mirror of
https://github.com/dashpay/dash.git
synced 2024-12-27 04:52:59 +01:00
112564974d
## Issue being fixed or feature implemented Non-deterministic IS locks aren't used anymore since v18 dip24. We should drop that support to make code simpler. ## What was done? Dropped non-deterministic IS code, `evo_instantsend_tests` and `feature_llmq_is_migration.py` (don't need it anymore), adjusted func tests. ## How Has This Been Tested? all tests, synced Testnet ## Breaking Changes ## Checklist: - [x] I have performed a self-review of my own code - [x] I have commented my code, particularly in hard-to-understand areas - [ ] I have added or updated relevant unit/integration/functional/e2e tests - [ ] I have made corresponding changes to the documentation - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_ --------- Co-authored-by: UdjinM6 <UdjinM6@users.noreply.github.com> Co-authored-by: Konstantin Akimov <545784+knst@users.noreply.github.com>
209 lines
10 KiB
Python
Executable File
209 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright (c) 2015-2022 The Dash Core developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
'''
|
|
feature_llmq_is_retroactive.py
|
|
|
|
Tests retroactive signing
|
|
|
|
We have 5 nodes where node 0 is the control node, nodes 1-4 are masternodes.
|
|
Mempool inconsistencies are simulated via disconnecting/reconnecting node 3
|
|
and by having a higher relay fee on node 4.
|
|
'''
|
|
|
|
import time
|
|
|
|
from test_framework.test_framework import DashTestFramework
|
|
from test_framework.util import set_node_times
|
|
|
|
|
|
class LLMQ_IS_RetroactiveSigning(DashTestFramework):
|
|
def set_test_params(self):
|
|
# -whitelist is needed to avoid the trickling logic on node0
|
|
self.set_dash_test_params(5, 4, [["-whitelist=127.0.0.1"], [], [], [], ["-minrelaytxfee=0.001"]], fast_dip3_enforcement=True)
|
|
|
|
def run_test(self):
|
|
self.activate_dip8()
|
|
|
|
self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 0)
|
|
# Turn mempool IS signing off
|
|
self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", 1)
|
|
self.wait_for_sporks_same()
|
|
|
|
self.activate_v19(expected_activation_height=900)
|
|
self.log.info("Activated v19 at height:" + str(self.nodes[0].getblockcount()))
|
|
self.move_to_next_cycle()
|
|
self.log.info("Cycle H height:" + str(self.nodes[0].getblockcount()))
|
|
self.move_to_next_cycle()
|
|
self.log.info("Cycle H+C height:" + str(self.nodes[0].getblockcount()))
|
|
self.move_to_next_cycle()
|
|
self.log.info("Cycle H+2C height:" + str(self.nodes[0].getblockcount()))
|
|
|
|
self.mine_cycle_quorum(llmq_type_name='llmq_test_dip0024', llmq_type=103)
|
|
|
|
# Make sure that all nodes are chainlocked at the same height before starting actual tests
|
|
self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash(), timeout=30)
|
|
|
|
self.log.info("trying normal IS lock w/ signing spork off. Shouldn't be islocked before block is created.")
|
|
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
|
# 3 nodes should be enough to create an IS lock even if nodes 4 and 5 (which have no tx itself)
|
|
# are the only "neighbours" in intra-quorum connections for one of them.
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
# Have to disable ChainLocks to avoid signing a block with a "safe" tx too early
|
|
self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", 4000000000)
|
|
self.wait_for_sporks_same()
|
|
# We have to wait in order to include tx in block
|
|
self.bump_mocktime(10 * 60 + 1)
|
|
block = self.nodes[0].generate(1)[0]
|
|
self.wait_for_instantlock(txid, self.nodes[0])
|
|
self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", 0)
|
|
self.wait_for_sporks_same()
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
|
|
self.log.info("Enable mempool IS signing")
|
|
self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", 0)
|
|
self.wait_for_sporks_same()
|
|
|
|
self.log.info("trying normal IS lock")
|
|
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
|
# 3 nodes should be enough to create an IS lock even if nodes 4 and 5 (which have no tx itself)
|
|
# are the only "neighbours" in intra-quorum connections for one of them.
|
|
self.wait_for_instantlock(txid, self.nodes[0])
|
|
self.bump_mocktime(1)
|
|
block = self.nodes[0].generate(1)[0]
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
|
|
self.log.info("testing normal signing with partially known TX")
|
|
self.isolate_node(3)
|
|
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
|
# Make sure nodes 1 and 2 received the TX before we continue,
|
|
# otherwise it might announce the TX to node 3 when reconnecting
|
|
self.wait_for_tx(txid, self.nodes[1])
|
|
self.wait_for_tx(txid, self.nodes[2])
|
|
self.reconnect_isolated_node(3, 0)
|
|
# Make sure nodes actually try re-connecting quorum connections
|
|
self.bump_mocktime(30)
|
|
self.wait_for_mnauth(self.nodes[3], 2)
|
|
# node 3 fully reconnected but the TX wasn't relayed to it, so there should be no IS lock
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
# push the tx directly via rpc
|
|
self.nodes[3].sendrawtransaction(self.nodes[0].getrawtransaction(txid))
|
|
# node 3 should vote on a tx now since it became aware of it via sendrawtransaction
|
|
# and this should be enough to complete an IS lock
|
|
self.wait_for_instantlock(txid, self.nodes[0])
|
|
|
|
self.log.info("testing retroactive signing with unknown TX")
|
|
self.isolate_node(3)
|
|
rawtx = self.nodes[0].createrawtransaction([], {self.nodes[0].getnewaddress(): 1})
|
|
rawtx = self.nodes[0].fundrawtransaction(rawtx)['hex']
|
|
rawtx = self.nodes[0].signrawtransactionwithwallet(rawtx)['hex']
|
|
txid = self.nodes[3].sendrawtransaction(rawtx)
|
|
# Make node 3 consider the TX as safe
|
|
self.bump_mocktime(10 * 60 + 1)
|
|
block = self.nodes[3].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
|
|
self.reconnect_isolated_node(3, 0)
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
self.nodes[0].setmocktime(self.mocktime)
|
|
|
|
self.log.info("testing retroactive signing with partially known TX")
|
|
self.isolate_node(3)
|
|
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
|
|
# Make sure nodes 1 and 2 received the TX before we continue,
|
|
# otherwise it might announce the TX to node 3 when reconnecting
|
|
self.wait_for_tx(txid, self.nodes[1])
|
|
self.wait_for_tx(txid, self.nodes[2])
|
|
self.reconnect_isolated_node(3, 0)
|
|
# Make sure nodes actually try re-connecting quorum connections
|
|
self.bump_mocktime(30)
|
|
self.wait_for_mnauth(self.nodes[3], 2)
|
|
# node 3 fully reconnected but the TX wasn't relayed to it, so there should be no IS lock
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
# Make node0 consider the TX as safe
|
|
self.bump_mocktime(10 * 60 + 1)
|
|
block = self.nodes[0].generate(1)[0]
|
|
assert txid in self.nodes[0].getblock(block, 1)['tx']
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
|
|
self.log.info("testing retroactive signing with partially known TX and all nodes session timeout")
|
|
self.test_all_nodes_session_timeout(False)
|
|
self.log.info("repeating test, but with cycled LLMQs")
|
|
self.test_all_nodes_session_timeout(True)
|
|
|
|
self.log.info("testing retroactive signing with partially known TX and single node session timeout")
|
|
self.test_single_node_session_timeout(False)
|
|
self.log.info("repeating test, but with cycled LLMQs")
|
|
self.test_single_node_session_timeout(True)
|
|
|
|
def cycle_llmqs(self):
|
|
self.mine_quorum()
|
|
self.mine_quorum()
|
|
self.wait_for_chainlocked_block_all_nodes(self.nodes[0].getbestblockhash(), timeout=30)
|
|
|
|
def test_all_nodes_session_timeout(self, do_cycle_llmqs):
|
|
set_node_times(self.nodes, self.mocktime)
|
|
self.isolate_node(3)
|
|
rawtx = self.nodes[0].createrawtransaction([], {self.nodes[0].getnewaddress(): 1})
|
|
rawtx = self.nodes[0].fundrawtransaction(rawtx)['hex']
|
|
rawtx = self.nodes[0].signrawtransactionwithwallet(rawtx)['hex']
|
|
txid = self.nodes[0].sendrawtransaction(rawtx)
|
|
txid = self.nodes[3].sendrawtransaction(rawtx)
|
|
# Make sure nodes 1 and 2 received the TX before we continue
|
|
self.wait_for_tx(txid, self.nodes[1])
|
|
self.wait_for_tx(txid, self.nodes[2])
|
|
# Make sure signing is done on nodes 1 and 2 (it's async)
|
|
time.sleep(5)
|
|
# Make the signing session for the IS lock timeout on nodes 1-3
|
|
self.bump_mocktime(61)
|
|
time.sleep(2) # make sure Cleanup() is called
|
|
self.reconnect_isolated_node(3, 0)
|
|
# Make sure nodes actually try re-connecting quorum connections
|
|
self.bump_mocktime(30)
|
|
self.wait_for_mnauth(self.nodes[3], 2)
|
|
# node 3 fully reconnected but the signing session is already timed out on all nodes, so no IS lock
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
if do_cycle_llmqs:
|
|
self.cycle_llmqs()
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
# Make node 0 consider the TX as safe
|
|
self.bump_mocktime(10 * 60 + 1)
|
|
block = self.nodes[0].generate(1)[0]
|
|
assert txid in self.nodes[0].getblock(block, 1)['tx']
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
|
|
def test_single_node_session_timeout(self, do_cycle_llmqs):
|
|
set_node_times(self.nodes, self.mocktime)
|
|
self.isolate_node(3)
|
|
rawtx = self.nodes[0].createrawtransaction([], {self.nodes[0].getnewaddress(): 1})
|
|
rawtx = self.nodes[0].fundrawtransaction(rawtx)['hex']
|
|
rawtx = self.nodes[0].signrawtransactionwithwallet(rawtx)['hex']
|
|
txid = self.nodes[3].sendrawtransaction(rawtx)
|
|
time.sleep(2) # make sure signing is done on node 2 (it's async)
|
|
# Make the signing session for the IS lock timeout on node 3
|
|
self.bump_mocktime(61)
|
|
time.sleep(2) # make sure Cleanup() is called
|
|
self.reconnect_isolated_node(3, 0)
|
|
# Make sure nodes actually try re-connecting quorum connections
|
|
self.bump_mocktime(30)
|
|
self.wait_for_mnauth(self.nodes[3], 2)
|
|
self.nodes[0].sendrawtransaction(rawtx)
|
|
# Make sure nodes 1 and 2 received the TX
|
|
self.wait_for_tx(txid, self.nodes[1])
|
|
self.wait_for_tx(txid, self.nodes[2])
|
|
# Make sure signing is done on nodes 1 and 2 (it's async)
|
|
time.sleep(5)
|
|
# node 3 fully reconnected but the signing session is already timed out on it, so no IS lock
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 1)
|
|
if do_cycle_llmqs:
|
|
self.cycle_llmqs()
|
|
self.wait_for_instantlock(txid, self.nodes[0], False, 5)
|
|
# Make node 0 consider the TX as safe
|
|
self.bump_mocktime(10 * 60 + 1)
|
|
block = self.nodes[0].generate(1)[0]
|
|
assert txid in self.nodes[0].getblock(block, 1)['tx']
|
|
self.wait_for_chainlocked_block_all_nodes(block)
|
|
|
|
if __name__ == '__main__':
|
|
LLMQ_IS_RetroactiveSigning().main()
|