maxmustermann/dogecoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

scripted-diff: Rename sync_blocks to send_blocks to avoid name collisions and confusion

Browse source 
-BEGIN VERIFY SCRIPT-
FILE_LIST=$(git grep -l 'def sync_blocks' ./test/functional/*.py)
sed -i -e 's/def sync_blocks/def send_blocks/g'   $FILE_LIST
sed -i -e 's/self.sync_blocks/self.send_blocks/g' $FILE_LIST
-END VERIFY SCRIPT-
This commit is contained in:
MarcoFalke 2019-04-08 14:16:43 -04:00
parent 297ea51caf
commit fa4680ed09
No known key found for this signature in database
GPG key ID: CE2B75697E69A548
2 changed files with 130 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

198
test/functional/feature_block.py
View file

@ -98,7 +98,7 @@ class FullBlockTest(BitcoinTestFramework):
# Create a new block # Create a new block
b0 = self.next_block(0) b0 = self.next_block(0)
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks([b0]) self.send_blocks([b0])
# These constants chosen specifically to trigger an immature coinbase spend # These constants chosen specifically to trigger an immature coinbase spend
# at a certain time below. # at a certain time below.
@ -110,7 +110,7 @@ class FullBlockTest(BitcoinTestFramework):
for i in range(NUM_BUFFER_BLOCKS_TO_GENERATE): for i in range(NUM_BUFFER_BLOCKS_TO_GENERATE):
blocks.append(self.next_block("maturitybuffer.{}".format(i))) blocks.append(self.next_block("maturitybuffer.{}".format(i)))
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks(blocks) self.send_blocks(blocks)
# collect spendable outputs now to avoid cluttering the code later on # collect spendable outputs now to avoid cluttering the code later on
out = [] out = []
@ -126,7 +126,7 @@ class FullBlockTest(BitcoinTestFramework):
b2 = self.next_block(2, spend=out[1]) b2 = self.next_block(2, spend=out[1])
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks([b1, b2], timeout=4) self.send_blocks([b1, b2], timeout=4)
# Select a txn with an output eligible for spending. This won't actually be spent, # Select a txn with an output eligible for spending. This won't actually be spent,
# since we're testing submission of a series of blocks with invalid txns. # since we're testing submission of a series of blocks with invalid txns.
@ -162,7 +162,7 @@ class FullBlockTest(BitcoinTestFramework):
badtx.vout = [] badtx.vout = []
badtx.rehash() badtx.rehash()
badblock = self.update_block(blockname, [badtx]) badblock = self.update_block(blockname, [badtx])
self.sync_blocks( self.send_blocks(
[badblock], success=False, [badblock], success=False,
reject_reason=(template.block_reject_reason or template.reject_reason), reject_reason=(template.block_reject_reason or template.reject_reason),
reconnect=True, timeout=2) reconnect=True, timeout=2)
@ -179,7 +179,7 @@ class FullBlockTest(BitcoinTestFramework):
self.move_tip(1) self.move_tip(1)
b3 = self.next_block(3, spend=out[1]) b3 = self.next_block(3, spend=out[1])
txout_b3 = b3.vtx[1] txout_b3 = b3.vtx[1]
self.sync_blocks([b3], False) self.send_blocks([b3], False)
# Now we add another block to make the alternative chain longer. # Now we add another block to make the alternative chain longer.
# #
@ -187,7 +187,7 @@ class FullBlockTest(BitcoinTestFramework):
# \-> b3 (1) -> b4 (2) # \-> b3 (1) -> b4 (2)
self.log.info("Reorg to a longer chain") self.log.info("Reorg to a longer chain")
b4 = self.next_block(4, spend=out[2]) b4 = self.next_block(4, spend=out[2])
self.sync_blocks([b4]) self.send_blocks([b4])
# ... and back to the first chain. # ... and back to the first chain.
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -195,11 +195,11 @@ class FullBlockTest(BitcoinTestFramework):
self.move_tip(2) self.move_tip(2)
b5 = self.next_block(5, spend=out[2]) b5 = self.next_block(5, spend=out[2])
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks([b5], False) self.send_blocks([b5], False)
self.log.info("Reorg back to the original chain") self.log.info("Reorg back to the original chain")
b6 = self.next_block(6, spend=out[3]) b6 = self.next_block(6, spend=out[3])
self.sync_blocks([b6], True) self.send_blocks([b6], True)
# Try to create a fork that double-spends # Try to create a fork that double-spends
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -208,10 +208,10 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a chain with a double spend, even if it is longer") self.log.info("Reject a chain with a double spend, even if it is longer")
self.move_tip(5) self.move_tip(5)
b7 = self.next_block(7, spend=out[2]) b7 = self.next_block(7, spend=out[2])
self.sync_blocks([b7], False) self.send_blocks([b7], False)
b8 = self.next_block(8, spend=out[4]) b8 = self.next_block(8, spend=out[4])
self.sync_blocks([b8], False, reconnect=True) self.send_blocks([b8], False, reconnect=True)
# Try to create a block that has too much fee # Try to create a block that has too much fee
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -220,7 +220,7 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a block where the miner creates too much coinbase reward") self.log.info("Reject a block where the miner creates too much coinbase reward")
self.move_tip(6) self.move_tip(6)
b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1) b9 = self.next_block(9, spend=out[4], additional_coinbase_value=1)
self.sync_blocks([b9], success=False, reject_reason='bad-cb-amount', reconnect=True) self.send_blocks([b9], success=False, reject_reason='bad-cb-amount', reconnect=True)
# Create a fork that ends in a block with too much fee (the one that causes the reorg) # 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) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -229,10 +229,10 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a chain where the miner creates too much coinbase reward, even if the chain is longer") 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.move_tip(5)
b10 = self.next_block(10, spend=out[3]) b10 = self.next_block(10, spend=out[3])
self.sync_blocks([b10], False) self.send_blocks([b10], False)
b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1) b11 = self.next_block(11, spend=out[4], additional_coinbase_value=1)
self.sync_blocks([b11], success=False, reject_reason='bad-cb-amount', reconnect=True) self.send_blocks([b11], success=False, reject_reason='bad-cb-amount', reconnect=True)
# Try again, but with a valid fork first # Try again, but with a valid fork first
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -245,7 +245,7 @@ class FullBlockTest(BitcoinTestFramework):
b13 = self.next_block(13, spend=out[4]) b13 = self.next_block(13, spend=out[4])
self.save_spendable_output() self.save_spendable_output()
b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1) b14 = self.next_block(14, spend=out[5], additional_coinbase_value=1)
self.sync_blocks([b12, b13, b14], success=False, reject_reason='bad-cb-amount', reconnect=True) self.send_blocks([b12, b13, b14], success=False, reject_reason='bad-cb-amount', reconnect=True)
# New tip should be b13. # New tip should be b13.
assert_equal(node.getbestblockhash(), b13.hash) assert_equal(node.getbestblockhash(), b13.hash)
@ -259,12 +259,12 @@ class FullBlockTest(BitcoinTestFramework):
self.move_tip(13) self.move_tip(13)
b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs) b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks([b15], True) self.send_blocks([b15], True)
self.log.info("Reject a block with too many checksigs") self.log.info("Reject a block with too many checksigs")
too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS)) too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS))
b16 = self.next_block(16, spend=out[6], script=too_many_checksigs) b16 = self.next_block(16, spend=out[6], script=too_many_checksigs)
self.sync_blocks([b16], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b16], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# Attempt to spend a transaction created on a different fork # Attempt to spend a transaction created on a different fork
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -273,7 +273,7 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a block with a spend from a re-org'ed out tx") self.log.info("Reject a block with a spend from a re-org'ed out tx")
self.move_tip(15) self.move_tip(15)
b17 = self.next_block(17, spend=txout_b3) b17 = self.next_block(17, spend=txout_b3)
self.sync_blocks([b17], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b17], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to spend a transaction created on a different fork (on a fork this time) # Attempt to spend a transaction created on a different fork (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -283,10 +283,10 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a block with a spend from a re-org'ed out tx (on a forked chain)") 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.move_tip(13)
b18 = self.next_block(18, spend=txout_b3) b18 = self.next_block(18, spend=txout_b3)
self.sync_blocks([b18], False) self.send_blocks([b18], False)
b19 = self.next_block(19, spend=out[6]) b19 = self.next_block(19, spend=out[6])
self.sync_blocks([b19], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b19], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to spend a coinbase at depth too low # Attempt to spend a coinbase at depth too low
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -295,7 +295,7 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a block spending an immature coinbase.") self.log.info("Reject a block spending an immature coinbase.")
self.move_tip(15) self.move_tip(15)
b20 = self.next_block(20, spend=out[7]) b20 = self.next_block(20, spend=out[7])
self.sync_blocks([b20], success=False, reject_reason='bad-txns-premature-spend-of-coinbase') self.send_blocks([b20], success=False, reject_reason='bad-txns-premature-spend-of-coinbase')
# Attempt to spend a coinbase at depth too low (on a fork this time) # Attempt to spend a coinbase at depth too low (on a fork this time)
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -305,10 +305,10 @@ class FullBlockTest(BitcoinTestFramework):
self.log.info("Reject a block spending an immature coinbase (on a forked chain)") self.log.info("Reject a block spending an immature coinbase (on a forked chain)")
self.move_tip(13) self.move_tip(13)
b21 = self.next_block(21, spend=out[6]) b21 = self.next_block(21, spend=out[6])
self.sync_blocks([b21], False) self.send_blocks([b21], False)
b22 = self.next_block(22, spend=out[5]) b22 = self.next_block(22, spend=out[5])
self.sync_blocks([b22], success=False, reject_reason='bad-txns-premature-spend-of-coinbase') self.send_blocks([b22], success=False, reject_reason='bad-txns-premature-spend-of-coinbase')
# Create a block on either side of MAX_BLOCK_BASE_SIZE and make sure its accepted/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) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -326,7 +326,7 @@ class FullBlockTest(BitcoinTestFramework):
b23 = self.update_block(23, [tx]) b23 = self.update_block(23, [tx])
# Make sure the math above worked out to produce a max-sized block # Make sure the math above worked out to produce a max-sized block
assert_equal(len(b23.serialize()), MAX_BLOCK_BASE_SIZE) assert_equal(len(b23.serialize()), MAX_BLOCK_BASE_SIZE)
self.sync_blocks([b23], True) self.send_blocks([b23], True)
self.save_spendable_output() self.save_spendable_output()
self.log.info("Reject a block of size MAX_BLOCK_BASE_SIZE + 1") self.log.info("Reject a block of size MAX_BLOCK_BASE_SIZE + 1")
@ -337,10 +337,10 @@ class FullBlockTest(BitcoinTestFramework):
tx.vout = [CTxOut(0, script_output)] tx.vout = [CTxOut(0, script_output)]
b24 = self.update_block(24, [tx]) b24 = self.update_block(24, [tx])
assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE + 1) assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE + 1)
self.sync_blocks([b24], success=False, reject_reason='bad-blk-length', reconnect=True) self.send_blocks([b24], success=False, reject_reason='bad-blk-length', reconnect=True)
b25 = self.next_block(25, spend=out[7]) b25 = self.next_block(25, spend=out[7])
self.sync_blocks([b25], False) self.send_blocks([b25], False)
# Create blocks with a coinbase input script size out of range # Create blocks with a coinbase input script size out of range
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3) # genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@ -355,11 +355,11 @@ class FullBlockTest(BitcoinTestFramework):
# update_block causes the merkle root to get updated, even with no new # update_block causes the merkle root to get updated, even with no new
# transactions, and updates the required state. # transactions, and updates the required state.
b26 = self.update_block(26, []) b26 = self.update_block(26, [])
self.sync_blocks([b26], success=False, reject_reason='bad-cb-length', reconnect=True) self.send_blocks([b26], success=False, reject_reason='bad-cb-length', reconnect=True)
# Extend the b26 chain to make sure bitcoind isn't accepting b26 # Extend the b26 chain to make sure bitcoind isn't accepting b26
b27 = self.next_block(27, spend=out[7]) b27 = self.next_block(27, spend=out[7])
self.sync_blocks([b27], False) self.send_blocks([b27], False)
# Now try a too-large-coinbase script # Now try a too-large-coinbase script
self.move_tip(15) self.move_tip(15)
@ -367,11 +367,11 @@ class FullBlockTest(BitcoinTestFramework):
b28.vtx[0].vin[0].scriptSig = b'\x00' * 101 b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
b28.vtx[0].rehash() b28.vtx[0].rehash()
b28 = self.update_block(28, []) b28 = self.update_block(28, [])
self.sync_blocks([b28], success=False, reject_reason='bad-cb-length', reconnect=True) self.send_blocks([b28], success=False, reject_reason='bad-cb-length', reconnect=True)
# Extend the b28 chain to make sure bitcoind isn't accepting b28 # Extend the b28 chain to make sure bitcoind isn't accepting b28
b29 = self.next_block(29, spend=out[7]) b29 = self.next_block(29, spend=out[7])
self.sync_blocks([b29], False) self.send_blocks([b29], False)
# b30 has a max-sized coinbase scriptSig. # b30 has a max-sized coinbase scriptSig.
self.move_tip(23) self.move_tip(23)
@ -379,7 +379,7 @@ class FullBlockTest(BitcoinTestFramework):
b30.vtx[0].vin[0].scriptSig = b'\x00' * 100 b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
b30.vtx[0].rehash() b30.vtx[0].rehash()
b30 = self.update_block(30, []) b30 = self.update_block(30, [])
self.sync_blocks([b30], True) self.send_blocks([b30], True)
self.save_spendable_output() self.save_spendable_output()
# b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY # b31 - b35 - check sigops of OP_CHECKMULTISIG / OP_CHECKMULTISIGVERIFY / OP_CHECKSIGVERIFY
@ -395,7 +395,7 @@ class FullBlockTest(BitcoinTestFramework):
lots_of_multisigs = CScript([OP_CHECKMULTISIG] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19) 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) b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS) assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS)
self.sync_blocks([b31], True) self.send_blocks([b31], True)
self.save_spendable_output() self.save_spendable_output()
# this goes over the limit because the coinbase has one sigop # this goes over the limit because the coinbase has one sigop
@ -403,33 +403,33 @@ class FullBlockTest(BitcoinTestFramework):
too_many_multisigs = CScript([OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS // 20)) too_many_multisigs = CScript([OP_CHECKMULTISIG] * (MAX_BLOCK_SIGOPS // 20))
b32 = self.next_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) assert_equal(get_legacy_sigopcount_block(b32), MAX_BLOCK_SIGOPS + 1)
self.sync_blocks([b32], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b32], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# CHECKMULTISIGVERIFY # CHECKMULTISIGVERIFY
self.log.info("Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops") self.log.info("Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
self.move_tip(31) self.move_tip(31)
lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19) lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
b33 = self.next_block(33, spend=out[9], script=lots_of_multisigs) b33 = self.next_block(33, spend=out[9], script=lots_of_multisigs)
self.sync_blocks([b33], True) self.send_blocks([b33], True)
self.save_spendable_output() self.save_spendable_output()
self.log.info("Reject a block with too many OP_CHECKMULTISIGVERIFY sigops") self.log.info("Reject a block with too many OP_CHECKMULTISIGVERIFY sigops")
too_many_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS // 20)) too_many_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS // 20))
b34 = self.next_block(34, spend=out[10], script=too_many_multisigs) b34 = self.next_block(34, spend=out[10], script=too_many_multisigs)
self.sync_blocks([b34], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b34], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# CHECKSIGVERIFY # CHECKSIGVERIFY
self.log.info("Accept a block with the max number of OP_CHECKSIGVERIFY sigops") self.log.info("Accept a block with the max number of OP_CHECKSIGVERIFY sigops")
self.move_tip(33) self.move_tip(33)
lots_of_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS - 1)) lots_of_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS - 1))
b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs) b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
self.sync_blocks([b35], True) self.send_blocks([b35], True)
self.save_spendable_output() self.save_spendable_output()
self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops") self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops")
too_many_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS)) too_many_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS))
b36 = self.next_block(36, spend=out[11], script=too_many_checksigs) b36 = self.next_block(36, spend=out[11], script=too_many_checksigs)
self.sync_blocks([b36], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b36], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# Check spending of a transaction in a block which failed to connect # Check spending of a transaction in a block which failed to connect
# #
@ -446,12 +446,12 @@ class FullBlockTest(BitcoinTestFramework):
txout_b37 = b37.vtx[1] txout_b37 = b37.vtx[1]
tx = self.create_and_sign_transaction(out[11], 0) tx = self.create_and_sign_transaction(out[11], 0)
b37 = self.update_block(37, [tx]) b37 = self.update_block(37, [tx])
self.sync_blocks([b37], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b37], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid # attempt to spend b37's first non-coinbase tx, at which point b37 was still considered valid
self.move_tip(35) self.move_tip(35)
b38 = self.next_block(38, spend=txout_b37) b38 = self.next_block(38, spend=txout_b37)
self.sync_blocks([b38], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b38], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Check P2SH SigOp counting # Check P2SH SigOp counting
# #
@ -501,7 +501,7 @@ class FullBlockTest(BitcoinTestFramework):
b39_outputs += 1 b39_outputs += 1
b39 = self.update_block(39, []) b39 = self.update_block(39, [])
self.sync_blocks([b39], True) self.send_blocks([b39], True)
self.save_spendable_output() self.save_spendable_output()
# Test sigops in P2SH redeem scripts # Test sigops in P2SH redeem scripts
@ -543,7 +543,7 @@ class FullBlockTest(BitcoinTestFramework):
tx.rehash() tx.rehash()
new_txs.append(tx) new_txs.append(tx)
self.update_block(40, new_txs) self.update_block(40, new_txs)
self.sync_blocks([b40], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b40], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# same as b40, but one less sigop # same as b40, but one less sigop
self.log.info("Accept a block with the max number of P2SH sigops") self.log.info("Accept a block with the max number of P2SH sigops")
@ -556,7 +556,7 @@ class FullBlockTest(BitcoinTestFramework):
tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill))) tx.vout.append(CTxOut(1, CScript([OP_CHECKSIG] * b41_sigops_to_fill)))
tx.rehash() tx.rehash()
self.update_block(41, [tx]) self.update_block(41, [tx])
self.sync_blocks([b41], True) self.send_blocks([b41], True)
# Fork off of b39 to create a constant base again # Fork off of b39 to create a constant base again
# #
@ -569,7 +569,7 @@ class FullBlockTest(BitcoinTestFramework):
b43 = self.next_block(43, spend=out[13]) b43 = self.next_block(43, spend=out[13])
self.save_spendable_output() self.save_spendable_output()
self.sync_blocks([b42, b43], True) self.send_blocks([b42, b43], True)
# Test a number of really invalid scenarios # Test a number of really invalid scenarios
# #
@ -591,7 +591,7 @@ class FullBlockTest(BitcoinTestFramework):
self.tip = b44 self.tip = b44
self.block_heights[b44.sha256] = height self.block_heights[b44.sha256] = height
self.blocks[44] = b44 self.blocks[44] = b44
self.sync_blocks([b44], True) self.send_blocks([b44], True)
self.log.info("Reject a block with a non-coinbase as the first tx") self.log.info("Reject a block with a non-coinbase as the first tx")
non_coinbase = self.create_tx(out[15], 0, 1) non_coinbase = self.create_tx(out[15], 0, 1)
@ -606,7 +606,7 @@ class FullBlockTest(BitcoinTestFramework):
self.block_heights[b45.sha256] = self.block_heights[self.tip.sha256] + 1 self.block_heights[b45.sha256] = self.block_heights[self.tip.sha256] + 1
self.tip = b45 self.tip = b45
self.blocks[45] = b45 self.blocks[45] = b45
self.sync_blocks([b45], success=False, reject_reason='bad-cb-missing', reconnect=True) self.send_blocks([b45], success=False, reject_reason='bad-cb-missing', reconnect=True)
self.log.info("Reject a block with no transactions") self.log.info("Reject a block with no transactions")
self.move_tip(44) self.move_tip(44)
@ -621,7 +621,7 @@ class FullBlockTest(BitcoinTestFramework):
self.tip = b46 self.tip = b46
assert 46 not in self.blocks assert 46 not in self.blocks
self.blocks[46] = b46 self.blocks[46] = b46
self.sync_blocks([b46], success=False, reject_reason='bad-blk-length', reconnect=True) self.send_blocks([b46], success=False, reject_reason='bad-blk-length', reconnect=True)
self.log.info("Reject a block with invalid work") self.log.info("Reject a block with invalid work")
self.move_tip(44) self.move_tip(44)
@ -630,35 +630,35 @@ class FullBlockTest(BitcoinTestFramework):
while b47.sha256 < target: while b47.sha256 < target:
b47.nNonce += 1 b47.nNonce += 1
b47.rehash() b47.rehash()
self.sync_blocks([b47], False, force_send=True, reject_reason='high-hash') self.send_blocks([b47], False, force_send=True, reject_reason='high-hash')
self.log.info("Reject a block with a timestamp >2 hours in the future") self.log.info("Reject a block with a timestamp >2 hours in the future")
self.move_tip(44) self.move_tip(44)
b48 = self.next_block(48, solve=False) b48 = self.next_block(48, solve=False)
b48.nTime = int(time.time()) + 60 * 60 * 3 b48.nTime = int(time.time()) + 60 * 60 * 3
b48.solve() b48.solve()
self.sync_blocks([b48], False, force_send=True, reject_reason='time-too-new') self.send_blocks([b48], False, force_send=True, reject_reason='time-too-new')
self.log.info("Reject a block with invalid merkle hash") self.log.info("Reject a block with invalid merkle hash")
self.move_tip(44) self.move_tip(44)
b49 = self.next_block(49) b49 = self.next_block(49)
b49.hashMerkleRoot += 1 b49.hashMerkleRoot += 1
b49.solve() b49.solve()
self.sync_blocks([b49], success=False, reject_reason='bad-txnmrklroot', reconnect=True) self.send_blocks([b49], success=False, reject_reason='bad-txnmrklroot', reconnect=True)
self.log.info("Reject a block with incorrect POW limit") self.log.info("Reject a block with incorrect POW limit")
self.move_tip(44) self.move_tip(44)
b50 = self.next_block(50) b50 = self.next_block(50)
b50.nBits = b50.nBits - 1 b50.nBits = b50.nBits - 1
b50.solve() b50.solve()
self.sync_blocks([b50], False, force_send=True, reject_reason='bad-diffbits', reconnect=True) self.send_blocks([b50], False, force_send=True, reject_reason='bad-diffbits', reconnect=True)
self.log.info("Reject a block with two coinbase transactions") self.log.info("Reject a block with two coinbase transactions")
self.move_tip(44) self.move_tip(44)
b51 = self.next_block(51) b51 = self.next_block(51)
cb2 = create_coinbase(51, self.coinbase_pubkey) cb2 = create_coinbase(51, self.coinbase_pubkey)
b51 = self.update_block(51, [cb2]) b51 = self.update_block(51, [cb2])
self.sync_blocks([b51], success=False, reject_reason='bad-cb-multiple', reconnect=True) self.send_blocks([b51], success=False, reject_reason='bad-cb-multiple', reconnect=True)
self.log.info("Reject a block with duplicate transactions") 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 # Note: txns have to be in the right position in the merkle tree to trigger this error
@ -666,7 +666,7 @@ class FullBlockTest(BitcoinTestFramework):
b52 = self.next_block(52, spend=out[15]) b52 = self.next_block(52, spend=out[15])
tx = self.create_tx(b52.vtx[1], 0, 1) tx = self.create_tx(b52.vtx[1], 0, 1)
b52 = self.update_block(52, [tx, tx]) b52 = self.update_block(52, [tx, tx])
self.sync_blocks([b52], success=False, reject_reason='bad-txns-duplicate', reconnect=True) self.send_blocks([b52], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
# Test block timestamps # Test block timestamps
# -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) # -> b31 (8) -> b33 (9) -> b35 (10) -> b39 (11) -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15)
@ -674,21 +674,21 @@ class FullBlockTest(BitcoinTestFramework):
# #
self.move_tip(43) self.move_tip(43)
b53 = self.next_block(53, spend=out[14]) b53 = self.next_block(53, spend=out[14])
self.sync_blocks([b53], False) self.send_blocks([b53], False)
self.save_spendable_output() self.save_spendable_output()
self.log.info("Reject a block with timestamp before MedianTimePast") self.log.info("Reject a block with timestamp before MedianTimePast")
b54 = self.next_block(54, spend=out[15]) b54 = self.next_block(54, spend=out[15])
b54.nTime = b35.nTime - 1 b54.nTime = b35.nTime - 1
b54.solve() b54.solve()
self.sync_blocks([b54], False, force_send=True, reject_reason='time-too-old') self.send_blocks([b54], False, force_send=True, reject_reason='time-too-old')
# valid timestamp # valid timestamp
self.move_tip(53) self.move_tip(53)
b55 = self.next_block(55, spend=out[15]) b55 = self.next_block(55, spend=out[15])
b55.nTime = b35.nTime b55.nTime = b35.nTime
self.update_block(55, []) self.update_block(55, [])
self.sync_blocks([b55], True) self.send_blocks([b55], True)
self.save_spendable_output() self.save_spendable_output()
# Test Merkle tree malleability # Test Merkle tree malleability
@ -733,7 +733,7 @@ class FullBlockTest(BitcoinTestFramework):
assert_equal(len(b56.vtx), 3) assert_equal(len(b56.vtx), 3)
b56 = self.update_block(56, [tx1]) b56 = self.update_block(56, [tx1])
assert_equal(b56.hash, b57.hash) assert_equal(b56.hash, b57.hash)
self.sync_blocks([b56], success=False, reject_reason='bad-txns-duplicate', reconnect=True) self.send_blocks([b56], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
# b57p2 - a good block with 6 tx'es, don't submit until end # b57p2 - a good block with 6 tx'es, don't submit until end
self.move_tip(55) self.move_tip(55)
@ -753,13 +753,13 @@ class FullBlockTest(BitcoinTestFramework):
assert_equal(b56p2.hash, b57p2.hash) assert_equal(b56p2.hash, b57p2.hash)
assert_equal(len(b56p2.vtx), 6) assert_equal(len(b56p2.vtx), 6)
b56p2 = self.update_block("b56p2", [tx3, tx4]) b56p2 = self.update_block("b56p2", [tx3, tx4])
self.sync_blocks([b56p2], success=False, reject_reason='bad-txns-duplicate', reconnect=True) self.send_blocks([b56p2], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
self.move_tip("57p2") self.move_tip("57p2")
self.sync_blocks([b57p2], True) self.send_blocks([b57p2], True)
self.move_tip(57) self.move_tip(57)
self.sync_blocks([b57], False) # The tip is not updated because 57p2 seen first self.send_blocks([b57], False) # The tip is not updated because 57p2 seen first
self.save_spendable_output() self.save_spendable_output()
# Test a few invalid tx types # Test a few invalid tx types
@ -778,7 +778,7 @@ class FullBlockTest(BitcoinTestFramework):
tx.vout.append(CTxOut(0, b"")) tx.vout.append(CTxOut(0, b""))
tx.calc_sha256() tx.calc_sha256()
b58 = self.update_block(58, [tx]) b58 = self.update_block(58, [tx])
self.sync_blocks([b58], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b58], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# tx with output value > input value # tx with output value > input value
self.log.info("Reject a block with a transaction with outputs > inputs") self.log.info("Reject a block with a transaction with outputs > inputs")
@ -786,12 +786,12 @@ class FullBlockTest(BitcoinTestFramework):
b59 = self.next_block(59) b59 = self.next_block(59)
tx = self.create_and_sign_transaction(out[17], 51 * COIN) tx = self.create_and_sign_transaction(out[17], 51 * COIN)
b59 = self.update_block(59, [tx]) b59 = self.update_block(59, [tx])
self.sync_blocks([b59], success=False, reject_reason='bad-txns-in-belowout', reconnect=True) self.send_blocks([b59], success=False, reject_reason='bad-txns-in-belowout', reconnect=True)
# reset to good chain # reset to good chain
self.move_tip(57) self.move_tip(57)
b60 = self.next_block(60, spend=out[17]) b60 = self.next_block(60, spend=out[17])
self.sync_blocks([b60], True) self.send_blocks([b60], True)
self.save_spendable_output() self.save_spendable_output()
# Test BIP30 # Test BIP30
@ -810,7 +810,7 @@ class FullBlockTest(BitcoinTestFramework):
b61.vtx[0].rehash() b61.vtx[0].rehash()
b61 = self.update_block(61, []) b61 = self.update_block(61, [])
assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize()) assert_equal(b60.vtx[0].serialize(), b61.vtx[0].serialize())
self.sync_blocks([b61], success=False, reject_reason='bad-txns-BIP30', reconnect=True) self.send_blocks([b61], success=False, reject_reason='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) # Test tx.isFinal is properly rejected (not an exhaustive tx.isFinal test, that should be in data-driven transaction tests)
# #
@ -827,7 +827,7 @@ class FullBlockTest(BitcoinTestFramework):
assert tx.vin[0].nSequence < 0xffffffff assert tx.vin[0].nSequence < 0xffffffff
tx.calc_sha256() tx.calc_sha256()
b62 = self.update_block(62, [tx]) b62 = self.update_block(62, [tx])
self.sync_blocks([b62], success=False, reject_reason='bad-txns-nonfinal') self.send_blocks([b62], success=False, reject_reason='bad-txns-nonfinal')
# Test a non-final coinbase is also rejected # Test a non-final coinbase is also rejected
# #
@ -841,7 +841,7 @@ class FullBlockTest(BitcoinTestFramework):
b63.vtx[0].vin[0].nSequence = 0xDEADBEEF b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
b63.vtx[0].rehash() b63.vtx[0].rehash()
b63 = self.update_block(63, []) b63 = self.update_block(63, [])
self.sync_blocks([b63], success=False, reject_reason='bad-txns-nonfinal') self.send_blocks([b63], success=False, reject_reason='bad-txns-nonfinal')
# This checks that a block with a bloated VARINT between the block_header and the array of tx such that # 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, # the block is > MAX_BLOCK_BASE_SIZE with the bloated varint, but <= MAX_BLOCK_BASE_SIZE without the bloated varint,
@ -875,7 +875,7 @@ class FullBlockTest(BitcoinTestFramework):
tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0))) tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
b64a = self.update_block("64a", [tx]) b64a = self.update_block("64a", [tx])
assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8) assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8)
self.sync_blocks([b64a], success=False, reject_reason='non-canonical ReadCompactSize()') self.send_blocks([b64a], success=False, reject_reason='non-canonical ReadCompactSize()')
# bitcoind doesn't disconnect us for sending a bloated block, but if we subsequently # 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 # resend the header message, it won't send us the getdata message again. Just
@ -891,7 +891,7 @@ class FullBlockTest(BitcoinTestFramework):
assert_equal(len(b64.serialize()), MAX_BLOCK_BASE_SIZE) assert_equal(len(b64.serialize()), MAX_BLOCK_BASE_SIZE)
self.blocks[64] = b64 self.blocks[64] = b64
b64 = self.update_block(64, []) b64 = self.update_block(64, [])
self.sync_blocks([b64], True) self.send_blocks([b64], True)
self.save_spendable_output() self.save_spendable_output()
# Spend an output created in the block itself # Spend an output created in the block itself
@ -904,7 +904,7 @@ class FullBlockTest(BitcoinTestFramework):
tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue) tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue)
tx2 = self.create_and_sign_transaction(tx1, 0) tx2 = self.create_and_sign_transaction(tx1, 0)
b65 = self.update_block(65, [tx1, tx2]) b65 = self.update_block(65, [tx1, tx2])
self.sync_blocks([b65], True) self.send_blocks([b65], True)
self.save_spendable_output() self.save_spendable_output()
# Attempt to spend an output created later in the same block # Attempt to spend an output created later in the same block
@ -917,7 +917,7 @@ class FullBlockTest(BitcoinTestFramework):
tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue) tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
tx2 = self.create_and_sign_transaction(tx1, 1) tx2 = self.create_and_sign_transaction(tx1, 1)
b66 = self.update_block(66, [tx2, tx1]) b66 = self.update_block(66, [tx2, tx1])
self.sync_blocks([b66], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b66], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to double-spend a transaction created in a block # Attempt to double-spend a transaction created in a block
# #
@ -932,7 +932,7 @@ class FullBlockTest(BitcoinTestFramework):
tx2 = self.create_and_sign_transaction(tx1, 1) tx2 = self.create_and_sign_transaction(tx1, 1)
tx3 = self.create_and_sign_transaction(tx1, 2) tx3 = self.create_and_sign_transaction(tx1, 2)
b67 = self.update_block(67, [tx1, tx2, tx3]) b67 = self.update_block(67, [tx1, tx2, tx3])
self.sync_blocks([b67], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b67], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# More tests of block subsidy # More tests of block subsidy
# #
@ -951,14 +951,14 @@ class FullBlockTest(BitcoinTestFramework):
b68 = 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], out[20].vout[0].nValue - 9) tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 9)
b68 = self.update_block(68, [tx]) b68 = self.update_block(68, [tx])
self.sync_blocks([b68], success=False, reject_reason='bad-cb-amount', reconnect=True) self.send_blocks([b68], success=False, reject_reason='bad-cb-amount', reconnect=True)
self.log.info("Accept a block claiming the correct subsidy in the coinbase transaction") self.log.info("Accept a block claiming the correct subsidy in the coinbase transaction")
self.move_tip(65) self.move_tip(65)
b69 = self.next_block(69, additional_coinbase_value=10) b69 = self.next_block(69, additional_coinbase_value=10)
tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 10) tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 10)
self.update_block(69, [tx]) self.update_block(69, [tx])
self.sync_blocks([b69], True) self.send_blocks([b69], True)
self.save_spendable_output() self.save_spendable_output()
# Test spending the outpoint of a non-existent transaction # Test spending the outpoint of a non-existent transaction
@ -975,7 +975,7 @@ class FullBlockTest(BitcoinTestFramework):
tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff)) tx.vin.append(CTxIn(COutPoint(bogus_tx.sha256, 0), b"", 0xffffffff))
tx.vout.append(CTxOut(1, b"")) tx.vout.append(CTxOut(1, b""))
b70 = self.update_block(70, [tx]) b70 = self.update_block(70, [tx])
self.sync_blocks([b70], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b70], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks) # Test accepting an invalid block which has the same hash as a valid one (via merkle tree tricks)
# #
@ -1000,10 +1000,10 @@ class FullBlockTest(BitcoinTestFramework):
assert_equal(b72.sha256, b71.sha256) assert_equal(b72.sha256, b71.sha256)
self.move_tip(71) self.move_tip(71)
self.sync_blocks([b71], success=False, reject_reason='bad-txns-duplicate', reconnect=True) self.send_blocks([b71], success=False, reject_reason='bad-txns-duplicate', reconnect=True)
self.move_tip(72) self.move_tip(72)
self.sync_blocks([b72], True) self.send_blocks([b72], True)
self.save_spendable_output() self.save_spendable_output()
# Test some invalid scripts and MAX_BLOCK_SIGOPS # Test some invalid scripts and MAX_BLOCK_SIGOPS
@ -1038,7 +1038,7 @@ class FullBlockTest(BitcoinTestFramework):
tx = self.create_and_sign_transaction(out[22], 1, CScript(a)) tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
b73 = self.update_block(73, [tx]) b73 = self.update_block(73, [tx])
assert_equal(get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS + 1) assert_equal(get_legacy_sigopcount_block(b73), MAX_BLOCK_SIGOPS + 1)
self.sync_blocks([b73], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b73], success=False, reject_reason='bad-blk-sigops', reconnect=True)
# b74/75 - if we push an invalid script element, all previous sigops are counted, # b74/75 - if we push an invalid script element, all previous sigops are counted,
# but sigops after the element are not counted. # but sigops after the element are not counted.
@ -1062,7 +1062,7 @@ class FullBlockTest(BitcoinTestFramework):
a[MAX_BLOCK_SIGOPS + 4] = 0xff a[MAX_BLOCK_SIGOPS + 4] = 0xff
tx = self.create_and_sign_transaction(out[22], 1, CScript(a)) tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
b74 = self.update_block(74, [tx]) b74 = self.update_block(74, [tx])
self.sync_blocks([b74], success=False, reject_reason='bad-blk-sigops', reconnect=True) self.send_blocks([b74], success=False, reject_reason='bad-blk-sigops', reconnect=True)
self.move_tip(72) self.move_tip(72)
b75 = self.next_block(75) b75 = self.next_block(75)
@ -1075,7 +1075,7 @@ class FullBlockTest(BitcoinTestFramework):
a[MAX_BLOCK_SIGOPS + 3] = 0xff a[MAX_BLOCK_SIGOPS + 3] = 0xff
tx = self.create_and_sign_transaction(out[22], 1, CScript(a)) tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
b75 = self.update_block(75, [tx]) b75 = self.update_block(75, [tx])
self.sync_blocks([b75], True) self.send_blocks([b75], True)
self.save_spendable_output() self.save_spendable_output()
# Check that if we push an element filled with CHECKSIGs, they are not counted # Check that if we push an element filled with CHECKSIGs, they are not counted
@ -1086,7 +1086,7 @@ class FullBlockTest(BitcoinTestFramework):
a[MAX_BLOCK_SIGOPS - 1] = 0x4e # PUSHDATA4, but leave the following bytes as just checksigs a[MAX_BLOCK_SIGOPS - 1] = 0x4e # PUSHDATA4, but leave the following bytes as just checksigs
tx = self.create_and_sign_transaction(out[23], 1, CScript(a)) tx = self.create_and_sign_transaction(out[23], 1, CScript(a))
b76 = self.update_block(76, [tx]) b76 = self.update_block(76, [tx])
self.sync_blocks([b76], True) self.send_blocks([b76], True)
self.save_spendable_output() self.save_spendable_output()
# Test transaction resurrection # Test transaction resurrection
@ -1111,33 +1111,33 @@ class FullBlockTest(BitcoinTestFramework):
b77 = self.next_block(77) b77 = self.next_block(77)
tx77 = self.create_and_sign_transaction(out[24], 10 * COIN) tx77 = self.create_and_sign_transaction(out[24], 10 * COIN)
b77 = self.update_block(77, [tx77]) b77 = self.update_block(77, [tx77])
self.sync_blocks([b77], True) self.send_blocks([b77], True)
self.save_spendable_output() self.save_spendable_output()
b78 = self.next_block(78) b78 = self.next_block(78)
tx78 = self.create_tx(tx77, 0, 9 * COIN) tx78 = self.create_tx(tx77, 0, 9 * COIN)
b78 = self.update_block(78, [tx78]) b78 = self.update_block(78, [tx78])
self.sync_blocks([b78], True) self.send_blocks([b78], True)
b79 = self.next_block(79) b79 = self.next_block(79)
tx79 = self.create_tx(tx78, 0, 8 * COIN) tx79 = self.create_tx(tx78, 0, 8 * COIN)
b79 = self.update_block(79, [tx79]) b79 = self.update_block(79, [tx79])
self.sync_blocks([b79], True) self.send_blocks([b79], True)
# mempool should be empty # mempool should be empty
assert_equal(len(self.nodes[0].getrawmempool()), 0) assert_equal(len(self.nodes[0].getrawmempool()), 0)
self.move_tip(77) self.move_tip(77)
b80 = self.next_block(80, spend=out[25]) b80 = self.next_block(80, spend=out[25])
self.sync_blocks([b80], False, force_send=True) self.send_blocks([b80], False, force_send=True)
self.save_spendable_output() self.save_spendable_output()
b81 = self.next_block(81, spend=out[26]) b81 = self.next_block(81, spend=out[26])
self.sync_blocks([b81], False, force_send=True) # other chain is same length self.send_blocks([b81], False, force_send=True) # other chain is same length
self.save_spendable_output() self.save_spendable_output()
b82 = self.next_block(82, spend=out[27]) b82 = self.next_block(82, spend=out[27])
self.sync_blocks([b82], True) # now this chain is longer, triggers re-org self.send_blocks([b82], True) # now this chain is longer, triggers re-org
self.save_spendable_output() self.save_spendable_output()
# now check that tx78 and tx79 have been put back into the peer's mempool # now check that tx78 and tx79 have been put back into the peer's mempool
@ -1161,7 +1161,7 @@ class FullBlockTest(BitcoinTestFramework):
tx2.rehash() tx2.rehash()
b83 = self.update_block(83, [tx1, tx2]) b83 = self.update_block(83, [tx1, tx2])
self.sync_blocks([b83], True) self.send_blocks([b83], True)
self.save_spendable_output() self.save_spendable_output()
# Reorg on/off blocks that have OP_RETURN in them (and try to spend them) # Reorg on/off blocks that have OP_RETURN in them (and try to spend them)
@ -1188,30 +1188,30 @@ class FullBlockTest(BitcoinTestFramework):
tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN])) tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN]))
b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5]) b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
self.sync_blocks([b84], True) self.send_blocks([b84], True)
self.save_spendable_output() self.save_spendable_output()
self.move_tip(83) self.move_tip(83)
b85 = self.next_block(85, spend=out[29]) b85 = self.next_block(85, spend=out[29])
self.sync_blocks([b85], False) # other chain is same length self.send_blocks([b85], False) # other chain is same length
b86 = self.next_block(86, spend=out[30]) b86 = self.next_block(86, spend=out[30])
self.sync_blocks([b86], True) self.send_blocks([b86], True)
self.move_tip(84) self.move_tip(84)
b87 = self.next_block(87, spend=out[30]) b87 = self.next_block(87, spend=out[30])
self.sync_blocks([b87], False) # other chain is same length self.send_blocks([b87], False) # other chain is same length
self.save_spendable_output() self.save_spendable_output()
b88 = self.next_block(88, spend=out[31]) b88 = self.next_block(88, spend=out[31])
self.sync_blocks([b88], True) self.send_blocks([b88], True)
self.save_spendable_output() self.save_spendable_output()
# trying to spend the OP_RETURN output is rejected # trying to spend the OP_RETURN output is rejected
b89a = 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])) tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
b89a = self.update_block("89a", [tx]) b89a = self.update_block("89a", [tx])
self.sync_blocks([b89a], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True) self.send_blocks([b89a], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
self.log.info("Test a re-org of one week's worth of blocks (1088 blocks)") self.log.info("Test a re-org of one week's worth of blocks (1088 blocks)")
@ -1232,7 +1232,7 @@ class FullBlockTest(BitcoinTestFramework):
self.save_spendable_output() self.save_spendable_output()
spend = self.get_spendable_output() spend = self.get_spendable_output()
self.sync_blocks(blocks, True, timeout=480) self.send_blocks(blocks, True, timeout=480)
chain1_tip = i chain1_tip = i
# now create alt chain of same length # now create alt chain of same length
@ -1240,22 +1240,22 @@ class FullBlockTest(BitcoinTestFramework):
blocks2 = [] blocks2 = []
for i in range(89, LARGE_REORG_SIZE + 89): for i in range(89, LARGE_REORG_SIZE + 89):
blocks2.append(self.next_block("alt" + str(i), version=4)) blocks2.append(self.next_block("alt" + str(i), version=4))
self.sync_blocks(blocks2, False, force_send=True) self.send_blocks(blocks2, False, force_send=True)
# extend alt chain to trigger re-org # extend alt chain to trigger re-org
block = self.next_block("alt" + str(chain1_tip + 1), version=4) block = self.next_block("alt" + str(chain1_tip + 1), version=4)
self.sync_blocks([block], True, timeout=480) self.send_blocks([block], True, timeout=480)
# ... and re-org back to the first chain # ... and re-org back to the first chain
self.move_tip(chain1_tip) self.move_tip(chain1_tip)
block = self.next_block(chain1_tip + 1, version=4) block = self.next_block(chain1_tip + 1, version=4)
self.sync_blocks([block], False, force_send=True) self.send_blocks([block], False, force_send=True)
block = self.next_block(chain1_tip + 2, version=4) block = self.next_block(chain1_tip + 2, version=4)
self.sync_blocks([block], True, timeout=480) self.send_blocks([block], True, timeout=480)
self.log.info("Reject a block with an invalid block header version") self.log.info("Reject a block with an invalid block header version")
b_v1 = self.next_block('b_v1', version=1) b_v1 = self.next_block('b_v1', version=1)
self.sync_blocks([b_v1], success=False, force_send=True, reject_reason='bad-version(0x00000001)') self.send_blocks([b_v1], success=False, force_send=True, reject_reason='bad-version(0x00000001)')
self.move_tip(chain1_tip + 2) self.move_tip(chain1_tip + 2)
b_cb34 = self.next_block('b_cb34', version=4) b_cb34 = self.next_block('b_cb34', version=4)
@ -1263,7 +1263,7 @@ class FullBlockTest(BitcoinTestFramework):
b_cb34.vtx[0].rehash() b_cb34.vtx[0].rehash()
b_cb34.hashMerkleRoot = b_cb34.calc_merkle_root() b_cb34.hashMerkleRoot = b_cb34.calc_merkle_root()
b_cb34.solve() b_cb34.solve()
self.sync_blocks([b_cb34], success=False, reject_reason='bad-cb-height', reconnect=True) self.send_blocks([b_cb34], success=False, reject_reason='bad-cb-height', reconnect=True)
# Helper methods # Helper methods
################ ################
@ -1372,7 +1372,7 @@ class FullBlockTest(BitcoinTestFramework):
self.nodes[0].disconnect_p2ps() self.nodes[0].disconnect_p2ps()
self.bootstrap_p2p(timeout=timeout) self.bootstrap_p2p(timeout=timeout)
def sync_blocks(self, blocks, success=True, reject_reason=None, force_send=False, reconnect=False, timeout=60): def send_blocks(self, blocks, success=True, reject_reason=None, force_send=False, reconnect=False, timeout=60):
"""Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block. """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.""" Call with success = False if the tip shouldn't advance to the most recent block."""

62
test/functional/feature_csv_activation.py
View file

@ -168,7 +168,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
block.solve() block.solve()
return block return block
def sync_blocks(self, blocks, success=True): def send_blocks(self, blocks, success=True):
"""Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block. """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.""" Call with success = False if the tip shouldn't advance to the most recent block."""
@ -190,7 +190,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
self.log.info("Test that the csv softfork is DEFINED") self.log.info("Test that the csv softfork is DEFINED")
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'defined') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'defined')
test_blocks = self.generate_blocks(61, 4) test_blocks = self.generate_blocks(61, 4)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
self.log.info("Advance from DEFINED to STARTED, height = 143") self.log.info("Advance from DEFINED to STARTED, height = 143")
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started')
@ -202,7 +202,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
test_blocks = self.generate_blocks(20, 4, test_blocks) # 0x00000004 (signalling not) test_blocks = self.generate_blocks(20, 4, test_blocks) # 0x00000004 (signalling not)
test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready) test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
test_blocks = self.generate_blocks(24, 536936448, test_blocks) # 0x20010000 (signalling not) test_blocks = self.generate_blocks(24, 536936448, test_blocks) # 0x20010000 (signalling not)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
self.log.info("Failed to advance past STARTED, height = 287") self.log.info("Failed to advance past STARTED, height = 287")
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'started')
@ -214,14 +214,14 @@ class BIP68_112_113Test(BitcoinTestFramework):
test_blocks = self.generate_blocks(26, 4, test_blocks) # 0x00000004 (signalling not) test_blocks = self.generate_blocks(26, 4, test_blocks) # 0x00000004 (signalling not)
test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready) test_blocks = self.generate_blocks(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
test_blocks = self.generate_blocks(10, 536936448, test_blocks) # 0x20010000 (signalling not) test_blocks = self.generate_blocks(10, 536936448, test_blocks) # 0x20010000 (signalling not)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
self.log.info("Advanced from STARTED to LOCKED_IN, height = 431") self.log.info("Advanced from STARTED to LOCKED_IN, height = 431")
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in')
# Generate 140 more version 4 blocks # Generate 140 more version 4 blocks
test_blocks = self.generate_blocks(140, 4) test_blocks = self.generate_blocks(140, 4)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
# Inputs at height = 572 # Inputs at height = 572
# #
@ -264,7 +264,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
# 2 more version 4 blocks # 2 more version 4 blocks
test_blocks = self.generate_blocks(2, 4) test_blocks = self.generate_blocks(2, 4)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
self.log.info("Not yet advanced to ACTIVE, height = 574 (will activate for block 576, not 575)") self.log.info("Not yet advanced to ACTIVE, height = 574 (will activate for block 576, not 575)")
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in')
@ -318,7 +318,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
# try BIP 112 with seq=9 txs # try BIP 112 with seq=9 txs
success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v1)) success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v1))
success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v1)) success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v1))
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
self.log.info("Test version 2 txs") self.log.info("Test version 2 txs")
@ -337,12 +337,12 @@ class BIP68_112_113Test(BitcoinTestFramework):
# try BIP 112 with seq=9 txs # try BIP 112 with seq=9 txs
success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v2)) success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_9_v2))
success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v2)) success_txs.extend(all_rlt_txs(bip112txs_vary_OP_CSV_9_v2))
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# 1 more version 4 block to get us to height 575 so the fork should now be active for the next block # 1 more version 4 block to get us to height 575 so the fork should now be active for the next block
test_blocks = self.generate_blocks(1, 4) test_blocks = self.generate_blocks(1, 4)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'active') assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'active')
self.log.info("Post-Soft Fork Tests.") self.log.info("Post-Soft Fork Tests.")
@ -354,74 +354,74 @@ class BIP68_112_113Test(BitcoinTestFramework):
bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 # = MTP of prior block (not <) but < time put on current block
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2) bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
for bip113tx in [bip113signed1, bip113signed2]: for bip113tx in [bip113signed1, bip113signed2]:
self.sync_blocks([self.create_test_block([bip113tx])], success=False) self.send_blocks([self.create_test_block([bip113tx])], success=False)
# BIP 113 tests should now pass if the locktime is < MTP # BIP 113 tests should now pass if the locktime is < MTP
bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
bip113signed1 = sign_transaction(self.nodes[0], bip113tx_v1) bip113signed1 = sign_transaction(self.nodes[0], bip113tx_v1)
bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2) bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
for bip113tx in [bip113signed1, bip113signed2]: for bip113tx in [bip113signed1, bip113signed2]:
self.sync_blocks([self.create_test_block([bip113tx])]) self.send_blocks([self.create_test_block([bip113tx])])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# Next block height = 580 after 4 blocks of random version # Next block height = 580 after 4 blocks of random version
test_blocks = self.generate_blocks(4, 1234) test_blocks = self.generate_blocks(4, 1234)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
self.log.info("BIP 68 tests") self.log.info("BIP 68 tests")
self.log.info("Test version 1 txs - all should still pass") self.log.info("Test version 1 txs - all should still pass")
success_txs = [] success_txs = []
success_txs.extend(all_rlt_txs(bip68txs_v1)) success_txs.extend(all_rlt_txs(bip68txs_v1))
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
self.log.info("Test version 2 txs") self.log.info("Test version 2 txs")
# All txs with SEQUENCE_LOCKTIME_DISABLE_FLAG set pass # All txs with SEQUENCE_LOCKTIME_DISABLE_FLAG set pass
bip68success_txs = [tx['tx'] for tx in bip68txs_v2 if tx['sdf']] bip68success_txs = [tx['tx'] for tx in bip68txs_v2 if tx['sdf']]
self.sync_blocks([self.create_test_block(bip68success_txs)]) self.send_blocks([self.create_test_block(bip68success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# All txs without flag fail as we are at delta height = 8 < 10 and delta time = 8 * 600 < 10 * 512 # All txs without flag fail as we are at delta height = 8 < 10 and delta time = 8 * 600 < 10 * 512
bip68timetxs = [tx['tx'] for tx in bip68txs_v2 if not tx['sdf'] and tx['stf']] bip68timetxs = [tx['tx'] for tx in bip68txs_v2 if not tx['sdf'] and tx['stf']]
for tx in bip68timetxs: for tx in bip68timetxs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
bip68heighttxs = [tx['tx'] for tx in bip68txs_v2 if not tx['sdf'] and not tx['stf']] bip68heighttxs = [tx['tx'] for tx in bip68txs_v2 if not tx['sdf'] and not tx['stf']]
for tx in bip68heighttxs: for tx in bip68heighttxs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
# Advance one block to 581 # Advance one block to 581
test_blocks = self.generate_blocks(1, 1234) test_blocks = self.generate_blocks(1, 1234)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
# Height txs should fail and time txs should now pass 9 * 600 > 10 * 512 # Height txs should fail and time txs should now pass 9 * 600 > 10 * 512
bip68success_txs.extend(bip68timetxs) bip68success_txs.extend(bip68timetxs)
self.sync_blocks([self.create_test_block(bip68success_txs)]) self.send_blocks([self.create_test_block(bip68success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
for tx in bip68heighttxs: for tx in bip68heighttxs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
# Advance one block to 582 # Advance one block to 582
test_blocks = self.generate_blocks(1, 1234) test_blocks = self.generate_blocks(1, 1234)
self.sync_blocks(test_blocks) self.send_blocks(test_blocks)
# All BIP 68 txs should pass # All BIP 68 txs should pass
bip68success_txs.extend(bip68heighttxs) bip68success_txs.extend(bip68heighttxs)
self.sync_blocks([self.create_test_block(bip68success_txs)]) self.send_blocks([self.create_test_block(bip68success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
self.log.info("BIP 112 tests") self.log.info("BIP 112 tests")
self.log.info("Test version 1 txs") self.log.info("Test version 1 txs")
# -1 OP_CSV tx should fail # -1 OP_CSV tx should fail
self.sync_blocks([self.create_test_block([bip112tx_special_v1])], success=False) self.send_blocks([self.create_test_block([bip112tx_special_v1])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 1 txs should still pass # If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 1 txs should still pass
success_txs = [tx['tx'] for tx in bip112txs_vary_OP_CSV_v1 if tx['sdf']] success_txs = [tx['tx'] for tx in bip112txs_vary_OP_CSV_v1 if tx['sdf']]
success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if tx['sdf']] success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if tx['sdf']]
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV, version 1 txs should now fail # If SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV, version 1 txs should now fail
@ -430,18 +430,18 @@ class BIP68_112_113Test(BitcoinTestFramework):
fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if not tx['sdf']] fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if not tx['sdf']]
fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if not tx['sdf']] fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v1 if not tx['sdf']]
for tx in fail_txs: for tx in fail_txs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
self.log.info("Test version 2 txs") self.log.info("Test version 2 txs")
# -1 OP_CSV tx should fail # -1 OP_CSV tx should fail
self.sync_blocks([self.create_test_block([bip112tx_special_v2])], success=False) self.send_blocks([self.create_test_block([bip112tx_special_v2])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 2 txs should pass (all sequence locks are met) # If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV, version 2 txs should pass (all sequence locks are met)
success_txs = [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if tx['sdf']] success_txs = [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if tx['sdf']]
success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v2 if tx['sdf']] success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v2 if tx['sdf']]
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV for all remaining txs ## # SEQUENCE_LOCKTIME_DISABLE_FLAG is unset in argument to OP_CSV for all remaining txs ##
@ -450,23 +450,23 @@ class BIP68_112_113Test(BitcoinTestFramework):
fail_txs = all_rlt_txs(bip112txs_vary_nSequence_9_v2) fail_txs = all_rlt_txs(bip112txs_vary_nSequence_9_v2)
fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v2 if not tx['sdf']] fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v2 if not tx['sdf']]
for tx in fail_txs: for tx in fail_txs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in nSequence, tx should fail # If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in nSequence, tx should fail
fail_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if tx['sdf']] fail_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if tx['sdf']]
for tx in fail_txs: for tx in fail_txs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
# If sequencelock types mismatch, tx should fail # If sequencelock types mismatch, tx should fail
fail_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if not tx['sdf'] and tx['stf']] fail_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if not tx['sdf'] and tx['stf']]
fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and tx['stf']] fail_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and tx['stf']]
for tx in fail_txs: for tx in fail_txs:
self.sync_blocks([self.create_test_block([tx])], success=False) self.send_blocks([self.create_test_block([tx])], success=False)
# Remaining txs should pass, just test masking works properly # Remaining txs should pass, just test masking works properly
success_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if not tx['sdf'] and not tx['stf']] success_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if not tx['sdf'] and not tx['stf']]
success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and not tx['stf']] success_txs += [tx['tx'] for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and not tx['stf']]
self.sync_blocks([self.create_test_block(success_txs)]) self.send_blocks([self.create_test_block(success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# Additional test, of checking that comparison of two time types works properly # Additional test, of checking that comparison of two time types works properly
@ -476,7 +476,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
signtx = sign_transaction(self.nodes[0], tx) signtx = sign_transaction(self.nodes[0], tx)
time_txs.append(signtx) time_txs.append(signtx)
self.sync_blocks([self.create_test_block(time_txs)]) self.send_blocks([self.create_test_block(time_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash()) self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# TODO: Test empty stack fails # TODO: Test empty stack fails