[tests] Tidy up feature_block.py

- move all helper methods to the end
- remove block, create_tx and create_and_sign_tx shortcuts
- remove --runbarelyexpensive option, since it defaults to True and it's
unlikely that anyone ever runs the test with this option set to false.

1 files changed, 497 insertions, 508 deletions

diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index 59c336e11d..e026e85a3c 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -53,6 +53,8 @@ from test_framework.key import CECKey
 from test_framework.script import *
 import struct
 
+MAX_BLOCK_SIGOPS = 20000
+
 class PreviousSpendableOutput():
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
@@ -97,150 +99,45 @@ class FullBlockTest(ComparisonTestFramework):
         self.tip = None
         self.blocks = {}
 
-    def add_options(self, parser):
-        super().add_options(parser)
-        parser.add_option("--runbarelyexpensive", dest="runbarelyexpensive", default=True)
-
     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 add_transactions_to_block(self, block, tx_list):
-        [tx.rehash() for tx in tx_list]
-        block.vtx.extend(tx_list)
-
-    # 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
-
-    # 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
-    def sign_tx(self, tx, spend_tx, n):
-        scriptPubKey = bytearray(spend_tx.vout[n].scriptPubKey)
-        if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
-            tx.vin[0].scriptSig = CScript()
-            return
-        (sighash, err) = SignatureHash(spend_tx.vout[n].scriptPubKey, tx, 0, SIGHASH_ALL)
-        tx.vin[0].scriptSig = CScript([self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL]))])
-
-    def create_and_sign_transaction(self, spend_tx, n, value, script=CScript([OP_TRUE])):
-        tx = self.create_tx(spend_tx, n, value, script)
-        self.sign_tx(tx, spend_tx, n)
-        tx.rehash()
-        return tx
-
-    def next_block(self, number, spend=None, additional_coinbase_value=0, script=CScript([OP_TRUE]), solve=True):
-        if self.tip is None:
-            base_block_hash = self.genesis_hash
-            block_time = int(time.time()) + 1
-        else:
-            base_block_hash = self.tip.sha256
-            block_time = self.tip.nTime + 1
-        # First create the coinbase
-        height = self.block_heights[base_block_hash] + 1
-        coinbase = create_coinbase(height, self.coinbase_pubkey)
-        coinbase.vout[0].nValue += additional_coinbase_value
-        coinbase.rehash()
-        if spend is None:
-            block = create_block(base_block_hash, coinbase, block_time)
-        else:
-            coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1  # all but one satoshi to fees
-            coinbase.rehash()
-            block = create_block(base_block_hash, coinbase, block_time)
-            tx = create_transaction(spend.tx, spend.n, b"", 1, script)  # spend 1 satoshi
-            self.sign_tx(tx, spend.tx, spend.n)
-            self.add_transactions_to_block(block, [tx])
-            block.hashMerkleRoot = block.calc_merkle_root()
-        if solve:
-            block.solve()
-        self.tip = block
-        self.block_heights[block.sha256] = height
-        assert number not in self.blocks
-        self.blocks[number] = block
-        return block
-
     def get_tests(self):
         self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
         self.block_heights[self.genesis_hash] = 0
-        spendable_outputs = []
-
-        # save the current tip so it can be spent by a later block
-        def save_spendable_output():
-            spendable_outputs.append(self.tip)
-
-        # get an output that we previously marked as spendable
-        def get_spendable_output():
-            return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
-
-        # returns a test case that asserts that the current tip was accepted
-        def accepted():
-            return TestInstance([[self.tip, True]])
-
-        # returns a test case that asserts that the current tip was rejected
-        def rejected(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 tip(number):
-            self.tip = self.blocks[number]
-
-        # adds transactions to the block and updates state
-        def update_block(block_number, new_transactions):
-            block = self.blocks[block_number]
-            self.add_transactions_to_block(block, new_transactions)
-            old_sha256 = block.sha256
-            block.hashMerkleRoot = block.calc_merkle_root()
-            block.solve()
-            # Update the internal state just like in next_block
-            self.tip = block
-            if block.sha256 != old_sha256:
-                self.block_heights[block.sha256] = self.block_heights[old_sha256]
-                del self.block_heights[old_sha256]
-            self.blocks[block_number] = block
-            return block
-
-        # shorthand for functions
-        block = self.next_block
-        create_tx = self.create_tx
-        create_and_sign_tx = self.create_and_sign_transaction
-
-        # these must be updated if consensus changes
-        MAX_BLOCK_SIGOPS = 20000
+        self.spendable_outputs = []
 
         # Create a new block
-        block(0)
-        save_spendable_output()
-        yield accepted()
+        self.next_block(0)
+        self.save_spendable_output()
+        yield self.accepted()
 
         #  Now we need that block to mature so we can spend the coinbase.
         test = TestInstance(sync_every_block=False)
         for i in range(99):
-            block(5000 + i)
+            self.next_block(5000 + i)
             test.blocks_and_transactions.append([self.tip, True])
-            save_spendable_output()
+            self.save_spendable_output()
         yield test
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
         for i in range(33):
-            out.append(get_spendable_output())
+            out.append(self.get_spendable_output())
 
         # Start by building a couple of blocks on top (which output is spent is
         # in parentheses):
         #     genesis -> b1 (0) -> b2 (1)
-        block(1, spend=out[0])
-        save_spendable_output()
-        yield accepted()
+        self.next_block(1, spend=out[0])
+        self.save_spendable_output()
+        yield self.accepted()
 
-        block(2, spend=out[1])
-        yield accepted()
-        save_spendable_output()
+        self.next_block(2, spend=out[1])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # so fork like this:
         #
@@ -248,77 +145,77 @@ class FullBlockTest(ComparisonTestFramework):
         #                      \-> b3 (1)
         #
         # Nothing should happen at this point. We saw b2 first so it takes priority.
-        tip(1)
-        b3 = block(3, spend=out[1])
+        self.move_tip(1)
+        b3 = self.next_block(3, spend=out[1])
         txout_b3 = PreviousSpendableOutput(b3.vtx[1], 0)
-        yield rejected()
+        yield self.rejected()
 
         # Now we add another block to make the alternative chain longer.
         #
         #     genesis -> b1 (0) -> b2 (1)
         #                      \-> b3 (1) -> b4 (2)
-        block(4, spend=out[2])
-        yield accepted()
+        self.next_block(4, spend=out[2])
+        yield self.accepted()
 
         # ... and back to the first chain.
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                      \-> b3 (1) -> b4 (2)
-        tip(2)
-        block(5, spend=out[2])
-        save_spendable_output()
-        yield rejected()
+        self.move_tip(2)
+        self.next_block(5, spend=out[2])
+        self.save_spendable_output()
+        yield self.rejected()
 
-        block(6, spend=out[3])
-        yield accepted()
+        self.next_block(6, spend=out[3])
+        yield self.accepted()
 
         # Try to create a fork that double-spends
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                          \-> b7 (2) -> b8 (4)
         #                      \-> b3 (1) -> b4 (2)
-        tip(5)
-        block(7, spend=out[2])
-        yield rejected()
+        self.move_tip(5)
+        self.next_block(7, spend=out[2])
+        yield self.rejected()
 
-        block(8, spend=out[4])
-        yield rejected()
+        self.next_block(8, spend=out[4])
+        yield self.rejected()
 
         # Try to create a block that has too much fee
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
         #                                                    \-> b9 (4)
         #                      \-> b3 (1) -> b4 (2)
-        tip(6)
-        block(9, spend=out[4], additional_coinbase_value=1)
-        yield rejected(RejectResult(16, b'bad-cb-amount'))
+        self.move_tip(6)
+        self.next_block(9, spend=out[4], additional_coinbase_value=1)
+        yield self.rejected(RejectResult(16, b'bad-cb-amount'))
 
         # 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)
         #                                          \-> b10 (3) -> b11 (4)
         #                      \-> b3 (1) -> b4 (2)
-        tip(5)
-        block(10, spend=out[3])
-        yield rejected()
+        self.move_tip(5)
+        self.next_block(10, spend=out[3])
+        yield self.rejected()
 
-        block(11, spend=out[4], additional_coinbase_value=1)
-        yield rejected(RejectResult(16, b'bad-cb-amount'))
+        self.next_block(11, spend=out[4], additional_coinbase_value=1)
+        yield self.rejected(RejectResult(16, b'bad-cb-amount'))
 
         # 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)
-        tip(5)
-        b12 = block(12, spend=out[3])
-        save_spendable_output()
-        b13 = block(13, spend=out[4])
+        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]])
 
-        save_spendable_output()
+        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
-        block(14, spend=out[5], additional_coinbase_value=1)
-        yield rejected()
+        self.next_block(14, spend=out[5], additional_coinbase_value=1)
+        yield self.rejected()
 
         yield TestInstance([[b12, True, b13.sha256]])  # New tip should be b13.
 
@@ -329,125 +226,125 @@ class FullBlockTest(ComparisonTestFramework):
 
         # Test that a block with a lot of checksigs is okay
         lots_of_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS - 1))
-        tip(13)
-        block(15, spend=out[5], script=lots_of_checksigs)
-        yield accepted()
-        save_spendable_output()
+        self.move_tip(13)
+        self.next_block(15, spend=out[5], script=lots_of_checksigs)
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test that a block with too many checksigs is rejected
         too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS))
-        block(16, spend=out[6], script=too_many_checksigs)
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.next_block(16, spend=out[6], script=too_many_checksigs)
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # Attempt to spend a transaction created on a different fork
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b17 (b3.vtx[1])
         #                      \-> b3 (1) -> b4 (2)
-        tip(15)
-        block(17, spend=txout_b3)
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.move_tip(15)
+        self.next_block(17, spend=txout_b3)
+        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
 
         # Attempt to spend a transaction created on a different fork (on a fork this time)
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b18 (b3.vtx[1]) -> b19 (6)
         #                      \-> b3 (1) -> b4 (2)
-        tip(13)
-        block(18, spend=txout_b3)
-        yield rejected()
+        self.move_tip(13)
+        self.next_block(18, spend=txout_b3)
+        yield self.rejected()
 
-        block(19, spend=out[6])
-        yield rejected()
+        self.next_block(19, spend=out[6])
+        yield self.rejected()
 
         # Attempt to spend a coinbase at depth too low
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b20 (7)
         #                      \-> b3 (1) -> b4 (2)
-        tip(15)
-        block(20, spend=out[7])
-        yield rejected(RejectResult(16, b'bad-txns-premature-spend-of-coinbase'))
+        self.move_tip(15)
+        self.next_block(20, spend=out[7])
+        yield self.rejected(RejectResult(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)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5)
         #                                                                \-> b21 (6) -> b22 (5)
         #                      \-> b3 (1) -> b4 (2)
-        tip(13)
-        block(21, spend=out[6])
-        yield rejected()
+        self.move_tip(13)
+        self.next_block(21, spend=out[6])
+        yield self.rejected()
 
-        block(22, spend=out[5])
-        yield rejected()
+        self.next_block(22, spend=out[5])
+        yield self.rejected()
 
         # 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)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
         #                                                                           \-> b24 (6) -> b25 (7)
         #                      \-> b3 (1) -> b4 (2)
-        tip(15)
-        b23 = block(23, spend=out[6])
+        self.move_tip(15)
+        b23 = self.next_block(23, spend=out[6])
         tx = CTransaction()
         script_length = MAX_BLOCK_BASE_SIZE - len(b23.serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
-        b23 = update_block(23, [tx])
+        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 accepted()
-        save_spendable_output()
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Make the next block one byte bigger and check that it fails
-        tip(15)
-        b24 = block(24, spend=out[6])
+        self.move_tip(15)
+        b24 = self.next_block(24, spend=out[6])
         script_length = MAX_BLOCK_BASE_SIZE - len(b24.serialize()) - 69
         script_output = CScript([b'\x00' * (script_length + 1)])
         tx.vout = [CTxOut(0, script_output)]
-        b24 = update_block(24, [tx])
+        b24 = self.update_block(24, [tx])
         assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE + 1)
-        yield rejected(RejectResult(16, b'bad-blk-length'))
+        yield self.rejected(RejectResult(16, b'bad-blk-length'))
 
-        block(25, spend=out[7])
-        yield rejected()
+        self.next_block(25, spend=out[7])
+        yield self.rejected()
 
         # Create blocks with a coinbase input script size out of range
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6) -> b30 (7)
         #                                                                           \-> ... (6) -> ... (7)
         #                      \-> b3 (1) -> b4 (2)
-        tip(15)
-        b26 = block(26, spend=out[6])
+        self.move_tip(15)
+        b26 = self.next_block(26, spend=out[6])
         b26.vtx[0].vin[0].scriptSig = b'\x00'
         b26.vtx[0].rehash()
         # update_block causes the merkle root to get updated, even with no new
         # transactions, and updates the required state.
-        b26 = update_block(26, [])
-        yield rejected(RejectResult(16, b'bad-cb-length'))
+        b26 = self.update_block(26, [])
+        yield self.rejected(RejectResult(16, b'bad-cb-length'))
 
         # Extend the b26 chain to make sure bitcoind isn't accepting b26
-        block(27, spend=out[7])
-        yield rejected(False)
+        self.next_block(27, spend=out[7])
+        yield self.rejected(False)
 
         # Now try a too-large-coinbase script
-        tip(15)
-        b28 = block(28, spend=out[6])
+        self.move_tip(15)
+        b28 = self.next_block(28, spend=out[6])
         b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
         b28.vtx[0].rehash()
-        b28 = update_block(28, [])
-        yield rejected(RejectResult(16, b'bad-cb-length'))
+        b28 = self.update_block(28, [])
+        yield self.rejected(RejectResult(16, b'bad-cb-length'))
 
         # Extend the b28 chain to make sure bitcoind isn't accepting b28
-        block(29, spend=out[7])
-        yield rejected(False)
+        self.next_block(29, spend=out[7])
+        yield self.rejected(False)
 
         # b30 has a max-sized coinbase scriptSig.
-        tip(23)
-        b30 = block(30)
+        self.move_tip(23)
+        b30 = self.next_block(30)
         b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
         b30.vtx[0].rehash()
-        b30 = update_block(30, [])
-        yield accepted()
-        save_spendable_output()
+        b30 = self.update_block(30, [])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
         #
@@ -459,38 +356,38 @@ class FullBlockTest(ComparisonTestFramework):
 
         # MULTISIG: each op code counts as 20 sigops.  To create the edge case, pack another 19 sigops at the end.
         lots_of_multisigs = CScript([OP_CHECKMULTISIG] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
-        b31 = block(31, spend=out[8], script=lots_of_multisigs)
+        b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
         assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS)
-        yield accepted()
-        save_spendable_output()
+        yield self.accepted()
+        self.save_spendable_output()
 
         # this goes over the limit because the coinbase has one sigop
         too_many_multisigs = CScript([OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS // 20))
-        b32 = block(32, spend=out[9], script=too_many_multisigs)
+        b32 = self.next_block(32, spend=out[9], script=too_many_multisigs)
         assert_equal(get_legacy_sigopcount_block(b32), MAX_BLOCK_SIGOPS + 1)
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # CHECKMULTISIGVERIFY
-        tip(31)
+        self.move_tip(31)
         lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
-        block(33, spend=out[9], script=lots_of_multisigs)
-        yield accepted()
-        save_spendable_output()
+        self.next_block(33, spend=out[9], script=lots_of_multisigs)
+        yield self.accepted()
+        self.save_spendable_output()
 
         too_many_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS // 20))
-        block(34, spend=out[10], script=too_many_multisigs)
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.next_block(34, spend=out[10], script=too_many_multisigs)
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # CHECKSIGVERIFY
-        tip(33)
+        self.move_tip(33)
         lots_of_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS - 1))
-        b35 = block(35, spend=out[10], script=lots_of_checksigs)
-        yield accepted()
-        save_spendable_output()
+        b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
+        yield self.accepted()
+        self.save_spendable_output()
 
         too_many_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS))
-        block(36, spend=out[11], script=too_many_checksigs)
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.next_block(36, spend=out[11], script=too_many_checksigs)
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # Check spending of a transaction in a block which failed to connect
         #
@@ -501,17 +398,17 @@ class FullBlockTest(ComparisonTestFramework):
         #
 
         # save 37's spendable output, but then double-spend out11 to invalidate the block
-        tip(35)
-        b37 = block(37, spend=out[11])
+        self.move_tip(35)
+        b37 = self.next_block(37, spend=out[11])
         txout_b37 = PreviousSpendableOutput(b37.vtx[1], 0)
-        tx = create_and_sign_tx(out[11].tx, out[11].n, 0)
-        b37 = update_block(37, [tx])
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        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'))
 
         # attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid
-        tip(35)
-        block(38, spend=txout_b37)
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.move_tip(35)
+        self.next_block(38, spend=txout_b37)
+        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
 
         # Check P2SH SigOp counting
         #
@@ -524,8 +421,8 @@ class FullBlockTest(ComparisonTestFramework):
         #           redeem_script = COINBASE_PUBKEY, (OP_2DUP+OP_CHECKSIGVERIFY) * 5, OP_CHECKSIG
         #           p2sh_script = OP_HASH160, ripemd160(sha256(script)), OP_EQUAL
         #
-        tip(35)
-        b39 = block(39)
+        self.move_tip(35)
+        b39 = self.next_block(39)
         b39_outputs = 0
         b39_sigops_per_output = 6
 
@@ -537,11 +434,11 @@ class FullBlockTest(ComparisonTestFramework):
         # Create a transaction that spends one satoshi to the p2sh_script, the rest to OP_TRUE
         # This must be signed because it is spending a coinbase
         spend = out[11]
-        tx = create_tx(spend.tx, spend.n, 1, p2sh_script)
+        tx = self.create_tx(spend.tx, spend.n, 1, p2sh_script)
         tx.vout.append(CTxOut(spend.tx.vout[spend.n].nValue - 1, CScript([OP_TRUE])))
         self.sign_tx(tx, spend.tx, spend.n)
         tx.rehash()
-        b39 = update_block(39, [tx])
+        b39 = self.update_block(39, [tx])
         b39_outputs += 1
 
         # Until block is full, add tx's with 1 satoshi to p2sh_script, the rest to OP_TRUE
@@ -549,7 +446,7 @@ class FullBlockTest(ComparisonTestFramework):
         tx_last = tx
         total_size = len(b39.serialize())
         while(total_size < MAX_BLOCK_BASE_SIZE):
-            tx_new = create_tx(tx_last, 1, 1, p2sh_script)
+            tx_new = self.create_tx(tx_last, 1, 1, p2sh_script)
             tx_new.vout.append(CTxOut(tx_last.vout[1].nValue - 1, CScript([OP_TRUE])))
             tx_new.rehash()
             total_size += len(tx_new.serialize())
@@ -559,9 +456,9 @@ class FullBlockTest(ComparisonTestFramework):
             tx_last = tx_new
             b39_outputs += 1
 
-        b39 = update_block(39, [])
-        yield accepted()
-        save_spendable_output()
+        b39 = self.update_block(39, [])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test sigops in P2SH redeem scripts
         #
@@ -570,8 +467,8 @@ class FullBlockTest(ComparisonTestFramework):
         #
         # b41 does the same, less one, so it has the maximum sigops permitted.
         #
-        tip(39)
-        b40 = block(40, spend=out[12])
+        self.move_tip(39)
+        b40 = self.next_block(40, spend=out[12])
         sigops = get_legacy_sigopcount_block(b40)
         numTxes = (MAX_BLOCK_SIGOPS - sigops) // b39_sigops_per_output
         assert_equal(numTxes <= b39_outputs, True)
@@ -600,34 +497,34 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b40_sigops_to_fill)))
         tx.rehash()
         new_txs.append(tx)
-        update_block(40, new_txs)
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        self.update_block(40, new_txs)
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # same as b40, but one less sigop
-        tip(39)
-        block(41, spend=None)
-        update_block(41, b40.vtx[1:-1])
+        self.move_tip(39)
+        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()
         tx.vin.append(CTxIn(lastOutpoint, b''))
         tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
         tx.rehash()
-        update_block(41, [tx])
-        yield accepted()
+        self.update_block(41, [tx])
+        yield self.accepted()
 
         # Fork off of b39 to create a constant base again
         #
         # b23 (6) -> b30 (7) -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13)
         #                                                                  \-> b41 (12)
         #
-        tip(39)
-        block(42, spend=out[12])
-        yield rejected()
-        save_spendable_output()
+        self.move_tip(39)
+        self.next_block(42, spend=out[12])
+        yield self.rejected()
+        self.save_spendable_output()
 
-        block(43, spend=out[13])
-        yield accepted()
-        save_spendable_output()
+        self.next_block(43, spend=out[13])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test a number of really invalid scenarios
         #
@@ -648,10 +545,10 @@ class FullBlockTest(ComparisonTestFramework):
         self.tip = b44
         self.block_heights[b44.sha256] = height
         self.blocks[44] = b44
-        yield accepted()
+        yield self.accepted()
 
         # A block with a non-coinbase as the first tx
-        non_coinbase = create_tx(out[15].tx, out[15].n, 1)
+        non_coinbase = self.create_tx(out[15].tx, out[15].n, 1)
         b45 = CBlock()
         b45.nTime = self.tip.nTime + 1
         b45.hashPrevBlock = self.tip.sha256
@@ -663,10 +560,10 @@ class FullBlockTest(ComparisonTestFramework):
         self.block_heights[b45.sha256] = self.block_heights[self.tip.sha256] + 1
         self.tip = b45
         self.blocks[45] = b45
-        yield rejected(RejectResult(16, b'bad-cb-missing'))
+        yield self.rejected(RejectResult(16, b'bad-cb-missing'))
 
         # A block with no txns
-        tip(44)
+        self.move_tip(44)
         b46 = CBlock()
         b46.nTime = b44.nTime + 1
         b46.hashPrevBlock = b44.sha256
@@ -678,75 +575,75 @@ class FullBlockTest(ComparisonTestFramework):
         self.tip = b46
         assert 46 not in self.blocks
         self.blocks[46] = b46
-        yield rejected(RejectResult(16, b'bad-blk-length'))
+        yield self.rejected(RejectResult(16, b'bad-blk-length'))
 
         # A block with invalid work
-        tip(44)
-        b47 = block(47, solve=False)
+        self.move_tip(44)
+        b47 = self.next_block(47, solve=False)
         target = uint256_from_compact(b47.nBits)
         while b47.sha256 < target:  # changed > to <
             b47.nNonce += 1
             b47.rehash()
-        yield rejected(RejectResult(16, b'high-hash'))
+        yield self.rejected(RejectResult(16, b'high-hash'))
 
         # A block with timestamp > 2 hrs in the future
-        tip(44)
-        b48 = block(48, solve=False)
+        self.move_tip(44)
+        b48 = self.next_block(48, solve=False)
         b48.nTime = int(time.time()) + 60 * 60 * 3
         b48.solve()
-        yield rejected(RejectResult(16, b'time-too-new'))
+        yield self.rejected(RejectResult(16, b'time-too-new'))
 
         # A block with an invalid merkle hash
-        tip(44)
-        b49 = block(49)
+        self.move_tip(44)
+        b49 = self.next_block(49)
         b49.hashMerkleRoot += 1
         b49.solve()
-        yield rejected(RejectResult(16, b'bad-txnmrklroot'))
+        yield self.rejected(RejectResult(16, b'bad-txnmrklroot'))
 
         # A block with an incorrect POW limit
-        tip(44)
-        b50 = block(50)
+        self.move_tip(44)
+        b50 = self.next_block(50)
         b50.nBits = b50.nBits - 1
         b50.solve()
-        yield rejected(RejectResult(16, b'bad-diffbits'))
+        yield self.rejected(RejectResult(16, b'bad-diffbits'))
 
         # A block with two coinbase txns
-        tip(44)
-        block(51)
+        self.move_tip(44)
+        self.next_block(51)
         cb2 = create_coinbase(51, self.coinbase_pubkey)
-        update_block(51, [cb2])
-        yield rejected(RejectResult(16, b'bad-cb-multiple'))
+        self.update_block(51, [cb2])
+        yield self.rejected(RejectResult(16, b'bad-cb-multiple'))
 
         # A block w/ duplicate txns
         # Note: txns have to be in the right position in the merkle tree to trigger this error
-        tip(44)
-        b52 = block(52, spend=out[15])
-        tx = create_tx(b52.vtx[1], 0, 1)
-        b52 = update_block(52, [tx, tx])
-        yield rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.move_tip(44)
+        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'))
 
         # Test block timestamps
         #  -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
         #                                                                                   \-> b54 (15)
         #
-        tip(43)
-        block(53, spend=out[14])
-        yield rejected()  # rejected since b44 is at same height
-        save_spendable_output()
+        self.move_tip(43)
+        self.next_block(53, spend=out[14])
+        yield self.rejected()  # rejected since b44 is at same height
+        self.save_spendable_output()
 
         # invalid timestamp (b35 is 5 blocks back, so its time is MedianTimePast)
-        b54 = block(54, spend=out[15])
+        b54 = self.next_block(54, spend=out[15])
         b54.nTime = b35.nTime - 1
         b54.solve()
-        yield rejected(RejectResult(16, b'time-too-old'))
+        yield self.rejected(RejectResult(16, b'time-too-old'))
 
         # valid timestamp
-        tip(53)
-        b55 = block(55, spend=out[15])
+        self.move_tip(53)
+        b55 = self.next_block(55, spend=out[15])
         b55.nTime = b35.nTime
-        update_block(55, [])
-        yield accepted()
-        save_spendable_output()
+        self.update_block(55, [])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test CVE-2012-2459
         #
@@ -776,46 +673,46 @@ class FullBlockTest(ComparisonTestFramework):
         #  that the error was caught early, avoiding a DOS vulnerability.)
 
         # b57 - a good block with 2 txs, don't submit until end
-        tip(55)
-        b57 = block(57)
-        tx = create_and_sign_tx(out[16].tx, out[16].n, 1)
-        tx1 = create_tx(tx, 0, 1)
-        b57 = update_block(57, [tx, tx1])
+        self.move_tip(55)
+        b57 = self.next_block(57)
+        tx = self.create_and_sign_transaction(out[16].tx, out[16].n, 1)
+        tx1 = self.create_tx(tx, 0, 1)
+        b57 = self.update_block(57, [tx, tx1])
 
         # b56 - copy b57, add a duplicate tx
-        tip(55)
+        self.move_tip(55)
         b56 = copy.deepcopy(b57)
         self.blocks[56] = b56
         assert_equal(len(b56.vtx), 3)
-        b56 = update_block(56, [tx1])
+        b56 = self.update_block(56, [tx1])
         assert_equal(b56.hash, b57.hash)
-        yield rejected(RejectResult(16, b'bad-txns-duplicate'))
+        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
 
         # b57p2 - a good block with 6 tx'es, don't submit until end
-        tip(55)
-        b57p2 = block("57p2")
-        tx = create_and_sign_tx(out[16].tx, out[16].n, 1)
-        tx1 = create_tx(tx, 0, 1)
-        tx2 = create_tx(tx1, 0, 1)
-        tx3 = create_tx(tx2, 0, 1)
-        tx4 = create_tx(tx3, 0, 1)
-        b57p2 = update_block("57p2", [tx, tx1, tx2, tx3, tx4])
+        self.move_tip(55)
+        b57p2 = self.next_block("57p2")
+        tx = self.create_and_sign_transaction(out[16].tx, out[16].n, 1)
+        tx1 = self.create_tx(tx, 0, 1)
+        tx2 = self.create_tx(tx1, 0, 1)
+        tx3 = self.create_tx(tx2, 0, 1)
+        tx4 = self.create_tx(tx3, 0, 1)
+        b57p2 = self.update_block("57p2", [tx, tx1, tx2, tx3, tx4])
 
         # b56p2 - copy b57p2, duplicate two non-consecutive tx's
-        tip(55)
+        self.move_tip(55)
         b56p2 = copy.deepcopy(b57p2)
         self.blocks["b56p2"] = b56p2
         assert_equal(b56p2.hash, b57p2.hash)
         assert_equal(len(b56p2.vtx), 6)
-        b56p2 = update_block("b56p2", [tx3, tx4])
-        yield rejected(RejectResult(16, b'bad-txns-duplicate'))
+        b56p2 = self.update_block("b56p2", [tx3, tx4])
+        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
 
-        tip("57p2")
-        yield accepted()
+        self.move_tip("57p2")
+        yield self.accepted()
 
-        tip(57)
-        yield rejected()  # rejected because 57p2 seen first
-        save_spendable_output()
+        self.move_tip(57)
+        yield self.rejected()  # rejected because 57p2 seen first
+        self.save_spendable_output()
 
         # Test a few invalid tx types
         #
@@ -824,28 +721,28 @@ class FullBlockTest(ComparisonTestFramework):
         #
 
         # tx with prevout.n out of range
-        tip(57)
-        block(58, spend=out[17])
+        self.move_tip(57)
+        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()
-        update_block(58, [tx])
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.update_block(58, [tx])
+        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
 
         # tx with output value > input value out of range
-        tip(57)
-        block(59)
-        tx = create_and_sign_tx(out[17].tx, out[17].n, 51 * COIN)
-        update_block(59, [tx])
-        yield rejected(RejectResult(16, b'bad-txns-in-belowout'))
+        self.move_tip(57)
+        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'))
 
         # reset to good chain
-        tip(57)
-        b60 = block(60, spend=out[17])
-        yield accepted()
-        save_spendable_output()
+        self.move_tip(57)
+        b60 = self.next_block(60, spend=out[17])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test BIP30
         #
@@ -856,21 +753,21 @@ class FullBlockTest(ComparisonTestFramework):
         # not-fully-spent transaction in the same chain. To test, make identical coinbases;
         # the second one should be rejected.
         #
-        tip(60)
-        b61 = block(61, spend=out[18])
+        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].rehash()
-        b61 = update_block(61, [])
+        b61 = self.update_block(61, [])
         assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
-        yield rejected(RejectResult(16, b'bad-txns-BIP30'))
+        yield self.rejected(RejectResult(16, b'bad-txns-BIP30'))
 
         # Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
         #
         #   -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                     \-> b62 (18)
         #
-        tip(60)
-        block(62)
+        self.move_tip(60)
+        self.next_block(62)
         tx = CTransaction()
         tx.nLockTime = 0xffffffff  # this locktime is non-final
         assert(out[18].n < len(out[18].tx.vout))
@@ -878,21 +775,21 @@ class FullBlockTest(ComparisonTestFramework):
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
         assert(tx.vin[0].nSequence < 0xffffffff)
         tx.calc_sha256()
-        update_block(62, [tx])
-        yield rejected(RejectResult(16, b'bad-txns-nonfinal'))
+        self.update_block(62, [tx])
+        yield self.rejected(RejectResult(16, b'bad-txns-nonfinal'))
 
         # Test a non-final coinbase is also rejected
         #
         #   -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17)
         #                                                                                     \-> b63 (-)
         #
-        tip(60)
-        b63 = block(63)
+        self.move_tip(60)
+        b63 = self.next_block(63)
         b63.vtx[0].nLockTime = 0xffffffff
         b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
         b63.vtx[0].rehash()
-        b63 = update_block(63, [])
-        yield rejected(RejectResult(16, b'bad-txns-nonfinal'))
+        b63 = self.update_block(63, [])
+        yield self.rejected(RejectResult(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,
@@ -908,8 +805,8 @@ class FullBlockTest(ComparisonTestFramework):
         #  b64a is a bloated block (non-canonical varint)
         #  b64 is a good block (same as b64 but w/ canonical varint)
         #
-        tip(60)
-        regular_block = block("64a", spend=out[18])
+        self.move_tip(60)
+        regular_block = self.next_block("64a", spend=out[18])
 
         # make it a "broken_block," with non-canonical serialization
         b64a = CBrokenBlock(regular_block)
@@ -923,45 +820,45 @@ class FullBlockTest(ComparisonTestFramework):
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
-        b64a = update_block("64a", [tx])
+        b64a = self.update_block("64a", [tx])
         assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8)
         yield TestInstance([[self.tip, None]])
 
         # comptool workaround: to make sure b64 is delivered, manually erase b64a from blockstore
         self.test.block_store.erase(b64a.sha256)
 
-        tip(60)
+        self.move_tip(60)
         b64 = CBlock(b64a)
         b64.vtx = copy.deepcopy(b64a.vtx)
         assert_equal(b64.hash, b64a.hash)
         assert_equal(len(b64.serialize()), MAX_BLOCK_BASE_SIZE)
         self.blocks[64] = b64
-        update_block(64, [])
-        yield accepted()
-        save_spendable_output()
+        self.update_block(64, [])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Spend an output created in the block itself
         #
         # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
         #
-        tip(64)
-        block(65)
-        tx1 = create_and_sign_tx(out[19].tx, out[19].n, out[19].tx.vout[0].nValue)
-        tx2 = create_and_sign_tx(tx1, 0, 0)
-        update_block(65, [tx1, tx2])
-        yield accepted()
-        save_spendable_output()
+        self.move_tip(64)
+        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()
+        self.save_spendable_output()
 
         # Attempt to spend an output created later in the same block
         #
         # -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
         #                                                                                    \-> b66 (20)
-        tip(65)
-        block(66)
-        tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
-        tx2 = create_and_sign_tx(tx1, 0, 1)
-        update_block(66, [tx2, tx1])
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.move_tip(65)
+        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'))
 
         # Attempt to double-spend a transaction created in a block
         #
@@ -969,13 +866,13 @@ class FullBlockTest(ComparisonTestFramework):
         #                                                                                    \-> b67 (20)
         #
         #
-        tip(65)
-        block(67)
-        tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
-        tx2 = create_and_sign_tx(tx1, 0, 1)
-        tx3 = create_and_sign_tx(tx1, 0, 2)
-        update_block(67, [tx1, tx2, tx3])
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.move_tip(65)
+        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'))
 
         # More tests of block subsidy
         #
@@ -989,33 +886,33 @@ class FullBlockTest(ComparisonTestFramework):
         # b69 - coinbase with extra 10 satoshis, and a tx that gives a 10 satoshi fee
         #       this succeeds
         #
-        tip(65)
-        block(68, additional_coinbase_value=10)
-        tx = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 9)
-        update_block(68, [tx])
-        yield rejected(RejectResult(16, b'bad-cb-amount'))
+        self.move_tip(65)
+        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'))
 
-        tip(65)
-        b69 = block(69, additional_coinbase_value=10)
-        tx = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue - 10)
-        update_block(69, [tx])
-        yield accepted()
-        save_spendable_output()
+        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.save_spendable_output()
 
         # Test spending the outpoint of a non-existent transaction
         #
         # -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) -> b69 (20)
         #                                                                                    \-> b70 (21)
         #
-        tip(69)
-        block(70, spend=out[21])
+        self.move_tip(69)
+        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""))
-        update_block(70, [tx])
-        yield rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
+        self.update_block(70, [tx])
+        yield self.rejected(RejectResult(16, b'bad-txns-inputs-missingorspent'))
 
         # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
         #
@@ -1025,11 +922,11 @@ class FullBlockTest(ComparisonTestFramework):
         # 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.
         #
-        tip(69)
-        b72 = block(72)
-        tx1 = create_and_sign_tx(out[21].tx, out[21].n, 2)
-        tx2 = create_and_sign_tx(tx1, 0, 1)
-        b72 = update_block(72, [tx1, tx2])  # now tip is 72
+        self.move_tip(69)
+        b72 = self.next_block(72)
+        tx1 = self.create_and_sign_transaction(out[21].tx, out[21].n, 2)
+        tx2 = self.create_and_sign_transaction(tx1, 0, 1)
+        b72 = self.update_block(72, [tx1, tx2])  # now tip is 72
         b71 = copy.deepcopy(b72)
         b71.vtx.append(tx2)   # add duplicate tx2
         self.block_heights[b71.sha256] = self.block_heights[b69.sha256] + 1  # b71 builds off b69
@@ -1039,11 +936,11 @@ class FullBlockTest(ComparisonTestFramework):
         assert_equal(len(b72.vtx), 3)
         assert_equal(b72.sha256, b71.sha256)
 
-        tip(71)
-        yield rejected(RejectResult(16, b'bad-txns-duplicate'))
-        tip(72)
-        yield accepted()
-        save_spendable_output()
+        self.move_tip(71)
+        yield self.rejected(RejectResult(16, b'bad-txns-duplicate'))
+        self.move_tip(72)
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test some invalid scripts and MAX_BLOCK_SIGOPS
         #
@@ -1062,8 +959,8 @@ class FullBlockTest(ComparisonTestFramework):
         #       bytearray[20,004-20,525]: unread data (script_element)
         #       bytearray[20,526]       : OP_CHECKSIG (this puts us over the limit)
         #
-        tip(72)
-        b73 = block(73)
+        self.move_tip(72)
+        b73 = self.next_block(73)
         size = MAX_BLOCK_SIGOPS - 1 + MAX_SCRIPT_ELEMENT_SIZE + 1 + 5 + 1
         a = bytearray([OP_CHECKSIG] * size)
         a[MAX_BLOCK_SIGOPS - 1] = int("4e", 16)  # OP_PUSHDATA4
@@ -1074,10 +971,10 @@ class FullBlockTest(ComparisonTestFramework):
         a[MAX_BLOCK_SIGOPS + 2] = 0
         a[MAX_BLOCK_SIGOPS + 3] = 0
 
-        tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
-        b73 = update_block(73, [tx])
+        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 rejected(RejectResult(16, b'bad-blk-sigops'))
+        yield self.rejected(RejectResult(16, b'bad-blk-sigops'))
 
         # b74/75 - if we push an invalid script element, all prevous sigops are counted,
         #          but sigops after the element are not counted.
@@ -1091,8 +988,8 @@ class FullBlockTest(ComparisonTestFramework):
         #       b75 succeeds because we put MAX_BLOCK_SIGOPS before the element
         #
         #
-        tip(72)
-        block(74)
+        self.move_tip(72)
+        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
@@ -1100,12 +997,12 @@ class FullBlockTest(ComparisonTestFramework):
         a[MAX_BLOCK_SIGOPS + 2] = 0xff
         a[MAX_BLOCK_SIGOPS + 3] = 0xff
         a[MAX_BLOCK_SIGOPS + 4] = 0xff
-        tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
-        update_block(74, [tx])
-        yield rejected(RejectResult(16, b'bad-blk-sigops'))
+        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'))
 
-        tip(72)
-        block(75)
+        self.move_tip(72)
+        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
@@ -1113,21 +1010,21 @@ class FullBlockTest(ComparisonTestFramework):
         a[MAX_BLOCK_SIGOPS + 1] = 0xff
         a[MAX_BLOCK_SIGOPS + 2] = 0xff
         a[MAX_BLOCK_SIGOPS + 3] = 0xff
-        tx = create_and_sign_tx(out[22].tx, 0, 1, CScript(a))
-        update_block(75, [tx])
-        yield accepted()
-        save_spendable_output()
+        tx = self.create_and_sign_transaction(out[22].tx, 0, 1, CScript(a))
+        self.update_block(75, [tx])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Check that if we push an element filled with CHECKSIGs, they are not counted
-        tip(75)
-        block(76)
+        self.move_tip(75)
+        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 = create_and_sign_tx(out[23].tx, 0, 1, CScript(a))
-        update_block(76, [tx])
-        yield accepted()
-        save_spendable_output()
+        tx = self.create_and_sign_transaction(out[23].tx, 0, 1, CScript(a))
+        self.update_block(76, [tx])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Test transaction resurrection
         #
@@ -1147,38 +1044,38 @@ class FullBlockTest(ComparisonTestFramework):
         #    spend to OP_TRUE.  If the standard-ness rules change, this test would need to be
         #    updated.  (Perhaps to spend to a P2SH OP_TRUE script)
         #
-        tip(76)
-        block(77)
-        tx77 = create_and_sign_tx(out[24].tx, out[24].n, 10 * COIN)
-        update_block(77, [tx77])
-        yield accepted()
-        save_spendable_output()
+        self.move_tip(76)
+        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()
+        self.save_spendable_output()
 
-        block(78)
-        tx78 = create_tx(tx77, 0, 9 * COIN)
-        update_block(78, [tx78])
-        yield accepted()
+        self.next_block(78)
+        tx78 = self.create_tx(tx77, 0, 9 * COIN)
+        self.update_block(78, [tx78])
+        yield self.accepted()
 
-        block(79)
-        tx79 = create_tx(tx78, 0, 8 * COIN)
-        update_block(79, [tx79])
-        yield accepted()
+        self.next_block(79)
+        tx79 = self.create_tx(tx78, 0, 8 * COIN)
+        self.update_block(79, [tx79])
+        yield self.accepted()
 
         # mempool should be empty
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
 
-        tip(77)
-        block(80, spend=out[25])
-        yield rejected()
-        save_spendable_output()
+        self.move_tip(77)
+        self.next_block(80, spend=out[25])
+        yield self.rejected()
+        self.save_spendable_output()
 
-        block(81, spend=out[26])
-        yield rejected()  # other chain is same length
-        save_spendable_output()
+        self.next_block(81, spend=out[26])
+        yield self.rejected()  # other chain is same length
+        self.save_spendable_output()
 
-        block(82, spend=out[27])
-        yield accepted()  # now this chain is longer, triggers re-org
-        save_spendable_output()
+        self.next_block(82, spend=out[27])
+        yield self.accepted()  # 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
         mempool = self.nodes[0].getrawmempool()
@@ -1190,18 +1087,18 @@ class FullBlockTest(ComparisonTestFramework):
         #
         #  -> b81 (26) -> b82 (27) -> b83 (28)
         #
-        block(83)
+        self.next_block(83)
         op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
         script = CScript(op_codes)
-        tx1 = create_and_sign_tx(out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script)
+        tx1 = self.create_and_sign_transaction(out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script)
 
-        tx2 = create_and_sign_tx(tx1, 0, 0, CScript([OP_TRUE]))
+        tx2 = self.create_and_sign_transaction(tx1, 0, 0, CScript([OP_TRUE]))
         tx2.vin[0].scriptSig = CScript([OP_FALSE])
         tx2.rehash()
 
-        update_block(83, [tx1, tx2])
-        yield accepted()
-        save_spendable_output()
+        self.update_block(83, [tx1, tx2])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
         #
@@ -1209,8 +1106,8 @@ class FullBlockTest(ComparisonTestFramework):
         #                                    \-> b85 (29) -> b86 (30)            \-> b89a (32)
         #
         #
-        block(84)
-        tx1 = create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
+        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])))
         tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
@@ -1218,84 +1115,176 @@ class FullBlockTest(ComparisonTestFramework):
         tx1.calc_sha256()
         self.sign_tx(tx1, out[29].tx, out[29].n)
         tx1.rehash()
-        tx2 = create_tx(tx1, 1, 0, CScript([OP_RETURN]))
+        tx2 = self.create_tx(tx1, 1, 0, CScript([OP_RETURN]))
         tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
-        tx3 = create_tx(tx1, 2, 0, CScript([OP_RETURN]))
+        tx3 = self.create_tx(tx1, 2, 0, CScript([OP_RETURN]))
         tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        tx4 = create_tx(tx1, 3, 0, CScript([OP_TRUE]))
+        tx4 = self.create_tx(tx1, 3, 0, CScript([OP_TRUE]))
         tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
-        tx5 = create_tx(tx1, 4, 0, CScript([OP_RETURN]))
+        tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN]))
 
-        update_block(84, [tx1, tx2, tx3, tx4, tx5])
-        yield accepted()
-        save_spendable_output()
+        self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
+        yield self.accepted()
+        self.save_spendable_output()
 
-        tip(83)
-        block(85, spend=out[29])
-        yield rejected()
+        self.move_tip(83)
+        self.next_block(85, spend=out[29])
+        yield self.rejected()
 
-        block(86, spend=out[30])
-        yield accepted()
+        self.next_block(86, spend=out[30])
+        yield self.accepted()
 
-        tip(84)
-        block(87, spend=out[30])
-        yield rejected()
-        save_spendable_output()
+        self.move_tip(84)
+        self.next_block(87, spend=out[30])
+        yield self.rejected()
+        self.save_spendable_output()
 
-        block(88, spend=out[31])
-        yield accepted()
-        save_spendable_output()
+        self.next_block(88, spend=out[31])
+        yield self.accepted()
+        self.save_spendable_output()
 
         # trying to spend the OP_RETURN output is rejected
-        block("89a", spend=out[32])
-        tx = create_tx(tx1, 0, 0, CScript([OP_TRUE]))
-        update_block("89a", [tx])
-        yield rejected()
-
-        #  Test re-org of a week's worth of blocks (1088 blocks)
-        #  This test takes a minute or two and can be accomplished in memory
-        #
-        if self.options.runbarelyexpensive:
-            tip(88)
-            LARGE_REORG_SIZE = 1088
-            test1 = TestInstance(sync_every_block=False)
-            spend = out[32]
-            for i in range(89, LARGE_REORG_SIZE + 89):
-                b = block(i, spend)
-                tx = CTransaction()
-                script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 69
-                script_output = CScript([b'\x00' * script_length])
-                tx.vout.append(CTxOut(0, script_output))
-                tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
-                b = update_block(i, [tx])
-                assert_equal(len(b.serialize()), MAX_BLOCK_BASE_SIZE)
-                test1.blocks_and_transactions.append([self.tip, True])
-                save_spendable_output()
-                spend = get_spendable_output()
-
-            yield test1
-            chain1_tip = i
-
-            # now create alt chain of same length
-            tip(88)
-            test2 = TestInstance(sync_every_block=False)
-            for i in range(89, LARGE_REORG_SIZE + 89):
-                block("alt" + str(i))
-                test2.blocks_and_transactions.append([self.tip, False])
-            yield test2
-
-            # extend alt chain to trigger re-org
-            block("alt" + str(chain1_tip + 1))
-            yield accepted()
-
-            # ... and re-org back to the first chain
-            tip(chain1_tip)
-            block(chain1_tip + 1)
-            yield rejected()
-            block(chain1_tip + 2)
-            yield accepted()
-
-            chain1_tip += 2
+        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()
+
+        self.move_tip(88)
+        LARGE_REORG_SIZE = 1088
+        test1 = TestInstance(sync_every_block=False)
+        spend = out[32]
+        for i in range(89, LARGE_REORG_SIZE + 89):
+            b = self.next_block(i, spend)
+            tx = CTransaction()
+            script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 69
+            script_output = CScript([b'\x00' * script_length])
+            tx.vout.append(CTxOut(0, script_output))
+            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])
+            self.save_spendable_output()
+            spend = self.get_spendable_output()
+
+        yield test1
+        chain1_tip = i
+
+        # now create alt chain of same length
+        self.move_tip(88)
+        test2 = TestInstance(sync_every_block=False)
+        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
+
+        # extend alt chain to trigger re-org
+        self.next_block("alt" + str(chain1_tip + 1))
+        yield self.accepted()
+
+        # ... 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
+
+    # Helper methods
+    ################
+
+    def add_transactions_to_block(self, block, tx_list):
+        [tx.rehash() for tx in tx_list]
+        block.vtx.extend(tx_list)
+
+    # 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
+
+    # 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
+    def sign_tx(self, tx, spend_tx, n):
+        scriptPubKey = bytearray(spend_tx.vout[n].scriptPubKey)
+        if (scriptPubKey[0] == OP_TRUE):  # an anyone-can-spend
+            tx.vin[0].scriptSig = CScript()
+            return
+        (sighash, err) = SignatureHash(spend_tx.vout[n].scriptPubKey, tx, 0, SIGHASH_ALL)
+        tx.vin[0].scriptSig = CScript([self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL]))])
+
+    def create_and_sign_transaction(self, spend_tx, n, value, script=CScript([OP_TRUE])):
+        tx = self.create_tx(spend_tx, n, value, script)
+        self.sign_tx(tx, spend_tx, n)
+        tx.rehash()
+        return tx
+
+    def next_block(self, number, spend=None, additional_coinbase_value=0, script=CScript([OP_TRUE]), solve=True):
+        if self.tip is None:
+            base_block_hash = self.genesis_hash
+            block_time = int(time.time()) + 1
+        else:
+            base_block_hash = self.tip.sha256
+            block_time = self.tip.nTime + 1
+        # First create the coinbase
+        height = self.block_heights[base_block_hash] + 1
+        coinbase = create_coinbase(height, self.coinbase_pubkey)
+        coinbase.vout[0].nValue += additional_coinbase_value
+        coinbase.rehash()
+        if spend is None:
+            block = create_block(base_block_hash, coinbase, block_time)
+        else:
+            coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1  # all but one satoshi to fees
+            coinbase.rehash()
+            block = create_block(base_block_hash, coinbase, block_time)
+            tx = create_transaction(spend.tx, spend.n, b"", 1, script)  # spend 1 satoshi
+            self.sign_tx(tx, spend.tx, spend.n)
+            self.add_transactions_to_block(block, [tx])
+            block.hashMerkleRoot = block.calc_merkle_root()
+        if solve:
+            block.solve()
+        self.tip = block
+        self.block_heights[block.sha256] = height
+        assert number not in self.blocks
+        self.blocks[number] = block
+        return block
+
+    # save the current tip so it can be spent by a later block
+    def save_spendable_output(self):
+        self.spendable_outputs.append(self.tip)
+
+    # get an output that we previously marked as spendable
+    def get_spendable_output(self):
+        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]
+
+    # adds transactions to the block and updates state
+    def update_block(self, block_number, new_transactions):
+        block = self.blocks[block_number]
+        self.add_transactions_to_block(block, new_transactions)
+        old_sha256 = block.sha256
+        block.hashMerkleRoot = block.calc_merkle_root()
+        block.solve()
+        # Update the internal state just like in next_block
+        self.tip = block
+        if block.sha256 != old_sha256:
+            self.block_heights[block.sha256] = self.block_heights[old_sha256]
+            del self.block_heights[old_sha256]
+        self.blocks[block_number] = block
+        return block
 
 
 if __name__ == '__main__':