mirror of
https://github.com/dashpay/dash.git
synced 2024-12-26 12:32:48 +01:00
0923511c25
## Issue being fixed or feature implemented ## What was done? As discussed with Platform team, threshold for `llmq_test_platform` needed to be 67%. Therefore, the size went from 4 members to 3 (while keeping threshold to 2) ## How Has This Been Tested? ## Breaking Changes ## Checklist: - [x] I have performed a self-review of my own code - [ ] I have commented my code, particularly in hard-to-understand areas - [x] I have added or updated relevant unit/integration/functional/e2e tests - [ ] I have made corresponding changes to the documentation **For repository code-owners and collaborators only** - [x] I have assigned this pull request to a milestone
223 lines
9.7 KiB
Python
Executable File
223 lines
9.7 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_hpmn.py
|
|
|
|
Checks HPMNs
|
|
|
|
'''
|
|
from _decimal import Decimal
|
|
import random
|
|
|
|
from test_framework.script import hash160
|
|
from test_framework.test_framework import DashTestFramework
|
|
from test_framework.util import (
|
|
assert_equal, p2p_port
|
|
)
|
|
|
|
|
|
def extract_quorum_members(quorum_info):
|
|
return [d['proTxHash'] for d in quorum_info["members"]]
|
|
|
|
class LLMQHPMNTest(DashTestFramework):
|
|
def set_test_params(self):
|
|
self.set_dash_test_params(5, 4, fast_dip3_enforcement=True, hpmn_count=7)
|
|
self.set_dash_llmq_test_params(4, 4)
|
|
|
|
def run_test(self):
|
|
# Connect all nodes to node1 so that we always have the whole network connected
|
|
# Otherwise only masternode connections will be established between nodes, which won't propagate TXs/blocks
|
|
# Usually node0 is the one that does this, but in this test we isolate it multiple times
|
|
|
|
for i in range(len(self.nodes)):
|
|
if i != 0:
|
|
self.connect_nodes(i, 0)
|
|
|
|
self.activate_dip8()
|
|
|
|
self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", 0)
|
|
self.wait_for_sporks_same()
|
|
|
|
self.mine_quorum(llmq_type_name='llmq_test', llmq_type=100)
|
|
|
|
self.log.info("Test that HPMN registration is rejected before v19")
|
|
self.test_hpmn_is_rejected_before_v19()
|
|
|
|
self.test_masternode_count(expected_mns_count=4, expected_hpmns_count=0)
|
|
|
|
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()))
|
|
|
|
(quorum_info_i_0, quorum_info_i_1) = self.mine_cycle_quorum(llmq_type_name='llmq_test_dip0024', llmq_type=103)
|
|
|
|
hpmn_protxhash_list = list()
|
|
for i in range(5):
|
|
hpmn_info = self.dynamically_add_masternode(hpmn=True)
|
|
hpmn_protxhash_list.append(hpmn_info.proTxHash)
|
|
self.nodes[0].generate(8)
|
|
self.sync_blocks(self.nodes)
|
|
self.test_masternode_count(expected_mns_count=4, expected_hpmns_count=i+1)
|
|
self.test_hpmn_update_service(hpmn_info)
|
|
|
|
self.log.info("Test llmq_platform are formed only with HPMNs")
|
|
for i in range(3):
|
|
quorum_i_hash = self.mine_quorum(llmq_type_name='llmq_test_platform', llmq_type=106, expected_connections=2, expected_members=3, expected_contributions=3, expected_complaints=0, expected_justifications=0, expected_commitments=3 )
|
|
self.test_quorum_members_are_high_performance(quorum_i_hash, llmq_type=106)
|
|
|
|
self.log.info("Test that HPMNs are present in MN list")
|
|
self.test_hpmn_protx_are_in_mnlist(hpmn_protxhash_list)
|
|
|
|
self.log.info("Test that HPMNs are paid 4x blocks in a row")
|
|
self.test_hpmmn_payements(window_analysis=256)
|
|
|
|
self.log.info(self.nodes[0].masternodelist())
|
|
|
|
return
|
|
|
|
def test_hpmmn_payements(self, window_analysis):
|
|
current_hpmn = None
|
|
consecutive_paymments = 0
|
|
for i in range(0, window_analysis):
|
|
payee = self.get_mn_payee_for_block(self.nodes[0].getbestblockhash())
|
|
if payee is not None and payee.hpmn:
|
|
if current_hpmn is not None and payee.proTxHash == current_hpmn.proTxHash:
|
|
# same HPMN
|
|
assert consecutive_paymments > 0
|
|
consecutive_paymments += 1
|
|
consecutive_paymments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
|
|
assert_equal(consecutive_paymments, consecutive_paymments_rpc)
|
|
else:
|
|
# new HPMN
|
|
if current_hpmn is not None:
|
|
# make sure the old one was paid 4 times in a row
|
|
assert_equal(consecutive_paymments, 4)
|
|
consecutive_paymments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
|
|
# old HPMN should have its nConsecutivePayments reset to 0
|
|
assert_equal(consecutive_paymments_rpc, 0)
|
|
current_hpmn = payee
|
|
consecutive_paymments = 1
|
|
consecutive_paymments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
|
|
assert_equal(consecutive_paymments, consecutive_paymments_rpc)
|
|
else:
|
|
# not a HPMN
|
|
if current_hpmn is not None:
|
|
# make sure the old one was paid 4 times in a row
|
|
assert_equal(consecutive_paymments, 4)
|
|
consecutive_paymments_rpc = self.nodes[0].protx('info', current_hpmn.proTxHash)['state']['consecutivePayments']
|
|
# old HPMN should have its nConsecutivePayments reset to 0
|
|
assert_equal(consecutive_paymments_rpc, 0)
|
|
current_hpmn = None
|
|
consecutive_paymments = 0
|
|
|
|
self.nodes[0].generate(1)
|
|
if i % 8 == 0:
|
|
self.sync_blocks()
|
|
|
|
def get_mn_payee_for_block(self, block_hash):
|
|
mn_payee_info = self.nodes[0].masternode("payments", block_hash)[0]
|
|
mn_payee_protx = mn_payee_info['masternodes'][0]['proTxHash']
|
|
|
|
mninfos_online = self.mninfo.copy()
|
|
for mn_info in mninfos_online:
|
|
if mn_info.proTxHash == mn_payee_protx:
|
|
return mn_info
|
|
return None
|
|
|
|
def test_quorum_members_are_high_performance(self, quorum_hash, llmq_type):
|
|
quorum_info = self.nodes[0].quorum("info", llmq_type, quorum_hash)
|
|
quorum_members = extract_quorum_members(quorum_info)
|
|
mninfos_online = self.mninfo.copy()
|
|
for qm in quorum_members:
|
|
found = False
|
|
for mn in mninfos_online:
|
|
if mn.proTxHash == qm:
|
|
assert_equal(mn.hpmn, True)
|
|
found = True
|
|
break
|
|
assert_equal(found, True)
|
|
|
|
def test_hpmn_protx_are_in_mnlist(self, hpmn_protx_list):
|
|
mn_list = self.nodes[0].masternodelist()
|
|
for hpmn_protx in hpmn_protx_list:
|
|
found = False
|
|
for mn in mn_list:
|
|
if mn_list.get(mn)['proTxHash'] == hpmn_protx:
|
|
found = True
|
|
assert_equal(mn_list.get(mn)['type'], "HighPerformance")
|
|
assert_equal(found, True)
|
|
|
|
def test_hpmn_is_rejected_before_v19(self):
|
|
bls = self.nodes[0].bls('generate')
|
|
collateral_address = self.nodes[0].getnewaddress()
|
|
funds_address = self.nodes[0].getnewaddress()
|
|
owner_address = self.nodes[0].getnewaddress()
|
|
voting_address = self.nodes[0].getnewaddress()
|
|
reward_address = self.nodes[0].getnewaddress()
|
|
|
|
collateral_amount = 4000
|
|
collateral_txid = self.nodes[0].sendtoaddress(collateral_address, collateral_amount)
|
|
# send to same address to reserve some funds for fees
|
|
self.nodes[0].sendtoaddress(funds_address, 1)
|
|
collateral_vout = 0
|
|
self.nodes[0].generate(1)
|
|
self.sync_all(self.nodes)
|
|
|
|
rawtx = self.nodes[0].getrawtransaction(collateral_txid, 1)
|
|
for txout in rawtx['vout']:
|
|
if txout['value'] == Decimal(collateral_amount):
|
|
collateral_vout = txout['n']
|
|
break
|
|
assert collateral_vout is not None
|
|
|
|
ipAndPort = '127.0.0.1:%d' % p2p_port(len(self.nodes))
|
|
operatorReward = len(self.nodes)
|
|
|
|
self.nodes[0].generate(1)
|
|
|
|
protx_success = False
|
|
try:
|
|
self.nodes[0].protx('register_hpmn', collateral_txid, collateral_vout, ipAndPort, owner_address, bls['public'], voting_address, operatorReward, reward_address, funds_address, True)
|
|
protx_success = True
|
|
except:
|
|
self.log.info("protx_hpmn rejected")
|
|
assert_equal(protx_success, False)
|
|
|
|
def test_masternode_count(self, expected_mns_count, expected_hpmns_count):
|
|
mn_count = self.nodes[0].masternode('count')
|
|
assert_equal(mn_count['total'], expected_mns_count + expected_hpmns_count)
|
|
detailed_count = mn_count['detailed']
|
|
assert_equal(detailed_count['regular']['total'], expected_mns_count)
|
|
assert_equal(detailed_count['hpmn']['total'], expected_hpmns_count)
|
|
|
|
def test_hpmn_update_service(self, hpmn_info):
|
|
funds_address = self.nodes[0].getnewaddress()
|
|
operator_reward_address = self.nodes[0].getnewaddress()
|
|
|
|
# For the sake of the test, generate random nodeid, p2p and http platform values
|
|
rnd = random.randint(1000, 65000)
|
|
platform_node_id = hash160(b'%d' % rnd).hex()
|
|
platform_p2p_port = '%d' % (rnd + 1)
|
|
platform_http_port = '%d' % (rnd + 2)
|
|
|
|
self.nodes[0].sendtoaddress(funds_address, 1)
|
|
self.nodes[0].generate(1)
|
|
self.sync_all(self.nodes)
|
|
|
|
self.nodes[0].protx('update_service_hpmn', hpmn_info.proTxHash, hpmn_info.addr, hpmn_info.keyOperator, platform_node_id, platform_p2p_port, platform_http_port, operator_reward_address, funds_address)
|
|
self.nodes[0].generate(1)
|
|
self.sync_all(self.nodes)
|
|
self.log.info("Updated HPMN %s: platformNodeID=%s, platformP2PPort=%s, platformHTTPPort=%s" % (hpmn_info.proTxHash, platform_node_id, platform_p2p_port, platform_http_port))
|
|
|
|
if __name__ == '__main__':
|
|
LLMQHPMNTest().main()
|