diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -92,14 +92,14 @@
# Create a new block
b0 = self.next_block(0)
self.save_spendable_output()
- self.sync_blocks([b0])
+ self.send_blocks([b0])
# Allow the block to mature
blocks = []
for i in range(99):
blocks.append(self.next_block(5000 + 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 = []
@@ -115,7 +115,7 @@
b2 = self.next_block(2, spend=out[1])
self.save_spendable_output()
- self.sync_blocks([b1, b2])
+ self.send_blocks([b1, b2])
# Fork like this:
#
@@ -128,7 +128,7 @@
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.
#
@@ -136,7 +136,7 @@
# \-> 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)
@@ -144,11 +144,11 @@
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)
@@ -158,10 +158,10 @@
"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)
@@ -171,7 +171,7 @@
"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,
+ 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)
@@ -182,10 +182,10 @@
"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,
+ self.send_blocks([b11], success=False,
reject_reason='bad-cb-amount', reconnect=True)
# Try again, but with a valid fork first
@@ -200,7 +200,7 @@
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,
+ self.send_blocks([b12, b13, b14], success=False,
reject_reason='bad-cb-amount', reconnect=True)
# New tip should be b13.
@@ -211,7 +211,7 @@
self.move_tip(13)
b15 = self.next_block(15)
self.save_spendable_output()
- self.sync_blocks([b15], True)
+ self.send_blocks([b15], True)
# Attempt to spend a transaction created on a different fork
# genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6 (3)
@@ -220,7 +220,7 @@
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,
+ 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)
@@ -232,10 +232,10 @@
"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,
+ self.send_blocks([b19], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# Attempt to spend a coinbase at depth too low
@@ -245,7 +245,7 @@
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,
+ 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)
@@ -257,10 +257,10 @@
"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,
+ self.send_blocks([b22], success=False,
reject_reason='bad-txns-premature-spend-of-coinbase')
# Create a block on either side of LEGACY_MAX_BLOCK_SIZE and make sure its accepted/rejected
@@ -279,7 +279,7 @@
b23 = self.update_block(23, [tx])
# Make sure the math above worked out to produce a max-sized block
assert_equal(len(b23.serialize()), LEGACY_MAX_BLOCK_SIZE)
- self.sync_blocks([b23], True)
+ self.send_blocks([b23], True)
self.save_spendable_output()
# Create blocks with a coinbase input script size out of range
@@ -296,12 +296,12 @@
# 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,
+ 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)
@@ -309,12 +309,12 @@
b28.vtx[0].vin[0].scriptSig = b'\x00' * 101
b28.vtx[0].rehash()
b28 = self.update_block(28, [])
- self.sync_blocks([b28], success=False,
+ 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)
@@ -322,7 +322,7 @@
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()
self.log.info("Skipped sigops tests")
@@ -333,7 +333,7 @@
self.save_spendable_output()
b35 = self.next_block(35)
self.save_spendable_output()
- self.sync_blocks([b31, b33, b35], True)
+ self.send_blocks([b31, b33, b35], True)
# Check spending of a transaction in a block which failed to connect
#
@@ -352,14 +352,14 @@
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,
+ 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,
+ self.send_blocks([b38], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
self.log.info("Skipped sigops tests")
@@ -368,7 +368,7 @@
b39 = self.next_block(39)
self.save_spendable_output()
b41 = self.next_block(41)
- self.sync_blocks([b39, b41], True)
+ self.send_blocks([b39, b41], True)
# Fork off of b39 to create a constant base again
#
@@ -381,7 +381,7 @@
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
#
@@ -404,7 +404,7 @@
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)
@@ -420,7 +420,7 @@
self.tip.sha256] + 1
self.tip = b45
self.blocks[45] = b45
- self.sync_blocks([b45], success=False,
+ self.send_blocks([b45], success=False,
reject_reason='bad-cb-missing', reconnect=True)
self.log.info("Reject a block with no transactions")
@@ -436,7 +436,7 @@
self.tip = b46
assert 46 not in self.blocks
self.blocks[46] = b46
- self.sync_blocks([b46], success=False,
+ self.send_blocks([b46], success=False,
reject_reason='bad-cb-missing', reconnect=True)
self.log.info("Reject a block with invalid work")
@@ -446,21 +446,21 @@
while b47.sha256 < target:
b47.nNonce += 1
b47.rehash()
- self.sync_blocks([b47], False, request_block=False)
+ self.send_blocks([b47], False, request_block=False)
self.log.info("Reject a block with a timestamp >2 hours in the future")
self.move_tip(44)
b48 = self.next_block(48, solve=False)
b48.nTime = int(time.time()) + 60 * 60 * 3
b48.solve()
- self.sync_blocks([b48], False, request_block=False)
+ self.send_blocks([b48], False, request_block=False)
self.log.info("Reject a block with invalid merkle hash")
self.move_tip(44)
b49 = self.next_block(49)
b49.hashMerkleRoot += 1
b49.solve()
- self.sync_blocks([b49], success=False,
+ self.send_blocks([b49], success=False,
reject_reason='bad-txnmrklroot', reconnect=True)
self.log.info("Reject a block with incorrect POW limit")
@@ -468,21 +468,21 @@
b50 = self.next_block(50)
b50.nBits = b50.nBits - 1
b50.solve()
- self.sync_blocks([b50], False, request_block=False, reconnect=True)
+ self.send_blocks([b50], False, request_block=False, 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,
+ self.send_blocks([b51], success=False,
reject_reason='bad-tx-coinbase', reconnect=True)
self.log.info("Reject a block with duplicate transactions")
self.move_tip(44)
b52 = self.next_block(52, spend=out[15])
b52 = self.update_block(52, [b52.vtx[1]])
- self.sync_blocks([b52], success=False,
+ self.send_blocks([b52], success=False,
reject_reason='tx-duplicate', reconnect=True)
# Test block timestamps
@@ -491,21 +491,21 @@
#
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, request_block=False)
+ self.send_blocks([b54], False, request_block=False)
# valid timestamp
self.move_tip(53)
b55 = self.next_block(55, spend=out[15])
b55.nTime = b35.nTime
self.update_block(55, [])
- self.sync_blocks([b55], True)
+ self.send_blocks([b55], True)
self.save_spendable_output()
# Test Merkle tree malleability
@@ -551,7 +551,7 @@
assert_equal(len(b56.vtx), 3)
b56 = self.update_block(56, [b57.vtx[2]])
assert_equal(b56.hash, b57.hash)
- self.sync_blocks([b56], success=False,
+ 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
@@ -573,15 +573,15 @@
assert_equal(len(b56p2.vtx), 6)
b56p2 = self.update_block("b56p2", b56p2.vtx[4:6], reorder=False)
assert_equal(b56p2.hash, b57p2.hash)
- self.sync_blocks([b56p2], success=False,
+ 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)
# The tip is not updated because 57p2 seen first
- self.sync_blocks([b57], False)
+ self.send_blocks([b57], False)
self.save_spendable_output()
# Test a few invalid tx types
@@ -603,7 +603,7 @@
pad_tx(tx)
tx.calc_sha256()
b58 = self.update_block(58, [tx])
- self.sync_blocks([b58], success=False,
+ self.send_blocks([b58], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# tx with output value > input value
@@ -613,13 +613,13 @@
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,
+ 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
@@ -640,7 +640,7 @@
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,
+ 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)
@@ -660,7 +660,7 @@
assert tx.vin[0].nSequence < 0xffffffff
tx.calc_sha256()
b62 = self.update_block(62, [tx])
- self.sync_blocks([b62], success=False,
+ self.send_blocks([b62], success=False,
reject_reason='bad-txns-nonfinal')
# Test a non-final coinbase is also rejected
@@ -676,7 +676,7 @@
b63.vtx[0].vin[0].nSequence = 0xDEADBEEF
b63.vtx[0].rehash()
b63 = self.update_block(63, [])
- self.sync_blocks([b63], success=False,
+ 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
@@ -713,7 +713,7 @@
tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
b64a = self.update_block("64a", [tx])
assert_equal(len(b64a.serialize()), LEGACY_MAX_BLOCK_SIZE + 8)
- self.sync_blocks([b64a], success=False,
+ 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
@@ -730,7 +730,7 @@
assert_equal(len(b64.serialize()), LEGACY_MAX_BLOCK_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
@@ -744,7 +744,7 @@
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 double-spend a transaction created in a block
@@ -761,7 +761,7 @@
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,
+ self.send_blocks([b67], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
# More tests of block subsidy
@@ -783,7 +783,7 @@
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,
+ self.send_blocks([b68], success=False,
reject_reason='bad-cb-amount', reconnect=True)
self.log.info(
@@ -793,7 +793,7 @@
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
@@ -813,7 +813,7 @@
tx.vout.append(CTxOut(1, b""))
pad_tx(tx)
b70 = self.update_block(70, [tx])
- self.sync_blocks([b70], success=False,
+ 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)
@@ -843,11 +843,11 @@
assert_equal(b72.sha256, b71.sha256)
self.move_tip(71)
- self.sync_blocks([b71], success=False,
+ 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()
self.log.info("Skipped sigops tests")
@@ -856,7 +856,7 @@
self.save_spendable_output()
b76 = self.next_block(76)
self.save_spendable_output()
- self.sync_blocks([b75, b76], True)
+ self.send_blocks([b75, b76], True)
# Test transaction resurrection
#
@@ -880,35 +880,35 @@
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, request_block=False)
+ self.send_blocks([b80], False, request_block=False)
self.save_spendable_output()
b81 = self.next_block(81, spend=out[26])
# other chain is same length
- self.sync_blocks([b81], False, request_block=False)
+ self.send_blocks([b81], False, request_block=False)
self.save_spendable_output()
b82 = self.next_block(82, spend=out[27])
# now this chain is longer, triggers re-org
- self.sync_blocks([b82], True)
+ self.send_blocks([b82], True)
self.save_spendable_output()
# now check that tx78 and tx79 have been put back into the peer's
@@ -935,7 +935,7 @@
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)
@@ -963,30 +963,30 @@
tx5 = self.create_tx(tx1, vout_offset + 3, 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,
+ self.send_blocks([b89a], success=False,
reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
self.log.info(
@@ -1009,7 +1009,7 @@
self.save_spendable_output()
spend = self.get_spendable_output()
- self.sync_blocks(blocks, True, timeout=960)
+ self.send_blocks(blocks, True, timeout=960)
chain1_tip = i
# now create alt chain of same length
@@ -1017,18 +1017,18 @@
blocks2 = []
for i in range(89, LARGE_REORG_SIZE + 89):
blocks2.append(self.next_block("alt" + str(i)))
- self.sync_blocks(blocks2, False, request_block=False)
+ self.send_blocks(blocks2, False, request_block=False)
# extend alt chain to trigger re-org
block = self.next_block("alt" + str(chain1_tip + 1))
- self.sync_blocks([block], True, timeout=960)
+ self.send_blocks([block], True, timeout=960)
# ... and re-org back to the first chain
self.move_tip(chain1_tip)
block = self.next_block(chain1_tip + 1)
- self.sync_blocks([block], False, request_block=False)
+ self.send_blocks([block], False, request_block=False)
block = self.next_block(chain1_tip + 2)
- self.sync_blocks([block], True, timeout=960)
+ self.send_blocks([block], True, timeout=960)
# Helper methods
################
@@ -1148,7 +1148,7 @@
self.nodes[0].disconnect_p2ps()
self.bootstrap_p2p()
- def sync_blocks(self, blocks, success=True, reject_reason=None,
+ def send_blocks(self, blocks, success=True, reject_reason=None,
request_block=True, reconnect=False, timeout=60):
"""Sends blocks to test node. Syncs and verifies that tip has advanced to most recent block.
diff --git a/test/functional/feature_csv_activation.py b/test/functional/feature_csv_activation.py
--- a/test/functional/feature_csv_activation.py
+++ b/test/functional/feature_csv_activation.py
@@ -222,7 +222,7 @@
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."""
@@ -256,7 +256,7 @@
# Generate 489 more version 4 blocks
test_blocks = self.generate_blocks(489)
# Test #1
- self.sync_blocks(test_blocks)
+ self.send_blocks(test_blocks)
# Still not activated.
assert_equal(get_csv_status(self.nodes[0]), False)
@@ -313,7 +313,7 @@
# 2 more version 4 blocks
test_blocks = self.generate_blocks(2)
# Test #2
- self.sync_blocks(test_blocks)
+ self.send_blocks(test_blocks)
self.log.info(
"Not yet activated, height = 574 (will activate for block 576, not 575)")
@@ -397,7 +397,7 @@
success_txs.extend([spend_tx(self.nodes[0], tx, self.nodeaddress)
for tx in all_rlt_txs(bip112txs_vary_OP_CSV_9_v1)])
# Test #3
- 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")
@@ -428,14 +428,14 @@
success_txs.extend([spend_tx(self.nodes[0], tx, self.nodeaddress)
for tx in all_rlt_txs(bip112txs_vary_OP_CSV_9_v2)])
# Test #4
- 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)
# Test #5
- self.sync_blocks(test_blocks)
+ self.send_blocks(test_blocks)
assert_equal(get_csv_status(self.nodes[0]), False)
self.nodes[0].generate(1)
@@ -455,7 +455,7 @@
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
for bip113tx in [bip113signed1, bip113signed2]:
# Test #6, Test #7
- self.sync_blocks(
+ self.send_blocks(
[self.create_test_block([bip113tx])], success=False)
# BIP 113 tests should now pass if the locktime is < MTP
@@ -467,13 +467,13 @@
bip113signed2 = sign_transaction(self.nodes[0], bip113tx_v2)
for bip113tx in [bip113signed1, bip113signed2]:
# Test #8, Test #9
- 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)
# Test #10
- 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")
@@ -481,14 +481,14 @@
success_txs = []
success_txs.extend(all_rlt_txs(bip68txs_v1))
# Test #11
- 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
@@ -497,38 +497,38 @@
for tx in bip68txs_v2 if not tx['sdf'] and tx['stf']]
for tx in bip68timetxs:
# Test #13 - Test #16
- 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:
# Test #17 - Test #20
- 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)
# Test #21
- 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)
# Test #22
- 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:
# Test #23 - Test #26
- 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)
# Test #27
- self.sync_blocks(test_blocks)
+ self.send_blocks(test_blocks)
# All BIP 68 txs should pass
bip68success_txs.extend(bip68heighttxs)
# Test #28
- 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")
@@ -536,7 +536,7 @@
# -1 OP_CSV tx should fail
# Test #29
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [bip112tx_special_v1])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV,
@@ -546,7 +546,7 @@
success_txs += [tx['tx']
for tx in bip112txs_vary_OP_CSV_9_v1 if tx['sdf']]
# Test #30
- self.sync_blocks(
+ self.send_blocks(
[self.create_test_block_spend_utxos(self.nodes[0], success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
@@ -560,14 +560,14 @@
for tx in bip112txs_vary_OP_CSV_9_v1 if not tx['sdf']]
for tx in fail_txs:
# Test #31 - Test #78
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [tx])], success=False)
self.log.info("Test version 2 txs")
# -1 OP_CSV tx should fail
# Test #79
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [bip112tx_special_v2])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in argument to OP_CSV,
@@ -578,7 +578,7 @@
for tx in bip112txs_vary_OP_CSV_9_v2 if tx['sdf']]
# Test #80
- self.sync_blocks(
+ self.send_blocks(
[self.create_test_block_spend_utxos(self.nodes[0], success_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
@@ -592,7 +592,7 @@
for tx in bip112txs_vary_OP_CSV_9_v2 if not tx['sdf']]
for tx in fail_txs:
# Test #81 - Test #104
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [tx])], success=False)
# If SEQUENCE_LOCKTIME_DISABLE_FLAG is set in nSequence, tx should fail
@@ -600,7 +600,7 @@
for tx in bip112txs_vary_nSequence_v2 if tx['sdf']]
for tx in fail_txs:
# Test #105 - Test #112
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [tx])], success=False)
# If sequencelock types mismatch, tx should fail
@@ -610,7 +610,7 @@
for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and tx['stf']]
for tx in fail_txs:
# Test #113 - Test #120
- self.sync_blocks([self.create_test_block_spend_utxos(
+ self.send_blocks([self.create_test_block_spend_utxos(
self.nodes[0], [tx])], success=False)
# Remaining txs should pass, just test masking works properly
@@ -619,7 +619,7 @@
success_txs += [tx['tx']
for tx in bip112txs_vary_OP_CSV_v2 if not tx['sdf'] and not tx['stf']]
# Test #121
- self.sync_blocks([self.create_test_block(success_txs)])
+ self.send_blocks([self.create_test_block(success_txs)])
# Spending the previous block utxos requires a difference of 10 blocks (nSequence = 10).
# Generate 9 blocks then spend in the 10th
@@ -628,7 +628,7 @@
self.tip = int("0x" + block, 0)
self.tipheight += 1
# Test #122
- self.sync_blocks(self.generate_blocks(9))
+ self.send_blocks(self.generate_blocks(9))
spend_txs = []
for tx in success_txs:
@@ -637,7 +637,7 @@
raw_tx.rehash()
spend_txs.append(raw_tx)
# Test #123
- self.sync_blocks([self.create_test_block(spend_txs)])
+ self.send_blocks([self.create_test_block(spend_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# Additional test, of checking that comparison of two time types works
@@ -649,7 +649,7 @@
time_txs.append(signtx)
# Test #124
- self.sync_blocks([self.create_test_block(time_txs)])
+ self.send_blocks([self.create_test_block(time_txs)])
# Spending the previous block utxos requires a block time difference of
# at least 10 * 512s (nSequence = 10).
@@ -659,7 +659,7 @@
self.tip = int("0x" + block, 0)
self.tipheight += 1
# Test #125
- self.sync_blocks(self.generate_blocks(8))
+ self.send_blocks(self.generate_blocks(8))
spend_txs = []
for tx in time_txs:
@@ -668,7 +668,7 @@
raw_tx.rehash()
spend_txs.append(raw_tx)
# Test #126
- self.sync_blocks([self.create_test_block(spend_txs)])
+ self.send_blocks([self.create_test_block(spend_txs)])
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# TODO: Test empty stack fails