sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-25 03:52:49 +01:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

test: remove redundant sync after generate* calls in Dash tests

Browse Source
This commit is contained in:
Kittywhiskers Van Gogh 2024-10-01 16:08:01 +00:00
parent 1367115f7b
commit a99a39ce8d
No known key found for this signature in database
GPG Key ID: 30CD0C065E5C4AAD
13 changed files with 0 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
test/functional/feature_addressindex.py
View File

@ -53,7 +53,6 @@ class AddressIndexTest(BitcoinTestFramework):
self.log.info("Mining blocks...") self.log.info("Mining blocks...")
mining_address = self.nodes[0].getnewaddress() mining_address = self.nodes[0].getnewaddress()
self.generatetoaddress(self.nodes[0], 105, mining_address) self.generatetoaddress(self.nodes[0], 105, mining_address)
self.sync_all()
chain_height = self.nodes[1].getblockcount() chain_height = self.nodes[1].getblockcount()
assert_equal(chain_height, 105) assert_equal(chain_height, 105)
@ -89,8 +88,6 @@ class AddressIndexTest(BitcoinTestFramework):
txidb2 = self.nodes[0].sendtoaddress("93bVhahvUKmQu8gu9g3QnPPa2cxFK98pMB", 20) txidb2 = self.nodes[0].sendtoaddress("93bVhahvUKmQu8gu9g3QnPPa2cxFK98pMB", 20)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
txids = self.nodes[1].getaddresstxids("yMNJePdcKvXtWWQnFYHNeJ5u8TF2v1dfK4") txids = self.nodes[1].getaddresstxids("yMNJePdcKvXtWWQnFYHNeJ5u8TF2v1dfK4")
assert_equal(len(txids), 3) assert_equal(len(txids), 3)
assert_equal(txids[0], txid0) assert_equal(txids[0], txid0)
@ -142,7 +139,6 @@ class AddressIndexTest(BitcoinTestFramework):
sent_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0) sent_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
txidsmany = self.nodes[1].getaddresstxids("93bVhahvUKmQu8gu9g3QnPPa2cxFK98pMB") txidsmany = self.nodes[1].getaddresstxids("93bVhahvUKmQu8gu9g3QnPPa2cxFK98pMB")
assert_equal(len(txidsmany), 4) assert_equal(len(txidsmany), 4)
@ -171,7 +167,6 @@ class AddressIndexTest(BitcoinTestFramework):
signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex()) signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex())
spending_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0) spending_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
balance1 = self.nodes[1].getaddressbalance(address2) balance1 = self.nodes[1].getaddressbalance(address2)
assert_equal(balance1["balance"], amount) assert_equal(balance1["balance"], amount)
@ -185,7 +180,6 @@ class AddressIndexTest(BitcoinTestFramework):
signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex()) signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex())
sent_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0) sent_txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
balance2 = self.nodes[1].getaddressbalance(address2) balance2 = self.nodes[1].getaddressbalance(address2)
assert_equal(balance2["balance"], change_amount) assert_equal(balance2["balance"], change_amount)
@ -239,7 +233,6 @@ class AddressIndexTest(BitcoinTestFramework):
self.generate(self.nodes[2], 1, sync_fun=self.no_op) self.generate(self.nodes[2], 1, sync_fun=self.no_op)
self.nodes[2].sendtoaddress(address2, 50) self.nodes[2].sendtoaddress(address2, 50)
self.generate(self.nodes[2], 1) self.generate(self.nodes[2], 1)
self.sync_all()
utxos3 = self.nodes[1].getaddressutxos({"addresses": [address2]}) utxos3 = self.nodes[1].getaddressutxos({"addresses": [address2]})
assert_equal(len(utxos3), 3) assert_equal(len(utxos3), 3)
@ -292,7 +285,6 @@ class AddressIndexTest(BitcoinTestFramework):
assert_equal(mempool[2]["index"], 1) assert_equal(mempool[2]["index"], 1)
self.generate(self.nodes[2], 1) self.generate(self.nodes[2], 1)
self.sync_all()
mempool2 = self.nodes[2].getaddressmempool({"addresses": [address3]}) mempool2 = self.nodes[2].getaddressmempool({"addresses": [address3]})
assert_equal(len(mempool2), 0) assert_equal(len(mempool2), 0)
@ -323,7 +315,6 @@ class AddressIndexTest(BitcoinTestFramework):
self.nodes[0].sendtoaddress(address1, 10) self.nodes[0].sendtoaddress(address1, 10)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
utxos = self.nodes[1].getaddressutxos({"addresses": [address1]}) utxos = self.nodes[1].getaddressutxos({"addresses": [address1]})
assert_equal(len(utxos), 1) assert_equal(len(utxos), 1)

20
test/functional/feature_asset_locks.py
View File

@ -231,7 +231,6 @@ class AssetLocksTest(DashTestFramework):
count -= batch count -= batch
self.bump_mocktime(batch) self.bump_mocktime(batch)
self.generate(self.nodes[1], batch) self.generate(self.nodes[1], batch)
self.sync_all()
# This functional test intentionally setup only 2 MN and only 2 Evo nodes # This functional test intentionally setup only 2 MN and only 2 Evo nodes
# to ensure that corner case of quorum with minimum amount of nodes as possible # to ensure that corner case of quorum with minimum amount of nodes as possible
@ -260,7 +259,6 @@ class AssetLocksTest(DashTestFramework):
self.set_sporks() self.set_sporks()
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.mempool_size = 0 self.mempool_size = 0
key = ECKey() key = ECKey()
@ -298,7 +296,6 @@ class AssetLocksTest(DashTestFramework):
assert_equal(self.get_credit_pool_balance(node=node), locked_1) assert_equal(self.get_credit_pool_balance(node=node), locked_1)
self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock") self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock")
self.generate(node, 12) self.generate(node, 12)
self.sync_all()
self.validate_credit_pool_balance(locked_1) self.validate_credit_pool_balance(locked_1)
@ -309,14 +306,12 @@ class AssetLocksTest(DashTestFramework):
inode.invalidateblock(self.block_hash_1) inode.invalidateblock(self.block_hash_1)
assert_equal(self.get_credit_pool_balance(node=inode), 0) assert_equal(self.get_credit_pool_balance(node=inode), 0)
self.generate(node, 3) self.generate(node, 3)
self.sync_all()
self.validate_credit_pool_balance(0) self.validate_credit_pool_balance(0)
self.log.info("Resubmit asset lock tx to new chain...") self.log.info("Resubmit asset lock tx to new chain...")
# NEW tx appears # NEW tx appears
asset_lock_tx_2 = self.create_assetlock(coin, locked_2, pubkey) asset_lock_tx_2 = self.create_assetlock(coin, locked_2, pubkey)
txid_in_block = self.send_tx(asset_lock_tx_2) txid_in_block = self.send_tx(asset_lock_tx_2)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.validate_credit_pool_balance(locked_2) self.validate_credit_pool_balance(locked_2)
self.log.info("Reconsider old blocks...") self.log.info("Reconsider old blocks...")
for inode in self.nodes: for inode in self.nodes:
@ -401,7 +396,6 @@ class AssetLocksTest(DashTestFramework):
self.check_mempool_size() self.check_mempool_size()
self.validate_credit_pool_balance(locked) self.validate_credit_pool_balance(locked)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
assert_equal(rawtx["instantlock"], False) assert_equal(rawtx["instantlock"], False)
assert_equal(rawtx["chainlock"], False) assert_equal(rawtx["chainlock"], False)
rawtx = node.getrawtransaction(txid, 1) rawtx = node.getrawtransaction(txid, 1)
@ -424,14 +418,12 @@ class AssetLocksTest(DashTestFramework):
self.validate_credit_pool_balance(locked - 1 * COIN) self.validate_credit_pool_balance(locked - 1 * COIN)
self.send_tx(asset_unlock_tx_late) self.send_tx(asset_unlock_tx_late)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.validate_credit_pool_balance(locked - 2 * COIN) self.validate_credit_pool_balance(locked - 2 * COIN)
self.log.info("Generating many blocks to make quorum far behind (even still active)...") self.log.info("Generating many blocks to make quorum far behind (even still active)...")
self.generate_batch(too_late_height - node.getblockcount() - 1) self.generate_batch(too_late_height - node.getblockcount() - 1)
self.check_mempool_result(tx=asset_unlock_tx_too_late, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}}) self.check_mempool_result(tx=asset_unlock_tx_too_late, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.check_mempool_result(tx=asset_unlock_tx_too_late, self.check_mempool_result(tx=asset_unlock_tx_too_late,
result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-too-late'}) result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-too-late'})
@ -456,7 +448,6 @@ class AssetLocksTest(DashTestFramework):
self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum") self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum")
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.validate_credit_pool_balance(locked - 2 * COIN) self.validate_credit_pool_balance(locked - 2 * COIN)
self.validate_credit_pool_balance(block_hash=self.block_hash_1, expected=locked) self.validate_credit_pool_balance(block_hash=self.block_hash_1, expected=locked)
@ -476,7 +467,6 @@ class AssetLocksTest(DashTestFramework):
txid_in_block = self.send_tx(asset_unlock_tx_full) txid_in_block = self.send_tx(asset_unlock_tx_full)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.ensure_tx_is_not_mined(txid_in_block) self.ensure_tx_is_not_mined(txid_in_block)
@ -490,7 +480,6 @@ class AssetLocksTest(DashTestFramework):
txid_in_block = self.send_tx(asset_unlock_tx_full) txid_in_block = self.send_tx(asset_unlock_tx_full)
expected_balance = (Decimal(self.get_credit_pool_balance()) - Decimal(tiny_amount)) expected_balance = (Decimal(self.get_credit_pool_balance()) - Decimal(tiny_amount))
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.log.info("Check txid_in_block was mined") self.log.info("Check txid_in_block was mined")
block = node.getblock(node.getbestblockhash()) block = node.getblock(node.getbestblockhash())
assert txid_in_block in block['tx'] assert txid_in_block in block['tx']
@ -528,7 +517,6 @@ class AssetLocksTest(DashTestFramework):
self.log.info(f"Collecting coins in pool... Collected {total}/{10_901 * COIN}") self.log.info(f"Collecting coins in pool... Collected {total}/{10_901 * COIN}")
self.sync_mempools() self.sync_mempools()
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
credit_pool_balance_1 = self.get_credit_pool_balance() credit_pool_balance_1 = self.get_credit_pool_balance()
assert_greater_than(credit_pool_balance_1, 10_901 * COIN) assert_greater_than(credit_pool_balance_1, 10_901 * COIN)
limit_amount_1 = 1000 * COIN limit_amount_1 = 1000 * COIN
@ -548,7 +536,6 @@ class AssetLocksTest(DashTestFramework):
self.sync_mempools() self.sync_mempools()
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
new_total = self.get_credit_pool_balance() new_total = self.get_credit_pool_balance()
amount_actually_withdrawn = total - new_total amount_actually_withdrawn = total - new_total
@ -561,7 +548,6 @@ class AssetLocksTest(DashTestFramework):
assert_equal(amount_actually_withdrawn, 900 * COIN + 10001) assert_equal(amount_actually_withdrawn, 900 * COIN + 10001)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.log.info("Checking that exactly 1 tx stayed in mempool...") self.log.info("Checking that exactly 1 tx stayed in mempool...")
self.mempool_size = 1 self.mempool_size = 1
self.check_mempool_size() self.check_mempool_size()
@ -575,7 +561,6 @@ class AssetLocksTest(DashTestFramework):
self.send_tx_simple(asset_unlock_tx) self.send_tx_simple(asset_unlock_tx)
self.sync_mempools() self.sync_mempools()
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
new_total = self.get_credit_pool_balance() new_total = self.get_credit_pool_balance()
amount_actually_withdrawn = total - new_total amount_actually_withdrawn = total - new_total
assert_equal(limit_amount_1, amount_actually_withdrawn) assert_equal(limit_amount_1, amount_actually_withdrawn)
@ -599,10 +584,8 @@ class AssetLocksTest(DashTestFramework):
asset_unlock_tx = self.create_assetunlock(index, limit_amount_2, pubkey) asset_unlock_tx = self.create_assetunlock(index, limit_amount_2, pubkey)
self.send_tx(asset_unlock_tx) self.send_tx(asset_unlock_tx)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
assert_equal(new_total, self.get_credit_pool_balance()) assert_equal(new_total, self.get_credit_pool_balance())
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
new_total -= limit_amount_2 new_total -= limit_amount_2
assert_equal(new_total, self.get_credit_pool_balance()) assert_equal(new_total, self.get_credit_pool_balance())
self.log.info("Trying to withdraw more... expecting to fail") self.log.info("Trying to withdraw more... expecting to fail")
@ -610,7 +593,6 @@ class AssetLocksTest(DashTestFramework):
asset_unlock_tx = self.create_assetunlock(index, COIN, pubkey) asset_unlock_tx = self.create_assetunlock(index, COIN, pubkey)
self.send_tx(asset_unlock_tx) self.send_tx(asset_unlock_tx)
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
tip = self.nodes[0].getblockcount() tip = self.nodes[0].getblockcount()
indexes_statuses_no_height = self.nodes[0].getassetunlockstatuses(["101", "102", "103"]) indexes_statuses_no_height = self.nodes[0].getassetunlockstatuses(["101", "102", "103"])
@ -644,7 +626,6 @@ class AssetLocksTest(DashTestFramework):
assert_equal(platform_reward, 34371430) assert_equal(platform_reward, 34371430)
assert_equal(locked, self.get_credit_pool_balance()) assert_equal(locked, self.get_credit_pool_balance())
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
locked += platform_reward locked += platform_reward
assert_equal(locked, self.get_credit_pool_balance()) assert_equal(locked, self.get_credit_pool_balance())
@ -653,7 +634,6 @@ class AssetLocksTest(DashTestFramework):
self.send_tx(self.create_assetlock(coin, COIN, pubkey)) self.send_tx(self.create_assetlock(coin, COIN, pubkey))
locked += platform_reward + COIN locked += platform_reward + COIN
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
assert_equal(locked, self.get_credit_pool_balance()) assert_equal(locked, self.get_credit_pool_balance())

8
test/functional/feature_dip3_deterministicmns.py
View File

@ -126,7 +126,6 @@ class DIP3Test(BitcoinTestFramework):
dummy_txin = self.spend_mn_collateral(mns[i], with_dummy_input_output=True) dummy_txin = self.spend_mn_collateral(mns[i], with_dummy_input_output=True)
dummy_txins.append(dummy_txin) dummy_txins.append(dummy_txin)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
mns_tmp.remove(mns[i]) mns_tmp.remove(mns[i])
self.assert_mnlists(mns_tmp) self.assert_mnlists(mns_tmp)
new_rpc_info = self.nodes[0].protx("info", old_protx_hash, old_blockhash) new_rpc_info = self.nodes[0].protx("info", old_protx_hash, old_blockhash)
@ -145,7 +144,6 @@ class DIP3Test(BitcoinTestFramework):
self.log.info("cause a reorg with a double spend and check that mnlists are still correct on all nodes") self.log.info("cause a reorg with a double spend and check that mnlists are still correct on all nodes")
self.mine_double_spend(mns, self.nodes[0], dummy_txins, self.nodes[0].getnewaddress()) self.mine_double_spend(mns, self.nodes[0], dummy_txins, self.nodes[0].getnewaddress())
self.generate(self.nodes[0], spend_mns_count) self.generate(self.nodes[0], spend_mns_count)
self.sync_all()
self.assert_mnlists(mns_tmp) self.assert_mnlists(mns_tmp)
self.log.info("test mn payment enforcement with deterministic MNs") self.log.info("test mn payment enforcement with deterministic MNs")
@ -153,7 +151,6 @@ class DIP3Test(BitcoinTestFramework):
node = self.nodes[i % len(self.nodes)] node = self.nodes[i % len(self.nodes)]
self.test_invalid_mn_payment(mns, node) self.test_invalid_mn_payment(mns, node)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
self.log.info("testing ProUpServTx") self.log.info("testing ProUpServTx")
for mn in mns: for mn in mns:
@ -176,7 +173,6 @@ class DIP3Test(BitcoinTestFramework):
expected_payee = bt['masternode'][0]['payee'] expected_payee = bt['masternode'][0]['payee']
expected_amount = bt['masternode'][0]['amount'] expected_amount = bt['masternode'][0]['amount']
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
if expected_payee == multisig: if expected_payee == multisig:
block = self.nodes[0].getblock(self.nodes[0].getbestblockhash()) block = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
cbtx = self.nodes[0].getrawtransaction(block['tx'][0], 1) cbtx = self.nodes[0].getrawtransaction(block['tx'][0], 1)
@ -199,7 +195,6 @@ class DIP3Test(BitcoinTestFramework):
self.register_mn(self.nodes[0], new_mn) self.register_mn(self.nodes[0], new_mn)
mns[i] = new_mn mns[i] = new_mn
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
self.assert_mnlists(mns) self.assert_mnlists(mns)
self.log.info("restarting MN %s" % new_mn.alias) self.log.info("restarting MN %s" % new_mn.alias)
self.stop_node(new_mn.idx) self.stop_node(new_mn.idx)
@ -218,7 +213,6 @@ class DIP3Test(BitcoinTestFramework):
node.sendtoaddress(mn.rewards_address, 0.001) node.sendtoaddress(mn.rewards_address, 0.001)
node.protx('update_registrar', mn.protx_hash, "", new_voting_address, "") node.protx('update_registrar', mn.protx_hash, "", new_voting_address, "")
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
new_dmnState = mn.node.masternode("status")["dmnState"] new_dmnState = mn.node.masternode("status")["dmnState"]
new_voting_address_from_rpc = new_dmnState["votingAddress"] new_voting_address_from_rpc = new_dmnState["votingAddress"]
assert new_voting_address_from_rpc == new_voting_address assert new_voting_address_from_rpc == new_voting_address
@ -296,7 +290,6 @@ class DIP3Test(BitcoinTestFramework):
self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001) self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001)
self.nodes[0].protx('update_registrar', mn.protx_hash, '', '', payee, mn.fundsAddr) self.nodes[0].protx('update_registrar', mn.protx_hash, '', '', payee, mn.fundsAddr)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
info = self.nodes[0].protx('info', mn.protx_hash) info = self.nodes[0].protx('info', mn.protx_hash)
assert info['state']['payoutAddress'] == payee assert info['state']['payoutAddress'] == payee
@ -304,7 +297,6 @@ class DIP3Test(BitcoinTestFramework):
self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001) self.nodes[0].sendtoaddress(mn.fundsAddr, 0.001)
self.nodes[0].protx('update_service', mn.protx_hash, '127.0.0.2:%d' % mn.p2p_port, mn.blsMnkey, "", mn.fundsAddr) self.nodes[0].protx('update_service', mn.protx_hash, '127.0.0.2:%d' % mn.p2p_port, mn.blsMnkey, "", mn.fundsAddr)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
for node in self.nodes: for node in self.nodes:
protx_info = node.protx('info', mn.protx_hash) protx_info = node.protx('info', mn.protx_hash)
mn_list = node.masternode('list') mn_list = node.masternode('list')

1
test/functional/feature_dip3_v19.py
View File

@ -126,7 +126,6 @@ class DIP3V19Test(DashTestFramework):
self.wait_for_instantlock(fund_txid, self.nodes[0]) self.wait_for_instantlock(fund_txid, self.nodes[0])
tip = self.generate(self.nodes[0], 1)[0] tip = self.generate(self.nodes[0], 1)[0]
assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1) assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1)
self.sync_all()
protx_result = self.nodes[0].protx('revoke', revoke_protx, revoke_keyoperator, 1, funds_address) protx_result = self.nodes[0].protx('revoke', revoke_protx, revoke_keyoperator, 1, funds_address)
self.wait_for_instantlock(protx_result, self.nodes[0]) self.wait_for_instantlock(protx_result, self.nodes[0])

1
test/functional/feature_llmq_evo.py
View File

@ -214,7 +214,6 @@ class LLMQEvoNodesTest(DashTestFramework):
outputs = {collateral_address: collateral_amount, funds_address: 1} outputs = {collateral_address: collateral_amount, funds_address: 1}
collateral_txid = self.nodes[0].sendmany("", outputs) collateral_txid = self.nodes[0].sendmany("", outputs)
self.generate(self.nodes[0], 8) self.generate(self.nodes[0], 8)
self.sync_all()
rawtx = self.nodes[0].getrawtransaction(collateral_txid, 1) rawtx = self.nodes[0].getrawtransaction(collateral_txid, 1)
collateral_vout = 0 collateral_vout = 0

2
test/functional/feature_llmq_is_cl_conflicts.py
View File

@ -223,7 +223,6 @@ class LLMQ_IS_CL_Conflicts(DashTestFramework):
# Mine the conflicting TX into a block # Mine the conflicting TX into a block
good_tip = self.nodes[0].getbestblockhash() good_tip = self.nodes[0].getbestblockhash()
self.generate(self.nodes[0], 2) self.generate(self.nodes[0], 2)
self.sync_all()
# Assert that the conflicting tx got mined and the locked TX is not valid # Assert that the conflicting tx got mined and the locked TX is not valid
assert self.nodes[0].getrawtransaction(rawtx1_txid, True)['confirmations'] > 0 assert self.nodes[0].getrawtransaction(rawtx1_txid, True)['confirmations'] > 0
@ -255,7 +254,6 @@ class LLMQ_IS_CL_Conflicts(DashTestFramework):
assert_raises_rpc_error(-26, "tx-txlock-conflict", self.nodes[0].sendrawtransaction, rawtx1) assert_raises_rpc_error(-26, "tx-txlock-conflict", self.nodes[0].sendrawtransaction, rawtx1)
islock_tip = self.generate(self.nodes[0], 1)[0] islock_tip = self.generate(self.nodes[0], 1)[0]
self.sync_all()
for node in self.nodes: for node in self.nodes:
self.wait_for_instantlock(rawtx2_txid, node) self.wait_for_instantlock(rawtx2_txid, node)

1
test/functional/feature_llmq_simplepose.py
View File

@ -212,7 +212,6 @@ class LLMQSimplePoSeTest(DashTestFramework):
# Make sure protxes are "safe" to mine even when InstantSend and ChainLocks are no longer functional # Make sure protxes are "safe" to mine even when InstantSend and ChainLocks are no longer functional
self.bump_mocktime(60 * 10 + 1) self.bump_mocktime(60 * 10 + 1)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
# Isolate and re-connect all MNs (otherwise there might be open connections with no MNAUTH for MNs which were banned before) # Isolate and re-connect all MNs (otherwise there might be open connections with no MNAUTH for MNs which were banned before)
for mn in self.mninfo: for mn in self.mninfo:

8
test/functional/feature_mnehf.py
View File

@ -149,8 +149,6 @@ class MnehfTest(DashTestFramework):
self.log.info(f"unknown ehf tx: {ehf_unknown_tx_sent}") self.log.info(f"unknown ehf tx: {ehf_unknown_tx_sent}")
self.sync_all() self.sync_all()
ehf_blockhash = self.generate(self.nodes[1], 1)[0] ehf_blockhash = self.generate(self.nodes[1], 1)[0]
self.sync_blocks()
self.sync_all()
self.log.info(f"Check MnEhfTx {ehf_tx_sent} was mined in {ehf_blockhash}") self.log.info(f"Check MnEhfTx {ehf_tx_sent} was mined in {ehf_blockhash}")
assert ehf_tx_sent in node.getblock(ehf_blockhash)['tx'] assert ehf_tx_sent in node.getblock(ehf_blockhash)['tx']
@ -164,7 +162,6 @@ class MnehfTest(DashTestFramework):
while (node.getblockcount() + 1) % 4 != 0: while (node.getblockcount() + 1) % 4 != 0:
self.check_fork('defined') self.check_fork('defined')
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.restart_all_nodes() self.restart_all_nodes()
@ -172,13 +169,11 @@ class MnehfTest(DashTestFramework):
for _ in range(4): for _ in range(4):
self.check_fork('started') self.check_fork('started')
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
for i in range(4): for i in range(4):
self.check_fork('locked_in') self.check_fork('locked_in')
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
if i == 7: if i == 7:
self.restart_all_nodes() self.restart_all_nodes()
@ -193,13 +188,11 @@ class MnehfTest(DashTestFramework):
for _ in range(4): for _ in range(4):
self.check_fork('defined') self.check_fork('defined')
self.generate(node, 1) self.generate(node, 1)
self.sync_all()
self.log.info("Re-sending MnEHF for new fork") self.log.info("Re-sending MnEHF for new fork")
tx_sent_2 = self.send_tx(ehf_tx) tx_sent_2 = self.send_tx(ehf_tx)
ehf_blockhash_2 = self.generate(node, 1)[0] ehf_blockhash_2 = self.generate(node, 1)[0]
self.sync_all()
self.log.info(f"Check MnEhfTx again {tx_sent_2} was mined in {ehf_blockhash_2}") self.log.info(f"Check MnEhfTx again {tx_sent_2} was mined in {ehf_blockhash_2}")
assert tx_sent_2 in node.getblock(ehf_blockhash_2)['tx'] assert tx_sent_2 in node.getblock(ehf_blockhash_2)['tx']
@ -242,7 +235,6 @@ class MnehfTest(DashTestFramework):
time.sleep(1) time.sleep(1)
self.bump_mocktime(1) self.bump_mocktime(1)
self.generate(self.nodes[1], 1) self.generate(self.nodes[1], 1)
self.sync_all()
self.check_fork('active') self.check_fork('active')

3
test/functional/feature_spentindex.py
View File

@ -54,7 +54,6 @@ class SpentIndexTest(BitcoinTestFramework):
self.log.info("Mining blocks...") self.log.info("Mining blocks...")
self.generate(self.nodes[0], 105) self.generate(self.nodes[0], 105)
self.sync_all()
chain_height = self.nodes[1].getblockcount() chain_height = self.nodes[1].getblockcount()
assert_equal(chain_height, 105) assert_equal(chain_height, 105)
@ -77,7 +76,6 @@ class SpentIndexTest(BitcoinTestFramework):
signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex()) signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex())
txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0) txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
self.log.info("Testing getspentinfo method...") self.log.info("Testing getspentinfo method...")
@ -121,7 +119,6 @@ class SpentIndexTest(BitcoinTestFramework):
# Check the database index # Check the database index
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
txVerbose4 = self.nodes[3].getrawtransaction(txid2, 1) txVerbose4 = self.nodes[3].getrawtransaction(txid2, 1)
assert_equal(txVerbose4["vin"][0]["address"], address2) assert_equal(txVerbose4["vin"][0]["address"], address2)

1
test/functional/feature_timestampindex.py
View File

@ -49,7 +49,6 @@ class TimestampIndexTest(BitcoinTestFramework):
blockhashes = self.generate(self.nodes[0], 5) blockhashes = self.generate(self.nodes[0], 5)
low = self.nodes[0].getblock(blockhashes[0])["time"] low = self.nodes[0].getblock(blockhashes[0])["time"]
high = self.nodes[0].getblock(blockhashes[4])["time"] high = self.nodes[0].getblock(blockhashes[4])["time"]
self.sync_all()
self.log.info("Checking timestamp index...") self.log.info("Checking timestamp index...")
hashes = self.nodes[1].getblockhashes(high, low) hashes = self.nodes[1].getblockhashes(high, low)
assert_equal(len(hashes), 5) assert_equal(len(hashes), 5)

2
test/functional/feature_txindex.py
View File

@ -39,7 +39,6 @@ class TxIndexTest(BitcoinTestFramework):
def run_test(self): def run_test(self):
self.log.info("Mining blocks...") self.log.info("Mining blocks...")
self.generate(self.nodes[0], 105) self.generate(self.nodes[0], 105)
self.sync_all()
chain_height = self.nodes[1].getblockcount() chain_height = self.nodes[1].getblockcount()
assert_equal(chain_height, 105) assert_equal(chain_height, 105)
@ -59,7 +58,6 @@ class TxIndexTest(BitcoinTestFramework):
signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex()) signed_tx = self.nodes[0].signrawtransactionwithwallet(tx.serialize().hex())
txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0) txid = self.nodes[0].sendrawtransaction(signed_tx["hex"], 0)
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
# Check verbose raw transaction results # Check verbose raw transaction results
verbose = self.nodes[3].getrawtransaction(txid, 1) verbose = self.nodes[3].getrawtransaction(txid, 1)

4
test/functional/p2p_instantsend.py
View File

@ -48,7 +48,6 @@ class InstantSendTest(DashTestFramework):
self.wait_for_instantlock(is_id, node) self.wait_for_instantlock(is_id, node)
self.bump_mocktime(1) self.bump_mocktime(1)
self.generate(self.nodes[0], 2) self.generate(self.nodes[0], 2)
self.sync_all()
# create doublespending transaction, but don't relay it # create doublespending transaction, but don't relay it
dblspnd_tx = self.create_raw_tx(sender, isolated, 0.5, 1, 100) dblspnd_tx = self.create_raw_tx(sender, isolated, 0.5, 1, 100)
@ -93,7 +92,6 @@ class InstantSendTest(DashTestFramework):
# make sure the above TX is on node0 # make sure the above TX is on node0
self.sync_mempools([n for n in self.nodes if n is not isolated]) self.sync_mempools([n for n in self.nodes if n is not isolated])
self.generate(self.nodes[0], 2) self.generate(self.nodes[0], 2)
self.sync_all()
def test_mempool_doublespend(self): def test_mempool_doublespend(self):
sender = self.nodes[self.sender_idx] sender = self.nodes[self.sender_idx]
@ -109,7 +107,6 @@ class InstantSendTest(DashTestFramework):
self.wait_for_instantlock(is_id, node) self.wait_for_instantlock(is_id, node)
self.bump_mocktime(1) self.bump_mocktime(1)
self.generate(self.nodes[0], 2) self.generate(self.nodes[0], 2)
self.sync_all()
# create doublespending transaction, but don't relay it # create doublespending transaction, but don't relay it
dblspnd_tx = self.create_raw_tx(sender, isolated, 0.5, 1, 100) dblspnd_tx = self.create_raw_tx(sender, isolated, 0.5, 1, 100)
@ -142,7 +139,6 @@ class InstantSendTest(DashTestFramework):
# mine more blocks # mine more blocks
self.bump_mocktime(1) self.bump_mocktime(1)
self.generate(self.nodes[0], 2) self.generate(self.nodes[0], 2)
self.sync_all()
if __name__ == '__main__': if __name__ == '__main__':
InstantSendTest().main() InstantSendTest().main()

3
test/functional/test_framework/test_framework.py
View File

@ -1330,7 +1330,6 @@ class DashTestFramework(BitcoinTestFramework):
self.wait_for_instantlock(fund_txid, self.nodes[0]) self.wait_for_instantlock(fund_txid, self.nodes[0])
tip = self.generate(self.nodes[0], 1)[0] tip = self.generate(self.nodes[0], 1)[0]
assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1) assert_equal(self.nodes[0].getrawtransaction(fund_txid, 1, tip)['confirmations'], 1)
self.sync_all()
protx_success = False protx_success = False
try: try:
@ -1338,7 +1337,6 @@ class DashTestFramework(BitcoinTestFramework):
self.wait_for_instantlock(protx_result, self.nodes[0]) self.wait_for_instantlock(protx_result, self.nodes[0])
tip = self.generate(self.nodes[0], 1)[0] tip = self.generate(self.nodes[0], 1)[0]
assert_equal(self.nodes[0].getrawtransaction(protx_result, 1, tip)['confirmations'], 1) assert_equal(self.nodes[0].getrawtransaction(protx_result, 1, tip)['confirmations'], 1)
self.sync_all()
self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, platform_p2p_port, platform_http_port)) self.log.info("Updated EvoNode %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (evo_info.proTxHash, platform_node_id, platform_p2p_port, platform_http_port))
protx_success = True protx_success = True
except: except:
@ -1410,7 +1408,6 @@ class DashTestFramework(BitcoinTestFramework):
rawtx = self.nodes[0].signrawtransactionwithwallet(rawtx) rawtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
self.nodes[0].sendrawtransaction(rawtx["hex"]) self.nodes[0].sendrawtransaction(rawtx["hex"])
self.generate(self.nodes[0], 1) self.generate(self.nodes[0], 1)
self.sync_all()
self.mninfo.remove(mn) self.mninfo.remove(mn)
self.log.info("Removed masternode %d", idx) self.log.info("Removed masternode %d", idx)