github.com/platonnetwork/platon-go@v0.7.6/cases/tests/govern/test_staking_and_unstaking.py (about) 1 from tests.lib.utils import upload_platon, assert_code, get_pledge_list, wait_block_number 2 from common.log import log 3 from tests.lib.client import Client, get_client_by_nodeid, get_clients_by_nodeid, StakingConfig 4 import pytest 5 import allure 6 import time 7 import math 8 from tests.govern.conftest import version_proposal_vote, proposal_vote 9 from tests.lib import Genesis, PipConfig 10 from dacite import from_dict 11 from tests.govern.test_voting_statistics import submitcvpandvote, submitcppandvote, submittpandvote, \ 12 submitvpandvote, submitppandvote 13 14 15 def create_lockup_plan(client): 16 address, _ = client.pip.economic.account.generate_account(client.node.web3, 17 3 * client.economic.genesis.economicModel.staking.stakeThreshold) 18 plan = [{'Epoch': 20, 'Amount': 2 * client.economic.genesis.economicModel.staking.stakeThreshold}] 19 result = client.restricting.createRestrictingPlan(address, plan, address, 20 transaction_cfg=client.pip.cfg.transaction_cfg) 21 log.info('CreateRestrictingPlan result : {}'.format(result)) 22 assert_code(result, 0) 23 result = client.staking.create_staking(1, address, address, 24 amount=int(1.8 * client.economic.genesis.economicModel.staking.stakeThreshold), 25 transaction_cfg=client.pip.cfg.transaction_cfg) 26 log.info('Create staking result : {}'.format(result)) 27 assert_code(result, 0) 28 client.economic.wait_settlement_blocknum(client.node) 29 30 31 @pytest.fixture() 32 def new_node_no_proposal(no_vp_proposal, clients_noconsensus, all_clients): 33 pip = no_vp_proposal 34 client = get_client_by_nodeid(pip.node.node_id, all_clients) 35 candidate_list = get_pledge_list(client.ppos.getCandidateList) 36 log.info('candidate_list: {}'.format(candidate_list)) 37 for client in clients_noconsensus: 38 if client.node.node_id not in candidate_list: 39 return client.pip 40 log.info('All nodes are staked, restart the chain') 41 pip.economic.env.deploy_all() 42 return clients_noconsensus[0].pip 43 44 45 def replace_platon_and_staking(pip, platon_bin): 46 all_nodes = pip.economic.env.get_all_nodes() 47 all_clients = [] 48 for node in all_nodes: 49 all_clients.append(Client(pip.economic.env, node, StakingConfig("externalId", "nodeName", "website", 50 "details"))) 51 client = get_client_by_nodeid(pip.node.node_id, all_clients) 52 upload_platon(pip.node, platon_bin) 53 log.info('Replace the platon of the node {}'.format(pip.node.node_id)) 54 pip.node.restart() 55 log.info('Restart the node {}'.format(pip.node.node_id)) 56 address, _ = pip.economic.account.generate_account(pip.node.web3, 57 10 * pip.economic.genesis.economicModel.staking.stakeThreshold) 58 result = client.staking.create_staking(0, address, address, transaction_cfg=pip.cfg.transaction_cfg) 59 log.info('Node {} staking result {}'.format(pip.node.node_id, result)) 60 return result 61 62 63 class TestVotingProposalStaking: 64 @pytest.mark.P1 65 @allure.title('Verify stake function') 66 @pytest.mark.parametrize('platon_bin', [getattr(PipConfig(), 'PLATON_NEW_BIN2'), 67 getattr(PipConfig(), 'PLATON_NEW_BIN1'), 68 getattr(PipConfig(), 'PLATON_NEW_BIN0'), 69 getattr(PipConfig(), 'PLATON_NEW_BIN3'), 70 getattr(PipConfig(), 'PLATON_NEW_BIN')]) 71 def test_ST_VS_001_to_005(self, new_node_has_proposal, platon_bin): 72 pip = new_node_has_proposal 73 result = replace_platon_and_staking(pip, platon_bin) 74 if platon_bin != pip.cfg.PLATON_NEW_BIN1: 75 assert_code(result, 0) 76 else: 77 assert_code(result, 301004) 78 79 80 class TestNoProposalStaking: 81 @pytest.mark.P1 82 @allure.title('No proposal, verify stake function') 83 def test_ST_NO_001(self, new_node_no_proposal): 84 pip = new_node_no_proposal 85 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN2) 86 assert_code(result, 0) 87 88 @pytest.mark.P1 89 @allure.title('No proposal, verify stake function') 90 def test_ST_NO_002(self, new_node_no_proposal): 91 pip = new_node_no_proposal 92 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN1) 93 assert_code(result, 301004) 94 95 @pytest.mark.P1 96 @allure.title('No proposal, verify stake function') 97 def test_ST_NO_003(self, new_node_no_proposal): 98 pip = new_node_no_proposal 99 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN0) 100 assert_code(result, 0) 101 102 @pytest.mark.P1 103 def test_ST_NO_004(self, new_node_no_proposal): 104 pip = new_node_no_proposal 105 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN3) 106 assert_code(result, 0) 107 108 @pytest.mark.P1 109 @allure.title('No proposal, verify stake function') 110 def test_ST_NO_005(self, new_node_no_proposal): 111 pip = new_node_no_proposal 112 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN) 113 assert_code(result, 301005) 114 115 116 class TestPreactiveProposalStaking: 117 def preactive_proposal(self, all_clients): 118 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 119 log.info('verifierlist :{}'.format(verifier_list)) 120 client_verifiers = get_clients_by_nodeid(verifier_list, all_clients) 121 pips = [client.pip for client in client_verifiers] 122 result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()), 123 pips[0].cfg.version5, 2, pips[0].node.staking_address, 124 transaction_cfg=pips[0].cfg.transaction_cfg) 125 log.info('submit version proposal, result : {}'.format(result)) 126 proposalinfo = pips[0].get_effect_proposal_info_of_vote() 127 log.info('Version proposalinfo: {}'.format(proposalinfo)) 128 for pip in pips: 129 result = version_proposal_vote(pip) 130 assert_code(result, 0) 131 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 132 assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4 133 134 @pytest.mark.P1 135 @allure.title('There is preactive proposal, verify stake function') 136 def test_ST_PR_001(self, new_genesis_env, new_node_no_proposal, all_clients): 137 pip = new_node_no_proposal 138 self.preactive_proposal(all_clients) 139 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN2) 140 assert_code(result, 301004) 141 142 @pytest.mark.P1 143 @allure.title('There is preactive proposal, verify stake function') 144 def test_ST_PR_002(self, new_genesis_env, new_node_no_proposal, all_clients): 145 pip = new_node_no_proposal 146 self.preactive_proposal(all_clients) 147 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN1) 148 assert_code(result, 301004) 149 150 @pytest.mark.P1 151 @allure.title('There is preactive proposal, verify stake function') 152 def test_ST_PR_003(self, new_genesis_env, new_node_no_proposal, all_clients): 153 pip = new_node_no_proposal 154 self.preactive_proposal(all_clients) 155 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN0) 156 assert_code(result, 301004) 157 158 @pytest.mark.P1 159 @allure.title('There is preactive proposal, verify stake function') 160 def test_ST_PR_004(self, new_genesis_env, new_node_no_proposal, all_clients): 161 pip = new_node_no_proposal 162 self.preactive_proposal(all_clients) 163 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN3) 164 assert_code(result, 301004) 165 166 @pytest.mark.P1 167 @allure.title('There is preactive proposal, verify stake function') 168 def test_ST_PR_005(self, new_genesis_env, new_node_no_proposal, all_clients): 169 pip = new_node_no_proposal 170 self.preactive_proposal(all_clients) 171 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN) 172 assert_code(result, 0) 173 174 @pytest.mark.P1 175 @allure.title('There is preactive proposal, verify stake function') 176 def test_ST_PR_006(self, new_genesis_env, new_node_no_proposal, all_clients): 177 pip = new_node_no_proposal 178 self.preactive_proposal(all_clients) 179 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN8) 180 assert_code(result, 301005) 181 182 183 class TestUpgradedProposalStaking: 184 def upgraded_proposal(self, all_clients): 185 verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) 186 log.info('verifierlist :{}'.format(verifier_list)) 187 client_verifiers = get_clients_by_nodeid(verifier_list, all_clients) 188 pips = [client.pip for client in client_verifiers] 189 result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()), 190 pips[0].cfg.version5, 2, pips[0].node.staking_address, 191 transaction_cfg=pips[0].cfg.transaction_cfg) 192 log.info('submit version proposal, result : {}'.format(result)) 193 proposalinfo = pips[0].get_effect_proposal_info_of_vote() 194 log.info('Version proposalinfo: {}'.format(proposalinfo)) 195 for pip in pips: 196 result = version_proposal_vote(pip) 197 assert_code(result, 0) 198 wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 199 assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4 200 wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) 201 assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 5 202 203 @pytest.mark.P2 204 @allure.title('Chain upgrade completed, verify stake function') 205 def test_ST_UPG_001(self, new_genesis_env, new_node_no_proposal, all_clients): 206 pip = new_node_no_proposal 207 self.upgraded_proposal(all_clients) 208 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN4) 209 assert_code(result, 0) 210 211 @pytest.mark.P2 212 @allure.title('Chain upgrade completed, verify stake function') 213 def test_ST_UPG_002(self, new_genesis_env, new_node_no_proposal, all_clients): 214 pip = new_node_no_proposal 215 self.upgraded_proposal(all_clients) 216 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN0) 217 assert_code(result, 301004) 218 219 @pytest.mark.P2 220 @allure.title('Chain upgrade completed, verify stake function') 221 def test_ST_UPG_003(self, new_genesis_env, new_node_no_proposal, all_clients): 222 pip = new_node_no_proposal 223 self.upgraded_proposal(all_clients) 224 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN) 225 assert_code(result, 0) 226 227 @pytest.mark.P2 228 @allure.title('Chain upgrade completed, verify stake function') 229 def test_ST_UPG_004(self, new_genesis_env, new_node_no_proposal, all_clients): 230 pip = new_node_no_proposal 231 self.upgraded_proposal(all_clients) 232 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN6) 233 assert_code(result, 0) 234 235 @pytest.mark.P2 236 @allure.title('Chain upgrade completed, verify stake function') 237 def test_ST_UPG_005(self, new_genesis_env, new_node_no_proposal, all_clients): 238 pip = new_node_no_proposal 239 self.upgraded_proposal(all_clients) 240 result = replace_platon_and_staking(pip, pip.cfg.PLATON_NEW_BIN7) 241 assert_code(result, 301005) 242 243 244 class TestUnstaking: 245 @pytest.mark.P1 246 @allure.title('Verify unstake function') 247 def test_UNS_AM_003_007(self, new_genesis_env, client_verifier): 248 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 249 genesis.economicModel.staking.unStakeFreezeDuration = 2 250 genesis.economicModel.slashing.maxEvidenceAge = 1 251 new_genesis_env.set_genesis(genesis.to_dict()) 252 new_genesis_env.deploy_all() 253 pip = client_verifier.pip 254 address = pip.node.staking_address 255 submitcvpandvote([client_verifier], 1) 256 result = version_proposal_vote(pip) 257 assert_code(result, 0) 258 shares = client_verifier.staking.get_staking_amount(pip.node) 259 result = client_verifier.staking.withdrew_staking(address) 260 log.info('Node withdrew staking result : {}'.format(result)) 261 assert_code(result, 0) 262 calculated_block = 480 263 wait_block_number(pip.node, calculated_block) 264 balance_before = pip.node.eth.getBalance(address, calculated_block - 1) 265 log.info('Block bumber {} staking address balance {}'.format(calculated_block - 1, balance_before)) 266 balance_after = pip.node.eth.getBalance(address, calculated_block) 267 log.info('Block bumber {} staking address balance {}'.format(calculated_block, balance_after)) 268 log.info('{}'.format(pip.economic.get_current_year_reward(pip.node))) 269 assert balance_after - balance_before == shares 270 271 @pytest.mark.P1 272 @allure.title('Verify unstake function') 273 def test_UNS_AM_005(self, new_genesis_env, client_verifier): 274 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 275 genesis.economicModel.staking.unStakeFreezeDuration = 2 276 genesis.economicModel.slashing.maxEvidenceAge = 1 277 new_genesis_env.set_genesis(genesis.to_dict()) 278 new_genesis_env.deploy_all() 279 pip = client_verifier.pip 280 address = pip.node.staking_address 281 result = pip.submitText(pip.node.node_id, str(time.time()), address, transaction_cfg=pip.cfg.transaction_cfg) 282 assert_code(result, 0) 283 284 submitcppandvote([client_verifier], [1]) 285 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 286 assert_code(result, 0) 287 shares = client_verifier.staking.get_staking_amount(pip.node) 288 result = client_verifier.staking.withdrew_staking(address) 289 log.info('Node withdrew staking result : {}'.format(result)) 290 assert_code(result, 0) 291 calculated_block = 480 292 wait_block_number(pip.node, calculated_block) 293 balance_before = pip.node.eth.getBalance(address, calculated_block - 1) 294 log.info('Block bumber {} staking address balance {}'.format(calculated_block - 1, balance_before)) 295 balance_after = pip.node.eth.getBalance(address, calculated_block) 296 log.info('Block bumber {} staking address balance {}'.format(calculated_block, balance_after)) 297 assert balance_after - balance_before == shares 298 299 @pytest.mark.P1 300 @allure.title('Verify unstake function') 301 def test_UNS_AM_004_006_008(self, new_genesis_env, clients_verifier): 302 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 303 genesis.economicModel.staking.unStakeFreezeDuration = 2 304 genesis.economicModel.slashing.maxEvidenceAge = 1 305 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 1000 306 genesis.economicModel.gov.textProposalVoteDurationSeconds = 840 307 new_genesis_env.set_genesis(genesis.to_dict()) 308 new_genesis_env.deploy_all() 309 pip_one = clients_verifier[0].pip 310 pip_two = clients_verifier[1].pip 311 pip_three = clients_verifier[2].pip 312 address = pip_one.node.staking_address 313 result = pip_one.submitVersion(pip_one.node.node_id, str(time.time()), pip_one.cfg.version5, 17, address, 314 transaction_cfg=pip_one.cfg.transaction_cfg) 315 log.info('Submit version proposal result : {}'.format(result)) 316 proposalinfo_version = pip_one.get_effect_proposal_info_of_vote(pip_one.cfg.version_proposal) 317 log.info('Version proposal information : {}'.format(proposalinfo_version)) 318 319 result = pip_one.submitCancel(pip_one.node.node_id, str(time.time()), 13, proposalinfo_version.get('ProposalID'), 320 address, transaction_cfg=pip_one.cfg.transaction_cfg) 321 log.info('Submit cancel proposal result : {}'.format(result)) 322 assert_code(result, 0) 323 result_text = pip_one.submitText(pip_one.node.node_id, str(time.time()), address, 324 transaction_cfg=pip_one.cfg.transaction_cfg) 325 log.info('Submit text proposal result : {}'.format(result_text)) 326 result = proposal_vote(pip_one, proposaltype=pip_one.cfg.cancel_proposal) 327 assert_code(result, 0) 328 result = version_proposal_vote(pip_two) 329 assert_code(result, 0) 330 result = proposal_vote(pip_three, proposaltype=pip_three.cfg.text_proposal) 331 assert_code(result, 0) 332 proposalinfo_cancel = pip_one.get_effect_proposal_info_of_vote(pip_one.cfg.cancel_proposal) 333 log.info('Get cancel proposal information {}'.format(proposalinfo_cancel)) 334 proposalinfo_text = pip_one.get_effect_proposal_info_of_vote(pip_one.cfg.text_proposal) 335 log.info('Get cancel proposal information {}'.format(proposalinfo_text)) 336 shares_one = clients_verifier[0].staking.get_staking_amount(pip_one.node) 337 shares_two = clients_verifier[1].staking.get_staking_amount(pip_two.node) 338 shares_three = clients_verifier[2].staking.get_staking_amount(pip_three.node) 339 result = clients_verifier[0].staking.withdrew_staking(address) 340 log.info('Node {} withdrew staking result : {}'.format(pip_one.node.node_id, result)) 341 assert_code(result, 0) 342 343 result = clients_verifier[1].staking.withdrew_staking(address) 344 log.info('Node {} withdrew staking result : {}'.format(pip_two.node.node_id, result)) 345 assert_code(result, 0) 346 347 result = clients_verifier[2].staking.withdrew_staking(address) 348 log.info('Node {} withdrew staking result : {}'.format(pip_three.node.node_id, result)) 349 assert_code(result, 0) 350 calculated_block = 480 351 wait_block_number(pip_one.node, calculated_block) 352 balance_before = pip_one.node.eth.getBalance(address, calculated_block - 1) 353 log.info('Block bumber {} staking address balance {}'.format(calculated_block - 1, balance_before)) 354 balance_after = pip_one.node.eth.getBalance(address, calculated_block) 355 log.info('Block bumber {} staking address balance {}'.format(calculated_block, balance_after)) 356 assert balance_after == balance_before 357 358 blocknumber = math.ceil(proposalinfo_cancel.get('EndVotingBlock') / pip_one.economic.settlement_size 359 ) * pip_one.economic.settlement_size 360 wait_block_number(pip_one.node, blocknumber) 361 balance_before = pip_one.node.eth.getBalance(address, blocknumber - 1) 362 log.info('Block bumber {} staking address balance {}'.format(blocknumber - 1, balance_before)) 363 balance_after = pip_one.node.eth.getBalance(address, blocknumber) 364 log.info('Block bumber {} staking address balance {}'.format(blocknumber, balance_after)) 365 assert balance_after - balance_before == shares_one 366 367 blocknumber = math.ceil(proposalinfo_version.get('EndVotingBlock') / pip_one.economic.settlement_size 368 ) * pip_one.economic.settlement_size 369 wait_block_number(pip_one.node, blocknumber) 370 balance_before = pip_one.node.eth.getBalance(address, blocknumber - 1) 371 log.info('Block bumber {} staking address balance {}'.format(blocknumber - 1, balance_before)) 372 balance_after = pip_one.node.eth.getBalance(address, blocknumber) 373 log.info('Block bumber {} staking address balance {}'.format(blocknumber, balance_after)) 374 assert balance_after - balance_before == shares_two 375 376 blocknumber = math.ceil(proposalinfo_text.get('EndVotingBlock') / pip_one.economic.settlement_size 377 ) * pip_one.economic.settlement_size 378 wait_block_number(pip_one.node, blocknumber) 379 balance_before = pip_one.node.eth.getBalance(address, blocknumber - 1) 380 log.info('Block bumber {} staking address balance {}'.format(blocknumber - 1, balance_before)) 381 balance_after = pip_one.node.eth.getBalance(address, blocknumber) 382 log.info('Block bumber {} staking address balance {}'.format(blocknumber, balance_after)) 383 assert balance_after - balance_before == shares_three 384 385 @pytest.mark.P2 386 @allure.title('Verify unstake function') 387 def test_UNS_AM_009_011_013(self, new_genesis_env, clients_noconsensus): 388 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 389 genesis.economicModel.staking.unStakeFreezeDuration = 2 390 genesis.economicModel.slashing.maxEvidenceAge = 1 391 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 1000 392 genesis.economicModel.gov.textProposalVoteDurationSeconds = 200 393 new_genesis_env.set_genesis(genesis.to_dict()) 394 new_genesis_env.deploy_all() 395 pip_test = clients_noconsensus[0].pip 396 address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10**18 * 20000000) 397 plan = [{'Epoch': 20, 'Amount': 10**18 * 2000000}] 398 result = clients_noconsensus[0].restricting.createRestrictingPlan(address, plan, address, 399 transaction_cfg=pip_test.cfg.transaction_cfg) 400 log.info('CreateRestrictingPlan result : {}'.format(result)) 401 assert_code(result, 0) 402 result = clients_noconsensus[0].staking.create_staking(1, address, address, 403 transaction_cfg=pip_test.cfg.transaction_cfg) 404 log.info('Create staking result : {}'.format(result)) 405 assert_code(result, 0) 406 pip_test.economic.wait_settlement_blocknum(pip_test.node) 407 result = pip_test.submitVersion(pip_test.node.node_id, str(time.time()), pip_test.cfg.version5, 408 4, pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) 409 log.info('Submit version proposal result : {}'.format(result)) 410 assert_code(result, 0) 411 result = pip_test.submitText(pip_test.node.node_id, str(time.time()), pip_test.node.staking_address, 412 transaction_cfg=pip_test.cfg.transaction_cfg) 413 log.info('Submit text proposal result : {}'.format(result)) 414 assert_code(result, 0) 415 416 proposalinfo_version = pip_test.get_effect_proposal_info_of_vote() 417 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 418 result = pip_test.submitCancel(pip_test.node.node_id, str(time.time()), 2, proposalinfo_version.get('ProposalID'), 419 pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) 420 log.info('Submit cancel result : {}'.format(result)) 421 assert_code(result, 0) 422 result = version_proposal_vote(pip_test) 423 assert_code(result, 0) 424 result = proposal_vote(pip_test, proposaltype=pip_test.cfg.text_proposal) 425 assert_code(result, 0) 426 result = proposal_vote(pip_test, proposaltype=pip_test.cfg.cancel_proposal) 427 assert_code(result, 0) 428 proposalinfo_cancel = pip_test.get_effect_proposal_info_of_vote(pip_test.cfg.cancel_proposal) 429 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 430 proposalinfo_text = pip_test.get_effect_proposal_info_of_vote(pip_test.cfg.text_proposal) 431 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 432 433 shares = clients_noconsensus[0].staking.get_staking_amount(pip_test.node) 434 result = clients_noconsensus[0].staking.withdrew_staking(address) 435 log.info('Node withdrew result : {}'.format(result)) 436 assert_code(result, 0) 437 438 wait_block_number(pip_test.node, 4 * pip_test.economic.settlement_size) 439 balance_before = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size - 1) 440 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size - 1, balance_before)) 441 balance_before_lockup = pip_test.node.eth.getBalance(pip_test.cfg.FOUNDATION_LOCKUP_ADDRESS, 442 4 * pip_test.economic.settlement_size - 1) 443 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(4 * pip_test.economic.settlement_size - 1, 444 balance_before_lockup)) 445 balance_after = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size) 446 balance_after_lockup = pip_test.node.eth.getBalance(pip_test.cfg.FOUNDATION_LOCKUP_ADDRESS, 447 4 * pip_test.economic.settlement_size) 448 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size, balance_after)) 449 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(4 * pip_test.economic.settlement_size, 450 balance_after_lockup)) 451 assert balance_after_lockup - balance_before_lockup == shares 452 453 @pytest.mark.P2 454 @allure.title('Verify unstake function') 455 def test_UNS_AM_010_012_014(self, new_genesis_env, clients_noconsensus): 456 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 457 genesis.economicModel.staking.unStakeFreezeDuration = 2 458 genesis.economicModel.slashing.maxEvidenceAge = 1 459 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 640 460 genesis.economicModel.gov.textProposalVoteDurationSeconds = 840 461 new_genesis_env.set_genesis(genesis.to_dict()) 462 new_genesis_env.deploy_all() 463 for client in clients_noconsensus: 464 pip = client.pip 465 address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 20000000) 466 plan = [{'Epoch': 20, 'Amount': 10**18 * 2000000}] 467 result = client.restricting.createRestrictingPlan(address, plan, address, 468 transaction_cfg=pip.cfg.transaction_cfg) 469 log.info('CreateRestrictingPlan result : {}'.format(result)) 470 assert_code(result, 0) 471 result = client.staking.create_staking(1, address, address, amount=10**18 * 1800000, 472 transaction_cfg=pip.cfg.transaction_cfg) 473 log.info('Create staking result : {}'.format(result)) 474 assert_code(result, 0) 475 pip.economic.wait_settlement_blocknum(pip.node) 476 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 477 '1116', address, transaction_cfg=pip.cfg.transaction_cfg) 478 log.info('Submit param proposal result : {}'.format(result)) 479 assert_code(result, 0) 480 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 481 transaction_cfg=pip.cfg.transaction_cfg) 482 log.info('Submit text proposal result : {}'.format(result)) 483 assert_code(result, 0) 484 485 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 486 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 487 result = pip.submitCancel(pip.node.node_id, str(time.time()), 14, proposalinfo_param.get('ProposalID'), 488 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 489 log.info('Submit cancel result : {}'.format(result)) 490 assert_code(result, 0) 491 result = proposal_vote(clients_noconsensus[0].pip, proposaltype=pip.cfg.param_proposal) 492 assert_code(result, 0) 493 result = proposal_vote(clients_noconsensus[1].pip, proposaltype=pip.cfg.text_proposal) 494 assert_code(result, 0) 495 result = proposal_vote(clients_noconsensus[2].pip, proposaltype=pip.cfg.cancel_proposal) 496 assert_code(result, 0) 497 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 498 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 499 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 500 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 501 502 shares0 = clients_noconsensus[0].staking.get_staking_amount(clients_noconsensus[0].node) 503 shares1 = clients_noconsensus[1].staking.get_staking_amount(clients_noconsensus[1].node) 504 shares2 = clients_noconsensus[2].staking.get_staking_amount(clients_noconsensus[2].node) 505 address0 = clients_noconsensus[0].node.staking_address 506 address1 = clients_noconsensus[1].node.staking_address 507 address2 = clients_noconsensus[2].node.staking_address 508 result = clients_noconsensus[0].staking.withdrew_staking(address0) 509 log.info('Node {} withdrew result : {}'.format(clients_noconsensus[0].node.node_id, result)) 510 assert_code(result, 0) 511 result = clients_noconsensus[1].staking.withdrew_staking(address1) 512 log.info('Node {} withdrew result : {}'.format(clients_noconsensus[0].node.node_id, result)) 513 assert_code(result, 0) 514 result = clients_noconsensus[2].staking.withdrew_staking(address2) 515 log.info('Node {} withdrew result : {}'.format(clients_noconsensus[0].node.node_id, result)) 516 assert_code(result, 0) 517 wait_block_number(pip.node, 4 * pip.economic.settlement_size) 518 balance_before_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 519 4 * pip.economic.settlement_size - 1) 520 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(4 * pip.economic.settlement_size - 1, 521 balance_before_lockup)) 522 balance_after_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 523 4 * pip.economic.settlement_size) 524 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(4 * pip.economic.settlement_size, 525 balance_after_lockup)) 526 assert balance_after_lockup == balance_before_lockup 527 528 wait_block_number(pip.node, 5 * pip.economic.settlement_size) 529 balance_before = pip.node.eth.getBalance(address2, 5 * pip.economic.settlement_size - 1) 530 balance_before_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 531 5 * pip.economic.settlement_size - 1) 532 log.info('Block bumber {} staking address balance {}'.format(5 * pip.economic.settlement_size - 1, balance_before)) 533 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(5 * pip.economic.settlement_size - 1, 534 balance_before_lockup)) 535 balance_after = pip.node.eth.getBalance(address2, 5 * pip.economic.settlement_size) 536 balance_after_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 537 5 * pip.economic.settlement_size) 538 log.info('Block bumber {} staking address balance {}'.format(5 * pip.economic.settlement_size, balance_after)) 539 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(5 * pip.economic.settlement_size, 540 balance_after_lockup)) 541 assert balance_after == balance_before 542 assert balance_after_lockup - balance_before_lockup == shares2 543 544 wait_block_number(pip.node, 6 * pip.economic.settlement_size) 545 balance_before = pip.node.eth.getBalance(address0, 6 * pip.economic.settlement_size - 1) 546 balance_before_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 547 6 * pip.economic.settlement_size - 1) 548 log.info('Block bumber {} staking address balance {}'.format(6 * pip.economic.settlement_size - 1, balance_before)) 549 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(6 * pip.economic.settlement_size - 1, 550 balance_before_lockup)) 551 balance_after = pip.node.eth.getBalance(address0, 6 * pip.economic.settlement_size) 552 balance_after_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 553 6 * pip.economic.settlement_size) 554 log.info('Block bumber {} staking address balance {}'.format(6 * pip.economic.settlement_size, balance_after)) 555 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(6 * pip.economic.settlement_size, balance_after_lockup)) 556 557 assert balance_after == balance_before 558 assert balance_after_lockup - balance_before_lockup == shares0 559 560 wait_block_number(pip.node, 7 * pip.economic.settlement_size) 561 balance_before = pip.node.eth.getBalance(address1, 7 * pip.economic.settlement_size - 1) 562 balance_before_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 563 7 * pip.economic.settlement_size - 1) 564 log.info('Block bumber {} staking address balance {}'.format(7 * pip.economic.settlement_size - 1, 565 balance_before)) 566 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(7 * pip.economic.settlement_size - 1, 567 balance_before_lockup)) 568 balance_after = pip.node.eth.getBalance(address1, 7 * pip.economic.settlement_size) 569 balance_after_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 570 7 * pip.economic.settlement_size) 571 log.info('Block bumber {} staking address balance {}'.format(7 * pip.economic.settlement_size, balance_after)) 572 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(7 * pip.economic.settlement_size, 573 balance_after_lockup)) 574 575 assert balance_after == balance_before 576 assert balance_after_lockup - balance_before_lockup == shares1 577 578 579 class TestSlashing: 580 @pytest.mark.P1 581 @allure.title('Node be slashed, verify unstake function') 582 def test_UNS_PU_003_005_007_017(self, new_genesis_env, clients_consensus): 583 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 584 genesis.economicModel.staking.unStakeFreezeDuration = 2 585 genesis.economicModel.slashing.maxEvidenceAge = 1 586 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 200 587 genesis.economicModel.gov.textProposalVoteDurationSeconds = 200 588 genesis.economicModel.slashing.slashBlocksReward = 0 589 new_genesis_env.set_genesis(genesis.to_dict()) 590 new_genesis_env.deploy_all() 591 pip = clients_consensus[0].pip 592 pip_test = clients_consensus[1].pip 593 address = pip.node.staking_address 594 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 1, 595 address, transaction_cfg=pip.cfg.transaction_cfg) 596 log.info('Submit version proposal result : {}'.format(result)) 597 assert_code(result, 0) 598 proposalinfo_version = pip.get_effect_proposal_info_of_vote() 599 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 600 result = version_proposal_vote(pip) 601 assert_code(result, 0) 602 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 603 submittpandvote([clients_consensus[0]], 3) 604 submitcppandvote([clients_consensus[0]], [2]) 605 result = proposal_vote(pip, proposaltype=pip.cfg.param_proposal) 606 assert_code(result, 0) 607 log.info('Stop the node {}'.format(pip.node.node_id)) 608 shares = clients_consensus[1].staking.get_staking_amount(pip_test.node) 609 pip.node.stop() 610 wait_block_number(pip_test.node, 4 * pip_test.economic.settlement_size) 611 balance_before = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size - 1) 612 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size - 1, 613 balance_before)) 614 balance_after = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size) 615 616 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size, 617 balance_after)) 618 assert balance_after - balance_before == shares 619 620 @pytest.mark.P2 621 @allure.title('Node be slashed, verify unstake function') 622 def test_UNS_PU_016(self, new_genesis_env, clients_consensus): 623 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 624 genesis.economicModel.staking.unStakeFreezeDuration = 2 625 genesis.economicModel.slashing.maxEvidenceAge = 1 626 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 640 627 genesis.economicModel.gov.textProposalVoteDurationSeconds = 200 628 genesis.economicModel.slashing.slashBlocksReward = 0 629 new_genesis_env.set_genesis(genesis.to_dict()) 630 new_genesis_env.deploy_all() 631 pip = clients_consensus[0].pip 632 pip_test = clients_consensus[1].pip 633 address = pip.node.staking_address 634 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 635 '1116', address, transaction_cfg=pip.cfg.transaction_cfg) 636 log.info('Submit param proposal result : {}'.format(result)) 637 assert_code(result, 0) 638 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 639 transaction_cfg=pip.cfg.transaction_cfg) 640 log.info('Submit text proposal result : {}'.format(result)) 641 assert_code(result, 0) 642 643 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 644 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 645 result = pip.submitCancel(pip.node.node_id, str(time.time()), 14, proposalinfo_param.get('ProposalID'), 646 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 647 log.info('Submit cancel result : {}'.format(result)) 648 assert_code(result, 0) 649 result = proposal_vote(pip, proposaltype=pip.cfg.param_proposal) 650 assert_code(result, 0) 651 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 652 assert_code(result, 0) 653 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 654 assert_code(result, 0) 655 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 656 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 657 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 658 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 659 660 shares0 = clients_consensus[0].staking.get_staking_amount(clients_consensus[0].node) 661 log.info('Stop node {}'.format(pip.node.node_id)) 662 pip.node.stop() 663 wait_block_number(pip_test.node, 3 * pip_test.economic.settlement_size) 664 balance_before = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size - 1) 665 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size - 1, 666 balance_before)) 667 balance_after = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size) 668 669 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size, 670 balance_after)) 671 assert balance_after == balance_before 672 673 wait_block_number(pip_test.node, 5 * pip_test.economic.settlement_size) 674 balance_before = pip_test.node.eth.getBalance(address, 5 * pip_test.economic.settlement_size - 1) 675 log.info('Block bumber {} staking address balance {}'.format(5 * pip_test.economic.settlement_size - 1, 676 balance_before)) 677 balance_after = pip_test.node.eth.getBalance(address, 5 * pip_test.economic.settlement_size) 678 679 log.info('Block bumber {} staking address balance {}'.format(5 * pip_test.economic.settlement_size, 680 balance_after)) 681 assert balance_after - balance_before == shares0 682 683 @pytest.mark.P1 684 @allure.title('Node be slashed, verify unstake function') 685 def test_UNS_PU_004(self, new_genesis_env, clients_consensus): 686 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 687 genesis.economicModel.staking.unStakeFreezeDuration = 2 688 genesis.economicModel.slashing.maxEvidenceAge = 1 689 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 1000 690 genesis.economicModel.gov.textProposalVoteDurationSeconds = 200 691 genesis.economicModel.slashing.slashBlocksReward = 0 692 new_genesis_env.set_genesis(genesis.to_dict()) 693 new_genesis_env.deploy_all() 694 pip = clients_consensus[0].pip 695 pip_test = clients_consensus[1].pip 696 address = pip.node.staking_address 697 result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 13, address, 698 transaction_cfg=pip.cfg.transaction_cfg) 699 log.info('Submit version proposal result : {}'.format(result)) 700 assert_code(result, 0) 701 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 702 transaction_cfg=pip.cfg.transaction_cfg) 703 log.info('Submit text proposal result : {}'.format(result)) 704 assert_code(result, 0) 705 706 proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) 707 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 708 result = version_proposal_vote(pip) 709 assert_code(result, 0) 710 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 711 assert_code(result, 0) 712 713 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 714 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 715 716 shares0 = clients_consensus[0].staking.get_staking_amount(clients_consensus[0].node) 717 log.info('Stop node {}'.format(pip.node.node_id)) 718 pip.node.stop() 719 wait_block_number(pip_test.node, 3 * pip_test.economic.settlement_size) 720 balance_before = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size - 1) 721 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size - 1, 722 balance_before)) 723 balance_after = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size) 724 725 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size, 726 balance_after)) 727 assert balance_after == balance_before 728 729 wait_block_number(pip_test.node, 4 * pip_test.economic.settlement_size) 730 balance_before = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size - 1) 731 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size - 1, 732 balance_before)) 733 balance_after = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size) 734 735 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size, 736 balance_after)) 737 assert balance_after - balance_before == shares0 738 739 @pytest.mark.P1 740 @allure.title('Node be slashed, verify unstake function') 741 def test_UNS_PU_006(self, new_genesis_env, clients_consensus): 742 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 743 genesis.economicModel.staking.unStakeFreezeDuration = 2 744 genesis.economicModel.slashing.maxEvidenceAge = 1 745 genesis.economicModel.gov.textProposalVoteDurationSeconds = 520 746 genesis.economicModel.slashing.slashBlocksReward = 0 747 new_genesis_env.set_genesis(genesis.to_dict()) 748 new_genesis_env.deploy_all() 749 pip = clients_consensus[0].pip 750 pip_test = clients_consensus[1].pip 751 address = pip.node.staking_address 752 753 result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, 754 transaction_cfg=pip.cfg.transaction_cfg) 755 log.info('Submit text proposal result : {}'.format(result)) 756 assert_code(result, 0) 757 758 result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) 759 assert_code(result, 0) 760 proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) 761 log.info('Get text proposal information : {}'.format(proposalinfo_text)) 762 763 shares0 = clients_consensus[0].staking.get_staking_amount(clients_consensus[0].node) 764 log.info('Stop node {}'.format(pip.node.node_id)) 765 pip.node.stop() 766 wait_block_number(pip_test.node, 3 * pip_test.economic.settlement_size) 767 balance_before = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size - 1) 768 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size - 1, 769 balance_before)) 770 balance_after = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size) 771 772 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size, 773 balance_after)) 774 assert balance_after == balance_before 775 776 wait_block_number(pip_test.node, 4 * pip_test.economic.settlement_size) 777 balance_before = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size - 1) 778 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size - 1, 779 balance_before)) 780 balance_after = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size) 781 782 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size, 783 balance_after)) 784 assert balance_after - balance_before == shares0 785 786 @pytest.mark.P2 787 @allure.title('Node be slashed, verify unstake function') 788 def test_UNS_PU_008(self, new_genesis_env, clients_consensus): 789 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 790 genesis.economicModel.staking.unStakeFreezeDuration = 2 791 genesis.economicModel.slashing.maxEvidenceAge = 1 792 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 700 793 genesis.economicModel.slashing.slashBlocksReward = 0 794 new_genesis_env.set_genesis(genesis.to_dict()) 795 new_genesis_env.deploy_all() 796 pip = clients_consensus[0].pip 797 pip_test = clients_consensus[1].pip 798 address = pip.node.staking_address 799 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', 800 '1116', address, transaction_cfg=pip.cfg.transaction_cfg) 801 log.info('Submit param proposal result : {}'.format(result)) 802 assert_code(result, 0) 803 804 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 805 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 806 result = pip.submitCancel(pip.node.node_id, str(time.time()), 14, proposalinfo_param.get('ProposalID'), 807 pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) 808 log.info('Submit cancel result : {}'.format(result)) 809 assert_code(result, 0) 810 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 811 assert_code(result, 0) 812 proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) 813 log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) 814 815 shares0 = clients_consensus[0].staking.get_staking_amount(clients_consensus[0].node) 816 log.info('Stop node {}'.format(pip.node.node_id)) 817 pip.node.stop() 818 wait_block_number(pip_test.node, 3 * pip_test.economic.settlement_size) 819 balance_before = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size - 1) 820 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size - 1, 821 balance_before)) 822 balance_after = pip_test.node.eth.getBalance(address, 3 * pip_test.economic.settlement_size) 823 824 log.info('Block bumber {} staking address balance {}'.format(3 * pip_test.economic.settlement_size, 825 balance_after)) 826 assert balance_after == balance_before 827 828 wait_block_number(pip_test.node, 4 * pip_test.economic.settlement_size) 829 balance_before = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size - 1) 830 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size - 1, 831 balance_before)) 832 balance_after = pip_test.node.eth.getBalance(address, 4 * pip_test.economic.settlement_size) 833 834 log.info('Block bumber {} staking address balance {}'.format(4 * pip_test.economic.settlement_size, 835 balance_after)) 836 assert balance_after - balance_before == shares0 837 838 @pytest.mark.P2 839 @allure.title('Node be slashed, verify unstake function') 840 def test_UNS_PU_009_011_013_019(self, new_genesis_env, clients_noconsensus): 841 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 842 genesis.economicModel.staking.unStakeFreezeDuration = 2 843 genesis.economicModel.slashing.maxEvidenceAge = 1 844 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 300 845 genesis.economicModel.slashing.slashBlocksReward = 0 846 new_genesis_env.set_genesis(genesis.to_dict()) 847 new_genesis_env.deploy_all() 848 pip = clients_noconsensus[0].pip 849 pip_test = clients_noconsensus[1].pip 850 851 create_lockup_plan(clients_noconsensus[0]) 852 address = pip.node.staking_address 853 submitvpandvote([clients_noconsensus[0]], votingrounds=1) 854 proposalinfo_version = pip.get_effect_proposal_info_of_vote() 855 log.info('Get version proposal information : {}'.format(proposalinfo_version)) 856 wait_block_number(pip.node, proposalinfo_version.get('EndVotingBlock')) 857 submitcppandvote([clients_noconsensus[0]], [1]) 858 submittpandvote([clients_noconsensus[0]], 1) 859 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 860 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 861 proposal_vote(pip, proposaltype=pip.cfg.param_proposal) 862 log.info('Stop the node {}'.format(pip.node.node_id)) 863 shares = clients_noconsensus[0].staking.get_staking_amount() 864 log.info('Node staking amount : {}'.format(shares)) 865 pip.node.stop() 866 867 self.verify_amount_block(pip_test, address, shares, value=4) 868 869 @pytest.mark.P2 870 @allure.title('Node be slashed, verify unstake function') 871 def test_UNS_PU_010(self, new_genesis_env, clients_noconsensus): 872 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 873 genesis.economicModel.staking.unStakeFreezeDuration = 2 874 genesis.economicModel.slashing.maxEvidenceAge = 1 875 genesis.economicModel.gov.versionProposalVoteDurationSeconds = 2000 876 genesis.economicModel.slashing.slashBlocksReward = 0 877 new_genesis_env.set_genesis(genesis.to_dict()) 878 new_genesis_env.deploy_all() 879 pip = clients_noconsensus[0].pip 880 pip_test = clients_noconsensus[1].pip 881 882 create_lockup_plan(clients_noconsensus[0]) 883 address = pip.node.staking_address 884 submitvpandvote([clients_noconsensus[0]], votingrounds=14) 885 shares = clients_noconsensus[0].staking.get_staking_amount() 886 log.info('Node staking amount : {}'.format(shares)) 887 pip.node.stop() 888 self.verify_amount(pip_test, address, shares) 889 890 @pytest.mark.P2 891 @allure.title('Node be slashed, verify unstake function') 892 def test_UNS_PU_012(self, new_genesis_env, clients_noconsensus): 893 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 894 genesis.economicModel.staking.unStakeFreezeDuration = 2 895 genesis.economicModel.slashing.maxEvidenceAge = 1 896 genesis.economicModel.gov.textProposalVoteDurationSeconds = 480 897 genesis.economicModel.slashing.slashBlocksReward = 0 898 new_genesis_env.set_genesis(genesis.to_dict()) 899 new_genesis_env.deploy_all() 900 pip = clients_noconsensus[0].pip 901 pip_test = clients_noconsensus[1].pip 902 903 create_lockup_plan(clients_noconsensus[0]) 904 address = pip.node.staking_address 905 submittpandvote([clients_noconsensus[0]], 1) 906 shares = clients_noconsensus[0].staking.get_staking_amount() 907 log.info('Node staking amount : {}'.format(shares)) 908 pip.node.stop() 909 self.verify_amount(pip_test, address, shares) 910 911 @pytest.mark.P2 912 @allure.title('Node be slashed, verify unstake function') 913 def test_UNS_PU_014(self, new_genesis_env, clients_noconsensus): 914 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 915 genesis.economicModel.staking.unStakeFreezeDuration = 2 916 genesis.economicModel.slashing.maxEvidenceAge = 1 917 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 640 918 genesis.economicModel.slashing.slashBlocksReward = 0 919 new_genesis_env.set_genesis(genesis.to_dict()) 920 new_genesis_env.deploy_all() 921 pip = clients_noconsensus[0].pip 922 pip_test = clients_noconsensus[1].pip 923 924 create_lockup_plan(clients_noconsensus[0]) 925 address = pip.node.staking_address 926 result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '1116', 927 address, transaction_cfg=pip.cfg.transaction_cfg) 928 log.info('Submit param proposal result : {}'.format(result)) 929 proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) 930 log.info('Get param proposal information : {}'.format(proposalinfo_param)) 931 result = pip.submitCancel(pip.node.node_id, str(time.time()), 13, proposalinfo_param.get('ProposalID'), 932 address, transaction_cfg=pip.cfg.transaction_cfg) 933 log.info('Submit cancel proposal result : {}'.format(result)) 934 result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) 935 assert_code(result, 0) 936 shares = clients_noconsensus[0].staking.get_staking_amount() 937 log.info('Node staking amount : {}'.format(shares)) 938 pip.node.stop() 939 self.verify_amount(pip_test, address, shares) 940 941 @pytest.mark.P2 942 @allure.title('Node be slashed, verify unstake function') 943 def test_UNS_PU_020(self, new_genesis_env, clients_noconsensus): 944 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 945 genesis.economicModel.staking.unStakeFreezeDuration = 2 946 genesis.economicModel.slashing.maxEvidenceAge = 1 947 genesis.economicModel.gov.paramProposalVoteDurationSeconds = 480 948 genesis.economicModel.slashing.slashBlocksReward = 0 949 new_genesis_env.set_genesis(genesis.to_dict()) 950 new_genesis_env.deploy_all() 951 pip = clients_noconsensus[0].pip 952 pip_test = clients_noconsensus[1].pip 953 954 create_lockup_plan(clients_noconsensus[0]) 955 address = pip.node.staking_address 956 submitppandvote([clients_noconsensus[0]], 3) 957 shares = clients_noconsensus[0].staking.get_staking_amount() 958 log.info('Node staking amount : {}'.format(shares)) 959 pip.node.stop() 960 self.verify_amount(pip_test, address, shares) 961 962 def verify_amount(self, pip, address, shares): 963 self.verify_amount_block(pip, address, shares, value=4, tag=False) 964 self.verify_amount_block(pip, address, shares, value=5) 965 966 def verify_amount_block(self, pip, address, shares, value, tag=True): 967 wait_block_number(pip.node, value * pip.economic.settlement_size) 968 balance_before = pip.node.eth.getBalance(address, value * pip.economic.settlement_size - 1) 969 balance_before_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 970 value * pip.economic.settlement_size - 1) 971 log.info('Block bumber {} staking address balance {}'.format(value * pip.economic.settlement_size - 1, 972 balance_before)) 973 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(value * pip.economic.settlement_size - 1, 974 balance_before_lockup)) 975 balance_after = pip.node.eth.getBalance(address, value * pip.economic.settlement_size) 976 balance_after_lockup = pip.node.eth.getBalance(pip.cfg.FOUNDATION_LOCKUP_ADDRESS, 977 value * pip.economic.settlement_size) 978 log.info('Block bumber {} staking address balance {}'.format(value * pip.economic.settlement_size, 979 balance_after)) 980 log.info('Block bumber {} FOUNDATION_LOCKUP_ADDRESS balance {}'.format(value * pip.economic.settlement_size, 981 balance_after_lockup)) 982 assert balance_after == balance_before 983 if tag: 984 assert balance_after_lockup - balance_before_lockup == shares 985 else: 986 assert balance_after_lockup == balance_before_lockup