scripted-diff: Rename sync_blocks to send_blocks to avoid name collisions and confusion
-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
parent
297ea51caf
commit
fa4680ed09
|
|
@ -98,7 +98,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
# Create a new block
|
||||
b0 = self.next_block(0)
|
||||
self.save_spendable_output()
|
||||
self.sync_blocks([b0])
|
||||
self.send_blocks([b0])
|
||||
|
||||
# These constants chosen specifically to trigger an immature coinbase spend
|
||||
# at a certain time below.
|
||||
|
|
@ -110,7 +110,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
for i in range(NUM_BUFFER_BLOCKS_TO_GENERATE):
|
||||
blocks.append(self.next_block("maturitybuffer.{}".format(i)))
|
||||
self.save_spendable_output()
|
||||
self.sync_blocks(blocks)
|
||||
self.send_blocks(blocks)
|
||||
|
||||
# collect spendable outputs now to avoid cluttering the code later on
|
||||
out = []
|
||||
|
|
@ -126,7 +126,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b2 = self.next_block(2, spend=out[1])
|
||||
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,
|
||||
# since we're testing submission of a series of blocks with invalid txns.
|
||||
|
|
@ -162,7 +162,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
badtx.vout = []
|
||||
badtx.rehash()
|
||||
badblock = self.update_block(blockname, [badtx])
|
||||
self.sync_blocks(
|
||||
self.send_blocks(
|
||||
[badblock], success=False,
|
||||
reject_reason=(template.block_reject_reason or template.reject_reason),
|
||||
reconnect=True, timeout=2)
|
||||
|
|
@ -179,7 +179,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.move_tip(1)
|
||||
b3 = self.next_block(3, spend=out[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.
|
||||
#
|
||||
|
|
@ -187,7 +187,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
# \-> b3 (1) -> b4 (2)
|
||||
self.log.info("Reorg to a longer chain")
|
||||
b4 = self.next_block(4, spend=out[2])
|
||||
self.sync_blocks([b4])
|
||||
self.send_blocks([b4])
|
||||
|
||||
# ... and back to the first chain.
|
||||
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
|
||||
|
|
@ -195,11 +195,11 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.move_tip(2)
|
||||
b5 = self.next_block(5, spend=out[2])
|
||||
self.save_spendable_output()
|
||||
self.sync_blocks([b5], False)
|
||||
self.send_blocks([b5], False)
|
||||
|
||||
self.log.info("Reorg back to the original chain")
|
||||
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
|
||||
# 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.move_tip(5)
|
||||
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])
|
||||
self.sync_blocks([b8], False, reconnect=True)
|
||||
self.send_blocks([b8], False, reconnect=True)
|
||||
|
||||
# Try to create a block that has too much fee
|
||||
# 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.move_tip(6)
|
||||
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)
|
||||
# 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.move_tip(5)
|
||||
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)
|
||||
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
|
||||
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
|
||||
|
|
@ -245,7 +245,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b13 = self.next_block(13, spend=out[4])
|
||||
self.save_spendable_output()
|
||||
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.
|
||||
assert_equal(node.getbestblockhash(), b13.hash)
|
||||
|
|
@ -259,12 +259,12 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.move_tip(13)
|
||||
b15 = self.next_block(15, spend=out[5], script=lots_of_checksigs)
|
||||
self.save_spendable_output()
|
||||
self.sync_blocks([b15], True)
|
||||
self.send_blocks([b15], True)
|
||||
|
||||
self.log.info("Reject a block with too many checksigs")
|
||||
too_many_checksigs = CScript([OP_CHECKSIG] * (MAX_BLOCK_SIGOPS))
|
||||
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
|
||||
# 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.move_tip(15)
|
||||
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)
|
||||
# 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.move_tip(13)
|
||||
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])
|
||||
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
|
||||
# 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.move_tip(15)
|
||||
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)
|
||||
# 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.move_tip(13)
|
||||
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])
|
||||
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
|
||||
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
|
||||
|
|
@ -326,7 +326,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
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)
|
||||
self.sync_blocks([b23], True)
|
||||
self.send_blocks([b23], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
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)]
|
||||
b24 = self.update_block(24, [tx])
|
||||
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])
|
||||
self.sync_blocks([b25], False)
|
||||
self.send_blocks([b25], False)
|
||||
|
||||
# Create blocks with a coinbase input script size out of range
|
||||
# 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
|
||||
# transactions, and updates the required state.
|
||||
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
|
||||
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
|
||||
self.move_tip(15)
|
||||
|
|
@ -367,11 +367,11 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
|
||||
b28.vtx[0].rehash()
|
||||
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
|
||||
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.
|
||||
self.move_tip(23)
|
||||
|
|
@ -379,7 +379,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b30.vtx[0].vin[0].scriptSig = b'\x00' * 100
|
||||
b30.vtx[0].rehash()
|
||||
b30 = self.update_block(30, [])
|
||||
self.sync_blocks([b30], True)
|
||||
self.send_blocks([b30], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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)
|
||||
b31 = self.next_block(31, spend=out[8], script=lots_of_multisigs)
|
||||
assert_equal(get_legacy_sigopcount_block(b31), MAX_BLOCK_SIGOPS)
|
||||
self.sync_blocks([b31], True)
|
||||
self.send_blocks([b31], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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))
|
||||
b32 = self.next_block(32, spend=out[9], script=too_many_multisigs)
|
||||
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
|
||||
self.log.info("Accept a block with the max number of OP_CHECKMULTISIGVERIFY sigops")
|
||||
self.move_tip(31)
|
||||
lots_of_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * ((MAX_BLOCK_SIGOPS - 1) // 20) + [OP_CHECKSIG] * 19)
|
||||
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.log.info("Reject a block with too many OP_CHECKMULTISIGVERIFY sigops")
|
||||
too_many_multisigs = CScript([OP_CHECKMULTISIGVERIFY] * (MAX_BLOCK_SIGOPS // 20))
|
||||
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
|
||||
self.log.info("Accept a block with the max number of OP_CHECKSIGVERIFY sigops")
|
||||
self.move_tip(33)
|
||||
lots_of_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS - 1))
|
||||
b35 = self.next_block(35, spend=out[10], script=lots_of_checksigs)
|
||||
self.sync_blocks([b35], True)
|
||||
self.send_blocks([b35], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
self.log.info("Reject a block with too many OP_CHECKSIGVERIFY sigops")
|
||||
too_many_checksigs = CScript([OP_CHECKSIGVERIFY] * (MAX_BLOCK_SIGOPS))
|
||||
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
|
||||
#
|
||||
|
|
@ -446,12 +446,12 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
txout_b37 = b37.vtx[1]
|
||||
tx = self.create_and_sign_transaction(out[11], 0)
|
||||
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
|
||||
self.move_tip(35)
|
||||
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
|
||||
#
|
||||
|
|
@ -501,7 +501,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b39_outputs += 1
|
||||
|
||||
b39 = self.update_block(39, [])
|
||||
self.sync_blocks([b39], True)
|
||||
self.send_blocks([b39], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# Test sigops in P2SH redeem scripts
|
||||
|
|
@ -543,7 +543,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
tx.rehash()
|
||||
new_txs.append(tx)
|
||||
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
|
||||
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.rehash()
|
||||
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
|
||||
#
|
||||
|
|
@ -569,7 +569,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
|
||||
b43 = self.next_block(43, spend=out[13])
|
||||
self.save_spendable_output()
|
||||
self.sync_blocks([b42, b43], True)
|
||||
self.send_blocks([b42, b43], True)
|
||||
|
||||
# Test a number of really invalid scenarios
|
||||
#
|
||||
|
|
@ -591,7 +591,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.tip = b44
|
||||
self.block_heights[b44.sha256] = height
|
||||
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")
|
||||
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.tip = 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.move_tip(44)
|
||||
|
|
@ -621,7 +621,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.tip = b46
|
||||
assert 46 not in self.blocks
|
||||
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.move_tip(44)
|
||||
|
|
@ -630,35 +630,35 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
while b47.sha256 < target:
|
||||
b47.nNonce += 1
|
||||
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.move_tip(44)
|
||||
b48 = self.next_block(48, solve=False)
|
||||
b48.nTime = int(time.time()) + 60 * 60 * 3
|
||||
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.move_tip(44)
|
||||
b49 = self.next_block(49)
|
||||
b49.hashMerkleRoot += 1
|
||||
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.move_tip(44)
|
||||
b50 = self.next_block(50)
|
||||
b50.nBits = b50.nBits - 1
|
||||
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.move_tip(44)
|
||||
b51 = self.next_block(51)
|
||||
cb2 = create_coinbase(51, self.coinbase_pubkey)
|
||||
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")
|
||||
# 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])
|
||||
tx = self.create_tx(b52.vtx[1], 0, 1)
|
||||
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
|
||||
# -> 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)
|
||||
b53 = self.next_block(53, spend=out[14])
|
||||
self.sync_blocks([b53], False)
|
||||
self.send_blocks([b53], False)
|
||||
self.save_spendable_output()
|
||||
|
||||
self.log.info("Reject a block with timestamp before MedianTimePast")
|
||||
b54 = self.next_block(54, spend=out[15])
|
||||
b54.nTime = b35.nTime - 1
|
||||
b54.solve()
|
||||
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
|
||||
self.move_tip(53)
|
||||
b55 = self.next_block(55, spend=out[15])
|
||||
b55.nTime = b35.nTime
|
||||
self.update_block(55, [])
|
||||
self.sync_blocks([b55], True)
|
||||
self.send_blocks([b55], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# Test Merkle tree malleability
|
||||
|
|
@ -733,7 +733,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
assert_equal(len(b56.vtx), 3)
|
||||
b56 = self.update_block(56, [tx1])
|
||||
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
|
||||
self.move_tip(55)
|
||||
|
|
@ -753,13 +753,13 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
assert_equal(b56p2.hash, b57p2.hash)
|
||||
assert_equal(len(b56p2.vtx), 6)
|
||||
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.sync_blocks([b57p2], True)
|
||||
self.send_blocks([b57p2], True)
|
||||
|
||||
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()
|
||||
|
||||
# Test a few invalid tx types
|
||||
|
|
@ -778,7 +778,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
tx.vout.append(CTxOut(0, b""))
|
||||
tx.calc_sha256()
|
||||
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
|
||||
self.log.info("Reject a block with a transaction with outputs > inputs")
|
||||
|
|
@ -786,12 +786,12 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b59 = self.next_block(59)
|
||||
tx = self.create_and_sign_transaction(out[17], 51 * COIN)
|
||||
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
|
||||
self.move_tip(57)
|
||||
b60 = self.next_block(60, spend=out[17])
|
||||
self.sync_blocks([b60], True)
|
||||
self.send_blocks([b60], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# Test BIP30
|
||||
|
|
@ -810,7 +810,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b61.vtx[0].rehash()
|
||||
b61 = self.update_block(61, [])
|
||||
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)
|
||||
#
|
||||
|
|
@ -827,7 +827,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
assert tx.vin[0].nSequence < 0xffffffff
|
||||
tx.calc_sha256()
|
||||
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
|
||||
#
|
||||
|
|
@ -841,7 +841,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
|
||||
b63.vtx[0].rehash()
|
||||
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
|
||||
# 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)))
|
||||
b64a = self.update_block("64a", [tx])
|
||||
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
|
||||
# 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)
|
||||
self.blocks[64] = b64
|
||||
b64 = self.update_block(64, [])
|
||||
self.sync_blocks([b64], True)
|
||||
self.send_blocks([b64], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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)
|
||||
tx2 = self.create_and_sign_transaction(tx1, 0)
|
||||
b65 = self.update_block(65, [tx1, tx2])
|
||||
self.sync_blocks([b65], True)
|
||||
self.send_blocks([b65], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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)
|
||||
tx2 = self.create_and_sign_transaction(tx1, 1)
|
||||
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
|
||||
#
|
||||
|
|
@ -932,7 +932,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
tx2 = self.create_and_sign_transaction(tx1, 1)
|
||||
tx3 = self.create_and_sign_transaction(tx1, 2)
|
||||
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
|
||||
#
|
||||
|
|
@ -951,14 +951,14 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b68 = self.next_block(68, additional_coinbase_value=10)
|
||||
tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 9)
|
||||
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.move_tip(65)
|
||||
b69 = self.next_block(69, additional_coinbase_value=10)
|
||||
tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 10)
|
||||
self.update_block(69, [tx])
|
||||
self.sync_blocks([b69], True)
|
||||
self.send_blocks([b69], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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.vout.append(CTxOut(1, b""))
|
||||
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)
|
||||
#
|
||||
|
|
@ -1000,10 +1000,10 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
assert_equal(b72.sha256, b71.sha256)
|
||||
|
||||
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.sync_blocks([b72], True)
|
||||
self.send_blocks([b72], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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))
|
||||
b73 = self.update_block(73, [tx])
|
||||
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,
|
||||
# but sigops after the element are not counted.
|
||||
|
|
@ -1062,7 +1062,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
a[MAX_BLOCK_SIGOPS + 4] = 0xff
|
||||
tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
|
||||
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)
|
||||
b75 = self.next_block(75)
|
||||
|
|
@ -1075,7 +1075,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
a[MAX_BLOCK_SIGOPS + 3] = 0xff
|
||||
tx = self.create_and_sign_transaction(out[22], 1, CScript(a))
|
||||
b75 = self.update_block(75, [tx])
|
||||
self.sync_blocks([b75], True)
|
||||
self.send_blocks([b75], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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
|
||||
tx = self.create_and_sign_transaction(out[23], 1, CScript(a))
|
||||
b76 = self.update_block(76, [tx])
|
||||
self.sync_blocks([b76], True)
|
||||
self.send_blocks([b76], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# Test transaction resurrection
|
||||
|
|
@ -1111,33 +1111,33 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b77 = self.next_block(77)
|
||||
tx77 = self.create_and_sign_transaction(out[24], 10 * COIN)
|
||||
b77 = self.update_block(77, [tx77])
|
||||
self.sync_blocks([b77], True)
|
||||
self.send_blocks([b77], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
b78 = self.next_block(78)
|
||||
tx78 = self.create_tx(tx77, 0, 9 * COIN)
|
||||
b78 = self.update_block(78, [tx78])
|
||||
self.sync_blocks([b78], True)
|
||||
self.send_blocks([b78], True)
|
||||
|
||||
b79 = self.next_block(79)
|
||||
tx79 = self.create_tx(tx78, 0, 8 * COIN)
|
||||
b79 = self.update_block(79, [tx79])
|
||||
self.sync_blocks([b79], True)
|
||||
self.send_blocks([b79], True)
|
||||
|
||||
# mempool should be empty
|
||||
assert_equal(len(self.nodes[0].getrawmempool()), 0)
|
||||
|
||||
self.move_tip(77)
|
||||
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()
|
||||
|
||||
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()
|
||||
|
||||
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()
|
||||
|
||||
# now check that tx78 and tx79 have been put back into the peer's mempool
|
||||
|
|
@ -1161,7 +1161,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
tx2.rehash()
|
||||
|
||||
b83 = self.update_block(83, [tx1, tx2])
|
||||
self.sync_blocks([b83], True)
|
||||
self.send_blocks([b83], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# 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]))
|
||||
|
||||
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.move_tip(83)
|
||||
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])
|
||||
self.sync_blocks([b86], True)
|
||||
self.send_blocks([b86], True)
|
||||
|
||||
self.move_tip(84)
|
||||
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()
|
||||
|
||||
b88 = self.next_block(88, spend=out[31])
|
||||
self.sync_blocks([b88], True)
|
||||
self.send_blocks([b88], True)
|
||||
self.save_spendable_output()
|
||||
|
||||
# trying to spend the OP_RETURN output is rejected
|
||||
b89a = self.next_block("89a", spend=out[32])
|
||||
tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
|
||||
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)")
|
||||
|
||||
|
|
@ -1232,7 +1232,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.save_spendable_output()
|
||||
spend = self.get_spendable_output()
|
||||
|
||||
self.sync_blocks(blocks, True, timeout=480)
|
||||
self.send_blocks(blocks, True, timeout=480)
|
||||
chain1_tip = i
|
||||
|
||||
# now create alt chain of same length
|
||||
|
|
@ -1240,22 +1240,22 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
blocks2 = []
|
||||
for i in range(89, LARGE_REORG_SIZE + 89):
|
||||
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
|
||||
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
|
||||
self.move_tip(chain1_tip)
|
||||
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)
|
||||
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")
|
||||
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)
|
||||
b_cb34 = self.next_block('b_cb34', version=4)
|
||||
|
|
@ -1263,7 +1263,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
b_cb34.vtx[0].rehash()
|
||||
b_cb34.hashMerkleRoot = b_cb34.calc_merkle_root()
|
||||
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
|
||||
################
|
||||
|
|
@ -1372,7 +1372,7 @@ class FullBlockTest(BitcoinTestFramework):
|
|||
self.nodes[0].disconnect_p2ps()
|
||||
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.
|
||||
|
||||
Call with success = False if the tip shouldn't advance to the most recent block."""
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
|
|||
block.solve()
|
||||
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.
|
||||
|
||||
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")
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'defined')
|
||||
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")
|
||||
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(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
|
||||
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")
|
||||
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(50, 536871169, test_blocks) # 0x20000101 (signalling ready)
|
||||
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")
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'locked_in')
|
||||
|
||||
# Generate 140 more version 4 blocks
|
||||
test_blocks = self.generate_blocks(140, 4)
|
||||
self.sync_blocks(test_blocks)
|
||||
self.send_blocks(test_blocks)
|
||||
|
||||
# Inputs at height = 572
|
||||
#
|
||||
|
|
@ -264,7 +264,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
|
|||
|
||||
# 2 more version 4 blocks
|
||||
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)")
|
||||
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
|
||||
success_txs.extend(all_rlt_txs(bip112txs_vary_nSequence_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.log.info("Test version 2 txs")
|
||||
|
|
@ -337,12 +337,12 @@ class BIP68_112_113Test(BitcoinTestFramework):
|
|||
# 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_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())
|
||||
|
||||
# 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)
|
||||
self.sync_blocks(test_blocks)
|
||||
self.send_blocks(test_blocks)
|
||||
assert_equal(get_bip9_status(self.nodes[0], 'csv')['status'], 'active')
|
||||
|
||||
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
|
||||
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
|
||||
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
|
||||
bip113tx_v1.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
|
||||
bip113signed1 = sign_transaction(self.nodes[0], bip113tx_v1)
|
||||
bip113tx_v2.nLockTime = self.last_block_time - 600 * 5 - 1 # < MTP of prior block
|
||||
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
|
||||
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())
|
||||
|
||||
# Next block height = 580 after 4 blocks of random version
|
||||
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("Test version 1 txs - all should still pass")
|
||||
|
||||
success_txs = []
|
||||
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.log.info("Test version 2 txs")
|
||||
|
||||
# All txs with SEQUENCE_LOCKTIME_DISABLE_FLAG set pass
|
||||
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())
|
||||
|
||||
# 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']]
|
||||
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']]
|
||||
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
|
||||
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
|
||||
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())
|
||||
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
|
||||
test_blocks = self.generate_blocks(1, 1234)
|
||||
self.sync_blocks(test_blocks)
|
||||
self.send_blocks(test_blocks)
|
||||
|
||||
# All BIP 68 txs should pass
|
||||
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.log.info("BIP 112 tests")
|
||||
self.log.info("Test version 1 txs")
|
||||
|
||||
# -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
|
||||
|
||||
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']]
|
||||
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())
|
||||
|
||||
# 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']]
|
||||
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")
|
||||
|
||||
# -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)
|
||||
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']]
|
||||
|
||||
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())
|
||||
|
||||
# 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 += [tx['tx'] for tx in bip112txs_vary_OP_CSV_9_v2 if not tx['sdf']]
|
||||
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
|
||||
fail_txs = [tx['tx'] for tx in bip112txs_vary_nSequence_v2 if tx['sdf']]
|
||||
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
|
||||
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']]
|
||||
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
|
||||
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']]
|
||||
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())
|
||||
|
||||
# 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)
|
||||
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())
|
||||
|
||||
# TODO: Test empty stack fails
|
||||
|
|
|
|||
Loading…
Reference in a new issue