github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos/test_governance_penalty_parameters.py (about) 1 import pytest 2 from dacite import from_dict 3 from common.key import mock_duplicate_sign 4 from common.log import log 5 from decimal import Decimal 6 from tests.conftest import (param_governance_verify, 7 param_governance_verify_before_endblock, 8 get_client_consensus, 9 staking_cfg 10 ) 11 from tests.lib import (EconomicConfig, 12 Genesis, check_node_in_list, 13 assert_code, get_governable_parameter_value, 14 wait_block_number, von_amount 15 ) 16 17 18 def pledge_punishment(clients): 19 """ 20 :return: 21 """ 22 first_index = 0 23 second_index = 1 24 first_client = clients[first_index] 25 second_client = clients[second_index] 26 log.info("Current block height: {}".format(first_client.node.eth.blockNumber)) 27 # stop node 28 first_client.node.stop() 29 # Waiting for a settlement round 30 second_client.economic.wait_consensus_blocknum(second_client.node, 3) 31 log.info("Current block height: {}".format(second_client.node.eth.blockNumber)) 32 # view verifier list 33 verifier_list = second_client.ppos.getVerifierList() 34 log.info("verifier_list: {}".format(verifier_list)) 35 candidate_info = second_client.ppos.getCandidateInfo(first_client.node.node_id) 36 log.info("Pledge node information： {}".format(candidate_info)) 37 return candidate_info 38 39 40 def information_before_slash_blocks(client): 41 node = client.node 42 # view Consensus Amount of pledge 43 first_candidate_info = client.ppos.getCandidateInfo(node.node_id) 44 first_pledge_amount = first_candidate_info['Ret']['Released'] 45 # view block_reward 46 log.info("block: {}".format(node.eth.blockNumber)) 47 block_reward, staking_reward = client.economic.get_current_year_reward(node) 48 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 49 # Get governable parameters 50 first_slash_blocks = get_governable_parameter_value(client, 'slashBlocksReward') 51 return first_pledge_amount, block_reward, first_slash_blocks 52 53 54 def verify_changed_parameters(clients, first_pledge_amount, block_reward, slash_blocks): 55 # Verify changed parameters 56 candidate_info = pledge_punishment(clients) 57 second_pledge_amount = candidate_info['Ret']['Released'] 58 punishment_amonut = int(Decimal(str(block_reward)) * Decimal(str(slash_blocks))) 59 if punishment_amonut < first_pledge_amount: 60 assert (second_pledge_amount == first_pledge_amount - punishment_amonut) or (second_pledge_amount == first_pledge_amount - punishment_amonut * 2), "ErrMsg:Consensus Amount of pledge {}".format( 61 second_pledge_amount) 62 else: 63 assert second_pledge_amount == 0, "ErrMsg:Consensus Amount of pledge {}".format(second_pledge_amount) 64 65 66 @pytest.mark.P1 67 @pytest.mark.parametrize('mark', [False, True]) 68 def test_PIP_PVF_001_002(clients_consensus, mark, reset_environment): 69 """ 70 PIP_PVF_001:治理修改低0出块率扣除验证人自有质押金块数投票失败 71 PIP_PVF_002:理修改低0出块率扣除验证人自有质押金块数成功处于未生效期 72 :param clients_consensus: 73 :return: 74 """ 75 index = 0 76 first_client = clients_consensus[index] 77 # get pledge amount1 and block reward 78 first_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks(first_client) 79 # create Parametric proposal 80 param_governance_verify_before_endblock(first_client, 'slashing', 'slashBlocksReward', '0', mark) 81 # Get governable parameters again 82 second_slash_blocks = get_governable_parameter_value(first_client, 'slashBlocksReward') 83 assert first_slash_blocks == second_slash_blocks, "ErrMsg:slash blocks {}".format(second_slash_blocks) 84 # Verify changed parameters 85 verify_changed_parameters(clients_consensus, first_pledge_amount, block_reward, first_slash_blocks) 86 87 88 @pytest.mark.P1 89 def test_PIP_PVF_003(clients_consensus, reset_environment): 90 """ 91 治理修改低0出块率扣除验证人自有质押金块数成功处于已生效期 92 :param clients_consensus: 93 :param reset_environment: 94 :return: 95 """ 96 first_index = 0 97 first_client = clients_consensus[first_index] 98 log.info("当前连接节点：{}".format(first_client.node.node_mark)) 99 node = first_client.node 100 # get pledge amount1 and block reward 101 first_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks(first_client) 102 # create Parametric proposal 103 param_governance_verify(first_client, 'slashing', 'slashBlocksReward', '0') 104 log.info("Current block height: {}".format(node.eth.blockNumber)) 105 # Get governable parameters again 106 second_slash_blocks = get_governable_parameter_value(first_client, 'slashBlocksReward') 107 assert second_slash_blocks == '0', "ErrMsg:Change parameters {}".format(second_slash_blocks) 108 # Verify changed parameters 109 verify_changed_parameters(clients_consensus, first_pledge_amount, block_reward, second_slash_blocks) 110 111 112 @pytest.mark.P1 113 def test_PIP_PVF_004(client_consensus, clients_noconsensus, reset_environment): 114 """ 115 治理修改低0出块率扣除验证人自有质押金块数成功扣除区块奖励块数49999-自由金额质押 116 :param client_consensus: 117 :param clients_noconsensus: 118 :param reset_environment: 119 :return: 120 """ 121 consensus_client = client_consensus 122 log.info("Current connection consensus node".format(consensus_client.node.node_mark)) 123 first_index = 0 124 first_client = clients_noconsensus[first_index] 125 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 126 economic = consensus_client.economic 127 node = consensus_client.node 128 change_parameter_value = '49999' 129 # get pledge amount1 and block reward 130 consensus_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks(consensus_client) 131 # create Parametric proposal 132 param_governance_verify(consensus_client, 'slashing', 'slashBlocksReward', change_parameter_value) 133 log.info("Current block height: {}".format(node.eth.blockNumber)) 134 # Get governable parameters again 135 second_slash_blocks = get_governable_parameter_value(consensus_client, 'slashBlocksReward') 136 assert second_slash_blocks == change_parameter_value, "ErrMsg:Change parameters {}".format(second_slash_blocks) 137 # create account 138 address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 139 # create staking 140 result = first_client.staking.create_staking(0, address, address) 141 assert_code(result, 0) 142 # wait settlement block 143 economic.wait_settlement_blocknum(node) 144 candidate_info = consensus_client.ppos.getCandidateInfo(first_client.node.node_id) 145 first_pledge_amount = candidate_info['Ret']['Released'] 146 log.info("Current pledge node amount：{}".format(first_pledge_amount)) 147 for i in range(4): 148 result = check_node_in_list(node.node_id, consensus_client.ppos.getValidatorList) 149 log.info("Current node in consensus list status：{}".format(result)) 150 if result: 151 # Verify changed parameters 152 verify_changed_parameters(clients_noconsensus, first_pledge_amount, block_reward, second_slash_blocks) 153 break 154 else: 155 # wait consensus block 156 economic.wait_consensus_blocknum(node) 157 158 159 @pytest.mark.P1 160 def test_PIP_PVF_005(client_consensus, clients_noconsensus, reset_environment): 161 """ 162 治理修改低出块率扣除验证人自有质押金比例扣除区块奖励块数49999-锁仓金额质押 163 :param client_consensus: 164 :param clients_noconsensus: 165 :param reset_environment: 166 :return: 167 """ 168 consensus_client = client_consensus 169 log.info("Current connection consensus node".format(consensus_client.node.node_mark)) 170 first_index = 0 171 first_client = clients_noconsensus[first_index] 172 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 173 economic = consensus_client.economic 174 node = consensus_client.node 175 change_parameter_value = '4999' 176 # get pledge amount1 and block reward 177 consensus_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks(consensus_client) 178 # create Parametric proposal 179 param_governance_verify(consensus_client, 'slashing', 'slashBlocksReward', change_parameter_value) 180 log.info("Current block height: {}".format(node.eth.blockNumber)) 181 # Get governable parameters 182 second_slash_blocks = get_governable_parameter_value(consensus_client, 'slashBlocksReward') 183 assert second_slash_blocks == change_parameter_value, "ErrMsg:Change parameters {}".format(second_slash_blocks) 184 # create account 185 address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 186 address1, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 187 # Create restricting plan 188 plan = [{'Epoch': 1, 'Amount': economic.create_staking_limit}] 189 result = consensus_client.restricting.createRestrictingPlan(address1, plan, address) 190 assert_code(result, 0) 191 # create staking 192 result = first_client.staking.create_staking(1, address1, address1) 193 assert_code(result, 0) 194 # wait settlement block 195 economic.wait_settlement_blocknum(node) 196 candidate_info = consensus_client.ppos.getCandidateInfo(first_client.node.node_id) 197 first_pledge_amount = candidate_info['Ret']['RestrictingPlan'] 198 log.info("Current pledge node amount：{}".format(first_pledge_amount)) 199 for i in range(4): 200 result = check_node_in_list(node.node_id, consensus_client.ppos.getValidatorList) 201 # log.info("Current node in consensus list status：{}".format(result)) 202 if result: 203 # Verify changed parameters 204 verify_changed_parameters(clients_noconsensus, first_pledge_amount, block_reward, second_slash_blocks) 205 break 206 else: 207 # wait consensus block 208 economic.wait_consensus_blocknum(node) 209 210 211 def adjust_initial_parameters(new_genesis_env): 212 # Change configuration parameters 213 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 214 genesis.economicModel.staking.unStakeFreezeDuration = 3 215 genesis.economicModel.slashing.maxEvidenceAge = 2 216 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 217 genesis.to_file(new_file) 218 new_genesis_env.deploy_all(new_file) 219 220 221 @pytest.mark.P1 222 @pytest.mark.parametrize('mark', [False, True]) 223 def test_PIP_PVF_006_007(new_genesis_env, mark): 224 """ 225 治理修改区块双签-证据有效期投票失败 226 :param new_genesis_env: 227 :return: 228 """ 229 # Change configuration parameters 230 adjust_initial_parameters(new_genesis_env) 231 first_client = get_client_consensus(new_genesis_env, staking_cfg) 232 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 233 economic = first_client.economic 234 node = first_client.node 235 # view Parameter value before treatment 236 first_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 237 # create Parametric proposal 238 param_governance_verify_before_endblock(first_client, 'slashing', 'maxEvidenceAge', '1', mark) 239 # view Parameter value before treatment again 240 second_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 241 assert second_slash_blocks == first_slash_blocks, "ErrMsg:Parameter value after treatment {}".format( 242 second_slash_blocks) 243 report_address, _ = first_client.economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 244 # wait consensus block 245 economic.wait_consensus_blocknum(node) 246 # Verify changed parameters 247 effective_block = economic.get_front_settlement_switchpoint(node, 2) 248 if effective_block < economic.consensus_size: 249 log.info("Current block: {}".format(node.eth.blockNumber)) 250 effective_block = economic.consensus_size + 1 251 log.info("Effective block height: {}".format(effective_block)) 252 # Report prepareblock signature 253 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, effective_block) 254 log.info("Report information: {}".format(report_information)) 255 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 256 assert_code(result, 0) 257 258 259 @pytest.mark.P1 260 def test_PIP_PVF_008(new_genesis_env): 261 """ 262 治理修改区块双签-证据有效期处于已生效期 263 :param new_genesis_env: 264 :return: 265 """ 266 # Change configuration parameters 267 adjust_initial_parameters(new_genesis_env) 268 first_client = get_client_consensus(new_genesis_env, staking_cfg) 269 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 270 economic = first_client.economic 271 node = first_client.node 272 change_parameter_value = '1' 273 # view Parameter value before treatment 274 first_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 275 # create Parametric proposal 276 param_governance_verify(first_client, 'slashing', 'maxEvidenceAge', change_parameter_value) 277 # view Parameter value before treatment again 278 second_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 279 assert second_slash_blocks != first_slash_blocks, "ErrMsg:Parameter value after treatment {}".format( 280 second_slash_blocks) 281 assert second_slash_blocks == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 282 second_slash_blocks) 283 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 284 # wait consensus block 285 economic.wait_consensus_blocknum(node) 286 # Verify changed parameters 287 effective_block = economic.get_front_settlement_switchpoint(node, int(second_slash_blocks)) 288 log.info("effective_block block height: {}".format(effective_block)) 289 # wait consensus block 290 economic.wait_consensus_blocknum(node) 291 # first Report prepareblock signature 292 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, economic.consensus_size + 1) 293 log.info("Report information: {}".format(report_information)) 294 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 295 assert_code(result, 303003) 296 # second Report prepareblock signature 297 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, effective_block) 298 log.info("Report information: {}".format(report_information)) 299 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 300 assert_code(result, 0) 301 302 303 @pytest.mark.P1 304 def test_PIP_PVF_009(new_genesis_env): 305 """ 306 治理修改区块双签-证据有效期（节点质押退回锁定周期-1） 307 :param new_genesis_env: 308 :return: 309 """ 310 # Change configuration parameters 311 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 312 genesis.economicModel.staking.unStakeFreezeDuration = 3 313 genesis.economicModel.slashing.maxEvidenceAge = 1 314 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 315 genesis.to_file(new_file) 316 new_genesis_env.deploy_all(new_file) 317 318 first_client = get_client_consensus(new_genesis_env, staking_cfg) 319 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 320 economic = first_client.economic 321 node = first_client.node 322 change_parameter_value = '2' 323 # view Parameter value before treatment 324 first_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 325 # create Parametric proposal 326 param_governance_verify(first_client, 'slashing', 'maxEvidenceAge', change_parameter_value) 327 # view Parameter value before treatment again 328 second_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 329 assert second_slash_blocks != first_slash_blocks, "ErrMsg:Parameter value after treatment {}".format( 330 second_slash_blocks) 331 assert second_slash_blocks == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 332 second_slash_blocks) 333 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 334 # wait consensus block 335 economic.wait_consensus_blocknum(node) 336 # Verify changed parameters 337 first_effective_block = economic.get_front_settlement_switchpoint(node, int(first_slash_blocks)) 338 log.info("first effective block height: {}".format(first_effective_block)) 339 second_effective_block = economic.get_front_settlement_switchpoint(node, int(second_slash_blocks)) 340 log.info("second effective block height: {}".format(second_effective_block)) 341 # first Report prepareblock signature 342 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, first_effective_block) 343 log.info("Report information: {}".format(report_information)) 344 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 345 assert_code(result, 0) 346 # second Report prepareblock signature 347 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, second_effective_block) 348 log.info("Report information: {}".format(report_information)) 349 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 350 assert_code(result, 303000) 351 352 353 @pytest.mark.P1 354 def test_PIP_PVF_010(new_genesis_env, clients_consensus): 355 """ 356 治理修改区块双签-证据有效期（超出有效期） 357 :param new_genesis_env: 358 :return: 359 """ 360 # Change configuration parameters 361 adjust_initial_parameters(new_genesis_env) 362 363 first_client = get_client_consensus(new_genesis_env, staking_cfg) 364 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 365 economic = first_client.economic 366 node = first_client.node 367 change_parameter_value = '1' 368 # view Parameter value before treatment 369 first_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 370 assert first_slash_blocks == '2', "ErrMsg:Parameter value before treatment {}".format(first_slash_blocks) 371 # create Parametric proposal 372 param_governance_verify(first_client, 'slashing', 'maxEvidenceAge', change_parameter_value) 373 # view Parameter value before treatment again 374 second_slash_blocks = get_governable_parameter_value(first_client, 'maxEvidenceAge') 375 assert second_slash_blocks == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 376 second_slash_blocks) 377 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 378 # wait consensus block 379 economic.wait_consensus_blocknum(node) 380 # Verify changed parameters 381 effective_block = economic.get_front_settlement_switchpoint(node, int(first_slash_blocks)) 382 log.info("Effective1 block height: {}".format(effective_block)) 383 # Report1 prepareblock signature 384 report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, effective_block) 385 log.info("Report information: {}".format(report_information)) 386 result = first_client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 387 assert_code(result, 303003) 388 389 390 def information_before_penalty_ratio(client): 391 # view Pledge amount 392 first_candidate_info = client.ppos.getCandidateInfo(client.node.node_id) 393 first_pledge_amount = first_candidate_info['Ret']['Released'] 394 # view Parameter value before treatment 395 first_penalty_ratio = get_governable_parameter_value(client, 'slashFractionDuplicateSign') 396 return first_pledge_amount, first_penalty_ratio 397 398 399 def duplicate_sign(client, report_address, report_block): 400 if report_block <= client.economic.consensus_size: 401 report_block = client.economic.consensus_size + 1 402 # Report1 prepareblock signature 403 report_information = mock_duplicate_sign(1, client.node.nodekey, client.node.blsprikey, report_block) 404 log.info("Report information: {}".format(report_information)) 405 result = client.duplicatesign.reportDuplicateSign(1, report_information, report_address) 406 assert_code(result, 0) 407 408 409 def assret_penalty_amount(clients, first_pledge_amount, penalty_ratio=None): 410 # view Pledge amount after punishment 411 proportion_reward, incentive_pool_reward = clients[1].economic.get_report_reward(first_pledge_amount, penalty_ratio) 412 log.info("Whistleblower benefits：{} Incentive pool income：{}".format(proportion_reward, incentive_pool_reward)) 413 # view Pledge amount again 414 candidate_info = clients[1].ppos.getCandidateInfo(clients[0].node.node_id) 415 second_pledge_amount = candidate_info['Ret']['Released'] 416 assert second_pledge_amount == first_pledge_amount - proportion_reward - incentive_pool_reward, "ErrMsg:Pledge amount {}".format( 417 second_pledge_amount) 418 419 420 @pytest.mark.P1 421 @pytest.mark.parametrize('mark', [False, True]) 422 def test_PIP_PVF_011_012(clients_consensus, mark, reset_environment): 423 """ 424 治理修改区块双签-最高处罚比例投票失败 425 :param clients_consensus: 426 :param mark: 427 :param reset_environment: 428 :return: 429 """ 430 first_index = 0 431 first_client = clients_consensus[first_index] 432 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 433 economic = first_client.economic 434 node = first_client.node 435 change_parameter_value = '1000' 436 # view Pledge amount and Parameter value before treatment 437 first_pledge_amount, first_penalty_ratio = information_before_penalty_ratio(first_client) 438 # create Parametric proposal 439 param_governance_verify_before_endblock(first_client, 'slashing', 'slashFractionDuplicateSign', 440 change_parameter_value, mark) 441 # view Parameter value after treatment again 442 second_penalty_ratio = get_governable_parameter_value(first_client, 'slashFractionDuplicateSign') 443 assert second_penalty_ratio == first_penalty_ratio, "ErrMsg:Parameter value after treatment {}".format( 444 second_penalty_ratio) 445 # wait consensus block 446 economic.wait_consensus_blocknum(node) 447 # create account 448 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 449 # Verify changed parameters 450 current_block = node.eth.blockNumber 451 log.info("Current block height: {}".format(current_block)) 452 # Verify changed parameters report 453 duplicate_sign(first_client, report_address, current_block) 454 # assret penalty amount 455 assret_penalty_amount(clients_consensus, first_pledge_amount) 456 457 458 @pytest.mark.P1 459 def test_PIP_PVF_013(clients_consensus, reset_environment): 460 """ 461 治理修改区块双签-最高处罚比例处于已生效期 462 :param clients_consensus: 463 :param reset_environment: 464 :return: 465 """ 466 first_index = 0 467 first_client = clients_consensus[first_index] 468 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 469 economic = first_client.economic 470 node = first_client.node 471 change_parameter_value = '1000' 472 # view Pledge amount and Parameter value before treatment 473 first_pledge_amount, first_penalty_ratio = information_before_penalty_ratio(first_client) 474 # create Parametric proposal 475 param_governance_verify(first_client, 'slashing', 'slashFractionDuplicateSign', change_parameter_value) 476 # view Parameter value before treatment again 477 second_penalty_ratio = get_governable_parameter_value(first_client, 'slashFractionDuplicateSign') 478 assert second_penalty_ratio == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 479 second_penalty_ratio) 480 # create account 481 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 482 # Verify changed parameters 483 current_block = node.eth.blockNumber 484 log.info("Current block height: {}".format(current_block)) 485 # Verify changed parameters report 486 duplicate_sign(first_client, report_address, current_block) 487 # assret penalty amount 488 assret_penalty_amount(clients_consensus, first_pledge_amount, int(change_parameter_value)) 489 490 491 @pytest.mark.P1 492 def test_PIP_PVF_014(clients_consensus, reset_environment): 493 """ 494 治理修改区块双签-最高处罚比例为10000‱ 495 :param clients_consensus: 496 :param reset_environment: 497 :return: 498 """ 499 first_index = 0 500 first_client = clients_consensus[first_index] 501 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 502 economic = first_client.economic 503 node = first_client.node 504 change_parameter_value = '10000' 505 # view Pledge amount and Parameter value before treatment 506 first_pledge_amount, first_penalty_ratio = information_before_penalty_ratio(first_client) 507 # create Parametric proposal 508 param_governance_verify(first_client, 'slashing', 'slashFractionDuplicateSign', change_parameter_value) 509 # view Parameter value before treatment again 510 second_penalty_ratio = get_governable_parameter_value(first_client, 'slashFractionDuplicateSign') 511 assert second_penalty_ratio == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 512 second_penalty_ratio) 513 # create account 514 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 515 # Verify changed parameters 516 current_block = node.eth.blockNumber 517 log.info("Current block height: {}".format(current_block)) 518 # Verify changed parameters report 519 duplicate_sign(first_client, report_address, current_block) 520 # assret penalty amount 521 assret_penalty_amount(clients_consensus, first_pledge_amount, int(change_parameter_value)) 522 523 524 @pytest.mark.P1 525 def test_PIP_PVF_015(clients_consensus, reset_environment): 526 """ 527 治理修改区块双签-最高处罚比例为1‱ 528 :param clients_consensus: 529 :param reset_environment: 530 :return: 531 """ 532 first_index = 0 533 first_client = clients_consensus[first_index] 534 log.info("Current connection non-consensus node：{}".format(first_client.node.node_mark)) 535 economic = first_client.economic 536 node = first_client.node 537 change_parameter_value = '1' 538 # view Pledge amount and Parameter value before treatment 539 first_pledge_amount, first_penalty_ratio = information_before_penalty_ratio(first_client) 540 # create Parametric proposal 541 param_governance_verify(first_client, 'slashing', 'slashFractionDuplicateSign', change_parameter_value) 542 # view Parameter value before treatment again 543 second_penalty_ratio = get_governable_parameter_value(first_client, 'slashFractionDuplicateSign') 544 assert second_penalty_ratio == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format( 545 second_penalty_ratio) 546 # create account 547 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 548 # Verify changed parameters 549 current_block = node.eth.blockNumber 550 log.info("Current block height: {}".format(current_block)) 551 # Verify changed parameters report 552 duplicate_sign(first_client, report_address, current_block) 553 # assret penalty amount 554 assret_penalty_amount(clients_consensus, first_pledge_amount, int(change_parameter_value)) 555 556 557 def information_before_report_reward(client): 558 # view Pledge amount 559 first_candidate_info = client.ppos.getCandidateInfo(client.node.node_id) 560 first_pledge_amount = first_candidate_info['Ret']['Released'] 561 # view Parameter value before treatment 562 first_report_reward = get_governable_parameter_value(client, 'duplicateSignReportReward') 563 return first_pledge_amount, first_report_reward 564 565 566 def get_account_amount(client): 567 # create report account 568 report_address, _ = client.economic.account.generate_account(client.node.web3, client.node.web3.toWei( 569 1000, 'ether')) 570 # view report amount 571 first_report_amount = client.node.eth.getBalance(report_address) 572 # view Incentive pool account 573 first_incentive_pool_account = client.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 574 return report_address, first_report_amount, first_incentive_pool_account 575 576 577 def asster_income_account_amount(client, first_report_amount, first_incentive_pool_account, report_address, 578 proportion_reward, 579 incentive_pool_reward): 580 # view report amount 581 second_report_amount = client.node.eth.getBalance(report_address) 582 # view Incentive pool account 583 second_incentive_pool_account = client.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 584 # asster amount reward 585 log.info("first_report_amount {} ,proportion_reward {} , second_report_amount {}".format(first_report_amount, 586 proportion_reward, 587 second_report_amount)) 588 assert first_report_amount + proportion_reward - second_report_amount < client.node.web3.toWei(1, 589 'ether'), "ErrMsg:report amount {}".format( 590 second_report_amount) 591 log.info("second_incentive_pool_account {} ,first_incentive_pool_account {} , incentive_pool_reward {}".format( 592 second_incentive_pool_account, first_incentive_pool_account, incentive_pool_reward)) 593 assert second_incentive_pool_account == first_incentive_pool_account + incentive_pool_reward + ( 594 first_report_amount + proportion_reward - second_report_amount), "ErrMsg:Incentive pool account {}".format( 595 second_incentive_pool_account) 596 597 598 @pytest.mark.P1 599 @pytest.mark.parametrize('mark', [False, True]) 600 def test_PIP_PVF_016_017(clients_consensus, mark, reset_environment): 601 """ 602 PIP_PVF_016:治理修改区块双签-举报奖励比例投票失败 603 PIP_PVF_017:治理修改区块双签-举报奖励比例处于未生效期 604 :param clients_consensus: 605 :param reset_environment: 606 :return: 607 """ 608 first_index = 0 609 second_index = 1 610 first_client = clients_consensus[first_index] 611 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 612 second_client = clients_consensus[second_index] 613 log.info("Current connection non-consensus second node：{}".format(second_client.node.node_mark)) 614 economic = first_client.economic 615 node = first_client.node 616 change_parameter_value = '60' 617 first_pledge_amount, first_report_reward = information_before_report_reward(first_client) 618 # create Parametric proposal 619 param_governance_verify_before_endblock(first_client, 'slashing', 'duplicateSignReportReward', change_parameter_value, mark) 620 # view Parameter value after treatment 621 second_report_reward = get_governable_parameter_value(first_client, 'duplicateSignReportReward') 622 assert first_report_reward == second_report_reward, "ErrMsg:Parameter value after treatment {}".format(second_report_reward) 623 # wait consensus block 624 economic.wait_consensus_blocknum(node) 625 # get account amount 626 report_address, first_report_amount, first_incentive_pool_account = get_account_amount(first_client) 627 # Verify changed parameters 628 current_block = node.eth.blockNumber 629 log.info("Current block height: {}".format(current_block)) 630 # Verify changed parameters report 631 duplicate_sign(first_client, report_address, current_block) 632 # view Pledge amount after punishment 633 proportion_reward, incentive_pool_reward = economic.get_report_reward(first_pledge_amount) 634 log.info("Whistleblower benefits：{} Incentive pool income：{}".format(proportion_reward, incentive_pool_reward)) 635 # asster account amount 636 asster_income_account_amount(second_client, first_report_amount, first_incentive_pool_account, 637 report_address, proportion_reward, incentive_pool_reward) 638 639 640 @pytest.mark.P1 641 def testt(client_consensus): 642 a = client_consensus.node.eth.getTransactionCount(client_consensus.economic.account.account_with_money['address']) 643 print(a) 644 645 646 @pytest.mark.P1 647 def test_PIP_PVF_018(clients_consensus, reset_environment): 648 """ 649 治理修改区块双签-举报奖励比例处于已生效期 650 :param clients_consensus: 651 :param reset_environment: 652 :return: 653 """ 654 first_index = 0 655 second_index = 1 656 first_client = clients_consensus[first_index] 657 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 658 second_client = clients_consensus[second_index] 659 log.info("Current connection non-consensus second node：{}".format(second_client.node.node_mark)) 660 node = first_client.node 661 change_parameter_value = '60' 662 # get first_pledge_amount first_report_amount first_incentive_pool_account first_report_reward 663 first_pledge_amount, first_report_reward = information_before_report_reward(first_client) 664 # create Parametric proposal 665 param_governance_verify(first_client, 'slashing', 'duplicateSignReportReward', change_parameter_value) 666 # view Parameter value after treatment 667 second_report_reward = get_governable_parameter_value(first_client, 'duplicateSignReportReward') 668 assert second_report_reward == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(second_report_reward) 669 # get account amount 670 report_address, first_report_amount, first_incentive_pool_account = get_account_amount(first_client) 671 # Verify changed parameters 672 current_block = node.eth.blockNumber 673 log.info("Current block height: {}".format(current_block)) 674 # Verify changed parameters report 675 duplicate_sign(first_client, report_address, current_block) 676 # view Pledge amount after punishment 677 proportion_reward, incentive_pool_reward = second_client.economic.get_report_reward(first_pledge_amount, None, int(change_parameter_value)) 678 log.info("Whistleblower benefits：{} Incentive pool income：{}".format(proportion_reward, incentive_pool_reward)) 679 # asster account amount 680 asster_income_account_amount(second_client, first_report_amount, first_incentive_pool_account, 681 report_address, proportion_reward, incentive_pool_reward) 682 683 684 @pytest.mark.P1 685 def test_PIP_PVF_019(clients_consensus, reset_environment): 686 """ 687 治理修改区块双签-举报奖励比例为80% 688 :param clients_consensus: 689 :param reset_environment: 690 :return: 691 """ 692 first_index = 0 693 second_index = 1 694 first_client = clients_consensus[first_index] 695 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 696 second_client = clients_consensus[second_index] 697 log.info("Current connection non-consensus second node：{}".format(second_client.node.node_mark)) 698 economic = first_client.economic 699 node = first_client.node 700 change_parameter_value = '80' 701 # get first_pledge_amount first_report_reward 702 first_pledge_amount, first_report_reward = information_before_report_reward(first_client) 703 # create Parametric proposal 704 param_governance_verify(first_client, 'slashing', 'duplicateSignReportReward', change_parameter_value) 705 # view Parameter value after treatment 706 second_report_reward = get_governable_parameter_value(first_client, 'duplicateSignReportReward') 707 assert second_report_reward == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(second_report_reward) 708 # get account amount 709 report_address, first_report_amount, first_incentive_pool_account = get_account_amount(first_client) 710 # Verify changed parameters 711 current_block = node.eth.blockNumber 712 log.info("Current block height: {}".format(current_block)) 713 # Verify changed parameters report 714 duplicate_sign(first_client, report_address, current_block) 715 # view Pledge amount after punishment 716 proportion_reward, incentive_pool_reward = economic.get_report_reward(first_pledge_amount, None, int(change_parameter_value)) 717 log.info("Whistleblower benefits：{} Incentive pool income：{}".format(proportion_reward, incentive_pool_reward)) 718 # asster account amount 719 asster_income_account_amount(second_client, first_report_amount, first_incentive_pool_account, 720 report_address, proportion_reward, incentive_pool_reward) 721 722 723 @pytest.mark.P1 724 def test_PIP_PVF_020(clients_consensus, reset_environment): 725 """ 726 治理修改区块双签-举报奖励比例为1% 727 :param clients_consensus: 728 :param reset_environment: 729 :return: 730 """ 731 first_index = 0 732 second_index = 1 733 first_client = clients_consensus[first_index] 734 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 735 second_client = clients_consensus[second_index] 736 log.info("Current connection non-consensus second node：{}".format(second_client.node.node_mark)) 737 economic = first_client.economic 738 node = first_client.node 739 change_parameter_value = '1' 740 # get first_pledge_amount first_report_reward 741 first_pledge_amount, first_report_reward = information_before_report_reward(first_client) 742 # create Parametric proposal 743 param_governance_verify(first_client, 'slashing', 'duplicateSignReportReward', change_parameter_value) 744 # view Parameter value after treatment 745 second_report_reward = get_governable_parameter_value(first_client, 'duplicateSignReportReward') 746 assert second_report_reward == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(second_report_reward) 747 # get account amount 748 report_address, first_report_amount, first_incentive_pool_account = get_account_amount(first_client) 749 # Verify changed parameters 750 current_block = node.eth.blockNumber 751 log.info("Current block height: {}".format(current_block)) 752 # Verify changed parameters report 753 duplicate_sign(first_client, report_address, current_block) 754 # view Pledge amount after punishment 755 proportion_reward, incentive_pool_reward = economic.get_report_reward(first_pledge_amount, None, int(change_parameter_value)) 756 log.info("Whistleblower benefits：{} Incentive pool income：{}".format(proportion_reward, incentive_pool_reward)) 757 # asster account amount 758 asster_income_account_amount(second_client, first_report_amount, first_incentive_pool_account, 759 report_address, proportion_reward, incentive_pool_reward) 760 761 762 @pytest.mark.parametrize('mark', [False, True]) 763 @pytest.mark.P1 764 def test_PIP_MG_001_002(client_consensus, mark, reset_environment): 765 """ 766 PIP_MG_001:治理修改默认每个区块的最大Gas 投票失败 767 PIP_MG_002:治理修改默认每个区块的最大Gas 处于未生效期 768 :param client_consensus: 769 :param reset_environment: 770 :return: 771 """ 772 first_client = client_consensus 773 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 774 node = first_client.node 775 # view Parameter value before treatment 776 first_max_gas_limit = get_governable_parameter_value(first_client, 'maxBlockGasLimit') 777 # create Parametric proposal 778 block = param_governance_verify_before_endblock(first_client, 'block', 'maxBlockGasLimit', '4712389', mark) 779 # view Parameter value after treatment 780 second_max_gas_limit = get_governable_parameter_value(first_client, 'maxBlockGasLimit') 781 # wait block 782 wait_block_number(node, block) 783 assert second_max_gas_limit == first_max_gas_limit, "ErrMsg:Parameter value after treatment {}".format(second_max_gas_limit) 784 785 786 @pytest.mark.P1 787 def test_PIP_MG_003(client_consensus, reset_environment): 788 """ 789 治理修改默认每个区块的最大Gas 处于已生效期 790 :param client_consensus: 791 :param reset_environment: 792 :return: 793 """ 794 first_client = client_consensus 795 log.info("Current connection non-consensus first node：{}".format(first_client.node.node_mark)) 796 node = first_client.node 797 change_parameter_value = '4712389' 798 # view Parameter value before treatment 799 first_max_gas_limit = get_governable_parameter_value(first_client, 'maxBlockGasLimit') 800 # create Parametric proposal 801 param_governance_verify(first_client, 'block', 'maxBlockGasLimit', change_parameter_value) 802 # view Parameter value after treatment 803 second_max_gas_limit = get_governable_parameter_value(first_client, 'maxBlockGasLimit') 804 assert second_max_gas_limit != first_max_gas_limit, "ErrMsg:Parameter value after treatment {}".format(second_max_gas_limit) 805 assert second_max_gas_limit == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(second_max_gas_limit)