github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_parameters_proposal.py (about) 1 # -*- coding: utf-8 -*- 2 from tests.conftest import param_governance_verify_before_endblock 3 from tests.lib.utils import * 4 import pytest 5 from dacite import from_dict 6 from common.log import log 7 from tests.lib import Genesis 8 9 10 @pytest.mark.P2 11 def test_POP_001_003(client_consensus, client_new_node): 12 """ 13 Increase the threshold of pledge 14 :param client_consensus: 15 :param get_generate_account: 16 :param client_new_node: 17 :return: 18 """ 19 client_consensus.economic.env.deploy_all() 20 old_amount = client_consensus.economic.create_staking_limit 21 new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") 22 block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", 23 str(new_amount)) 24 log.info(block) 25 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 26 10 ** 18 * 10000000) 27 wait_block_number(client_new_node.node, block) 28 result = client_new_node.staking.create_staking(0, address, address, amount=old_amount) 29 log.info(result) 30 assert_code(result, 301100) 31 result = client_new_node.staking.create_staking(0, address, address, amount=new_amount) 32 log.info(result) 33 assert_code(result, 0) 34 verifier_list = get_pledge_list(client_new_node.ppos.getVerifierList) 35 log.info(verifier_list) 36 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 37 verifier_list = get_pledge_list(client_new_node.ppos.getVerifierList) 38 assert client_new_node.node.node_id in verifier_list 39 40 41 @pytest.mark.P2 42 def test_POP_002(client_consensus, client_new_node, new_genesis_env): 43 """ 44 Minimum pledge reduced pledge threshold 45 :param client_consensus: 46 :param client_new_node: 47 :param new_genesis_env: 48 :return: 49 """ 50 51 old_amount = client_consensus.economic.create_staking_limit + client_consensus.node.web3.toWei(2, "ether") 52 new_amount = client_consensus.economic.create_staking_limit + client_consensus.node.web3.toWei(1, "ether") 53 54 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 55 genesis.economicModel.staking.stakeThreshold = old_amount 56 new_genesis_env.set_genesis(genesis.to_dict()) 57 new_genesis_env.deploy_all() 58 59 block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", 60 str(new_amount)) 61 log.info(block) 62 wait_block_number(client_new_node.node, block) 63 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 64 10 ** 18 * 10000000) 65 result = client_new_node.staking.create_staking(0, address, address, 66 amount=new_amount - client_consensus.node.web3.toWei(1, 67 "ether")) 68 log.info(result) 69 assert_code(result, 301100) 70 result = client_new_node.staking.create_staking(0, address, address, amount=new_amount) 71 log.info(result) 72 assert_code(result, 0) 73 74 75 @pytest.mark.P2 76 def test_POP_005(client_consensus, client_new_node): 77 """ 78 The amendment of the threshold of pledge shall not take effect 79 :param client_consensus: 80 :param get_generate_account: 81 :param client_new_node: 82 :return: 83 """ 84 client_consensus.economic.env.deploy_all() 85 old_amount = client_consensus.economic.create_staking_limit 86 new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") 87 88 block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", 89 str(new_amount), effectiveflag=False) 90 log.info(block) 91 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 92 10 ** 18 * 10000000) 93 wait_block_number(client_new_node.node, block) 94 result = client_new_node.staking.create_staking(0, address, address, amount=old_amount) 95 assert_code(result, 0) 96 97 98 @pytest.mark.P2 99 def test_POP_006(client_consensus, client_new_node): 100 """ 101 (hesitation period) increase - entrustment overweight threshold 102 :param client_consensus: 103 :param client_new_node: 104 :param new_genesis_env: 105 :return: 106 """ 107 client_consensus.economic.env.deploy_all() 108 old_amount = client_consensus.economic.delegate_limit 109 new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") 110 111 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 112 str(new_amount)) 113 log.info(block) 114 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 115 10 ** 18 * 10000000) 116 wait_block_number(client_new_node.node, block) 117 result = client_new_node.staking.create_staking(0, address1, address1) 118 assert_code(result, 0) 119 address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 120 10 ** 18 * 10000000) 121 result = client_new_node.delegate.delegate(0, address2, amount=old_amount) 122 assert_code(result, 301105) 123 result = client_new_node.delegate.delegate(0, address2, amount=new_amount) 124 assert_code(result, 0) 125 result = client_new_node.staking.increase_staking(0, address1, amount=old_amount) 126 assert_code(result, 301104) 127 result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) 128 assert_code(result, 0) 129 130 131 @pytest.mark.P2 132 def test_POP_007(client_consensus, client_new_node): 133 """ 134 (lockup period) increase - entrustment overweight threshold 135 :param client_consensus: 136 :param client_new_node: 137 :param new_genesis_env: 138 :return: 139 """ 140 client_consensus.economic.env.deploy_all() 141 old_amount = client_consensus.economic.delegate_limit 142 new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") 143 144 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 145 str(new_amount)) 146 log.info(block) 147 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 148 10 ** 18 * 10000000) 149 wait_block_number(client_new_node.node, block) 150 result = client_new_node.staking.create_staking(0, address1, address1) 151 assert_code(result, 0) 152 address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 153 10 ** 18 * 10000000) 154 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 155 156 result = client_new_node.delegate.delegate(0, address2, amount=old_amount) 157 assert_code(result, 301105) 158 result = client_new_node.delegate.delegate(0, address2, amount=new_amount) 159 assert_code(result, 0) 160 result = client_new_node.staking.increase_staking(0, address1, amount=old_amount) 161 assert_code(result, 301104) 162 result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) 163 assert_code(result, 0) 164 165 166 @pytest.mark.P2 167 def test_POP_008(client_consensus, client_new_node, new_genesis_env): 168 """ 169 (hesitation period) reduce the entrustment overweight threshold - test 170 :param client_consensus: 171 :param client_new_node: 172 :param new_genesis_env: 173 :return: 174 """ 175 176 old_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(2, "ether") 177 new_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(1, "ether") 178 179 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 180 genesis.economicModel.staking.operatingThreshold = old_amount 181 new_genesis_env.set_genesis(genesis.to_dict()) 182 new_genesis_env.deploy_all() 183 184 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 185 str(new_amount)) 186 log.info(block) 187 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 188 10 ** 18 * 10000000) 189 wait_block_number(client_new_node.node, block) 190 result = client_new_node.staking.create_staking(0, address1, address1) 191 assert_code(result, 0) 192 address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 193 10 ** 18 * 10000000) 194 result = client_new_node.delegate.delegate(0, address2, 195 amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) 196 assert_code(result, 301105) 197 result = client_new_node.delegate.delegate(0, address2, amount=new_amount) 198 assert_code(result, 0) 199 result = client_new_node.staking.increase_staking(0, address1, 200 amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) 201 assert_code(result, 301104) 202 result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) 203 assert_code(result, 0) 204 205 206 @pytest.mark.P2 207 def test_POP_009(client_consensus, client_new_node, new_genesis_env): 208 """ 209 (lockup period) reduce the entrustment increase threshold - test 210 :param client_consensus: 211 :param client_new_node: 212 :param new_genesis_env: 213 :return: 214 """ 215 old_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(2, "ether") 216 new_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(1, "ether") 217 218 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 219 genesis.economicModel.staking.operatingThreshold = old_amount 220 new_genesis_env.set_genesis(genesis.to_dict()) 221 new_genesis_env.deploy_all() 222 223 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 224 str(new_amount)) 225 log.info(block) 226 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 227 10 ** 18 * 10000000) 228 wait_block_number(client_new_node.node, block) 229 result = client_new_node.staking.create_staking(0, address1, address1) 230 assert_code(result, 0) 231 address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 232 10 ** 18 * 10000000) 233 log.info("The next cycle") 234 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 235 result = client_new_node.delegate.delegate(0, address2, 236 amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) 237 assert_code(result, 301105) 238 result = client_new_node.delegate.delegate(0, address2, amount=new_amount) 239 assert_code(result, 0) 240 result = client_new_node.staking.increase_staking(0, address1, 241 amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) 242 assert_code(result, 301104) 243 result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) 244 assert_code(result, 0) 245 246 247 @pytest.mark.P2 248 def test_POP_010_011(client_consensus, client_new_node): 249 """ 250 (hesitation period, lockup period) free amount initiate revocation entrustment 251 :param client_consensus: 252 :param client_new_node: 253 :param new_genesis_env: 254 :return: 255 """ 256 client_consensus.economic.env.deploy_all() 257 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 258 10 ** 18 * 10000000) 259 address_delegate_1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 260 10 ** 18 * 10000000) 261 result = client_new_node.staking.create_staking(0, address1, address1) 262 assert_code(result, 0) 263 delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(40, "ether") 264 log.info("Entrust the sum{}".format(delegate_amount)) 265 result = client_new_node.delegate.delegate(0, address_delegate_1, amount=delegate_amount) 266 assert_code(result, 0) 267 amount1_before = client_new_node.node.eth.getBalance(address_delegate_1) 268 log.info("The wallet balance:{}".format(amount1_before)) 269 parameters_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(10, "ether") 270 271 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 272 str(parameters_amount)) 273 log.info("The value of the proposal parameters{}".format(parameters_amount)) 274 wait_block_number(client_new_node.node, block) 275 log.info("The delegate is initiated after the parameter takes effect") 276 address_delegate_2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 277 10 ** 18 * 10000000) 278 result = client_new_node.delegate.delegate(0, address_delegate_2, amount=delegate_amount) 279 assert_code(result, 0) 280 amount2_before = client_new_node.node.eth.getBalance(address_delegate_1) 281 log.info("The wallet balance:{}".format(amount2_before)) 282 283 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 284 staking_blocknum = msg["Ret"]["StakingBlockNum"] 285 withdrew_delegate_amount = delegate_amount - parameters_amount + client_consensus.node.web3.toWei(1, "ether") 286 287 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_1, 288 amount=withdrew_delegate_amount) 289 assert_code(result, 0) 290 amount1_after = client_new_node.node.eth.getBalance(address_delegate_1) 291 log.info("The wallet balance:{}".format(amount1_after)) 292 assert amount1_before - amount1_after < client_new_node.node.web3.toWei(1, "ether") 293 294 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_2, 295 amount=withdrew_delegate_amount) 296 assert_code(result, 0) 297 amount2_after = client_new_node.node.eth.getBalance(address_delegate_1) 298 log.info("The wallet balance:{}".format(amount2_after)) 299 assert amount1_before - amount1_after < client_new_node.node.web3.toWei(1, "ether") 300 301 302 @pytest.mark.P2 303 def test_POP_012(client_consensus, client_new_node): 304 """ 305 :param client_consensus: 306 :param client_new_node: 307 :param new_genesis_env: 308 :return: 309 """ 310 311 client_consensus.economic.env.deploy_all() 312 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 313 10 ** 18 * 10000000) 314 result = client_new_node.staking.create_staking(0, address, address) 315 316 assert_code(result, 0) 317 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 318 10 ** 18 * 10000000) 319 delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(20, "ether") 320 321 log.info("Own funds to initiate the commission") 322 result = client_new_node.delegate.delegate(0, address_delegate, amount=delegate_amount) 323 assert_code(result, 0) 324 325 parameters_amount = client_consensus.economic.delegate_limit + \ 326 client_consensus.node.web3.toWei(10, "ether") 327 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 328 str(parameters_amount)) 329 wait_block_number(client_new_node.node, block) 330 331 plan = [{'Epoch': 1, 'Amount': delegate_amount}] 332 result = client_new_node.restricting.createRestrictingPlan(address_delegate, plan, address_delegate) 333 assert_code(result, 0) 334 335 log.info("Fund of lockup is initiated and entrusted") 336 result = client_new_node.delegate.delegate(1, address_delegate, amount=delegate_amount) 337 assert_code(result, 0) 338 amount_before = client_new_node.node.eth.getBalance(address_delegate) 339 log.info("The wallet balance:{}".format(amount_before)) 340 341 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 342 staking_blocknum = msg["Ret"]["StakingBlockNum"] 343 withdrew_delegate = delegate_amount * 2 - parameters_amount + \ 344 client_consensus.node.web3.toWei(1, "ether") 345 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate, 346 amount=withdrew_delegate) 347 assert_code(result, 0) 348 amount1_after = client_new_node.node.eth.getBalance(address_delegate) 349 log.info("The wallet balance:{}".format(amount1_after)) 350 amount_dill = amount1_after - amount_before 351 assert delegate_amount - amount_dill < client_new_node.node.web3.toWei(1, "ether") 352 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 353 354 amount1_last = client_new_node.node.eth.getBalance(address_delegate) 355 log.info("The wallet balance:{}".format(amount1_last)) 356 assert amount1_last - amount1_after == delegate_amount 357 assert delegate_amount * 2 - (amount1_last - amount_before) < client_new_node.node.web3.toWei(1, "ether") 358 359 360 @pytest.mark.P2 361 def test_POP_013(client_consensus, client_new_node, new_genesis_env): 362 """ 363 :param client_consensus: 364 :param client_new_node: 365 :param new_genesis_env: 366 :return: 367 """ 368 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 369 old_amount = client_consensus.economic.delegate_limit * 2 370 new_amount = client_consensus.economic.delegate_limit 371 genesis.economicModel.staking.operatingThreshold = old_amount 372 new_genesis_env.set_genesis(genesis.to_dict()) 373 new_genesis_env.deploy_all() 374 375 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 376 str(new_amount), effectiveflag=False) 377 log.info(block) 378 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 379 10 ** 18 * 10000000) 380 wait_block_number(client_new_node.node, block) 381 result = client_new_node.staking.create_staking(0, address1, address1) 382 assert_code(result, 0) 383 384 address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 385 10 ** 18 * 10000000) 386 result = client_new_node.delegate.delegate(0, address2, amount=new_amount) 387 log.info(result) 388 assert_code(result, 301105) 389 result = client_new_node.delegate.delegate(0, address2, amount=old_amount) 390 assert_code(result, 0) 391 result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) 392 assert_code(result, 301104) 393 result = client_new_node.staking.increase_staking(0, address1, amount=old_amount) 394 assert_code(result, 0) 395 396 397 @pytest.mark.P2 398 def test_POP_014(client_consensus, client_new_node): 399 """ 400 Parameter not in effect - initiate redemption 401 :param client_consensus: 402 :param client_new_node: 403 :param new_genesis_env: 404 :return: 405 """ 406 client_consensus.economic.env.deploy_all() 407 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 408 10 ** 18 * 10000000) 409 address_delegate_1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 410 10 ** 18 * 10000000) 411 result = client_new_node.staking.create_staking(0, address1, address1) 412 assert_code(result, 0) 413 delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(20, "ether") 414 log.info("Amount entrusted{}".format(delegate_amount)) 415 416 result = client_new_node.delegate.delegate(0, address_delegate_1, amount=delegate_amount) 417 assert_code(result, 0) 418 amount1_before = client_new_node.node.eth.getBalance(address_delegate_1) 419 log.info("The wallet balance:{}".format(amount1_before)) 420 param_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(10, "ether") 421 422 block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", 423 str(param_amount), effectiveflag=False) 424 wait_block_number(client_new_node.node, block) 425 log.info("The delegate is initiated after the parameter takes effect") 426 address_delegate_2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 427 10 ** 18 * 10000000) 428 result = client_new_node.delegate.delegate(0, address_delegate_2, amount=delegate_amount) 429 assert_code(result, 0) 430 amount2_before = client_new_node.node.eth.getBalance(address_delegate_1) 431 log.info("The wallet balance:{}".format(amount2_before)) 432 433 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 434 staking_blocknum = msg["Ret"]["StakingBlockNum"] 435 withdrew_delegate = delegate_amount - param_amount + client_consensus.node.web3.toWei(1, "ether") 436 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_1, 437 amount=withdrew_delegate) 438 assert_code(result, 0) 439 amount1_after = client_new_node.node.eth.getBalance(address_delegate_1) 440 log.info("The wallet balance:{}".format(amount1_after)) 441 amount1_dill = amount1_after - amount1_before 442 assert withdrew_delegate - amount1_dill < client_new_node.node.web3.toWei(1, "ether") 443 444 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_2, 445 amount=withdrew_delegate) 446 assert_code(result, 0) 447 amount2_after = client_new_node.node.eth.getBalance(address_delegate_2) 448 log.info("The wallet balance:{}".format(amount2_after)) 449 amount1_dill = amount2_after - amount2_before 450 assert withdrew_delegate - amount1_dill < client_new_node.node.web3.toWei(1, "ether") 451 452 453 @pytest.mark.P2 454 def test_POP_015(client_consensus, clients_noconsensus, new_genesis_env): 455 """ 456 Increase the number of alternative nodes 457 :param client_consensus: 458 :param client_new_node: 459 :param new_genesis_env: 460 :return: 461 """ 462 463 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 464 genesis.economicModel.staking.maxValidators = 5 465 new_genesis_env.set_genesis(genesis.to_dict()) 466 new_genesis_env.deploy_all() 467 client1 = clients_noconsensus[0] 468 client2 = clients_noconsensus[1] 469 address, _ = client1.economic.account.generate_account(client1.node.web3, 470 10 ** 18 * 10000000) 471 staking_amount = client1.economic.create_staking_limit 472 result = client1.staking.create_staking(0, address, address, amount=staking_amount * 2) 473 assert_code(result, 0) 474 param = 6 475 block = param_governance_verify_before_endblock(client_consensus, "staking", "maxValidators", 476 str(param)) 477 wait_block_number(client2.node, block) 478 address1, _ = client2.economic.account.generate_account(client2.node.web3, 479 10 ** 18 * 10000000) 480 result = client2.staking.create_staking(0, address1, address1, amount=staking_amount * 3) 481 assert_code(result, 0) 482 483 client2.economic.wait_settlement_blocknum(client2.node) 484 getVerifierList = get_pledge_list(client2.node.ppos.getVerifierList) 485 log.info(getVerifierList) 486 assert len(getVerifierList) == 6 487 node_id_1 = client1.node.node_id 488 node_id_2 = client2.node.node_id 489 assert node_id_1 in getVerifierList 490 assert node_id_2 in getVerifierList 491 492 493 @pytest.mark.P2 494 def test_POP_016(client_consensus, clients_noconsensus, new_genesis_env): 495 """ 496 Reduce the number of alternative nodes 497 :param client_consensus: 498 :param client_new_node: 499 :param new_genesis_env: 500 :return: 501 """ 502 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 503 genesis.economicModel.staking.maxValidators = 6 504 new_genesis_env.set_genesis(genesis.to_dict()) 505 new_genesis_env.deploy_all() 506 client1 = clients_noconsensus[0] 507 client2 = clients_noconsensus[1] 508 param = 5 509 block = param_governance_verify_before_endblock(client_consensus, "staking", "maxValidators", 510 str(param)) 511 wait_block_number(client2.node, block) 512 address, _ = client1.economic.account.generate_account(client1.node.web3, 513 10 ** 18 * 10000000) 514 staking_amount = client1.economic.create_staking_limit 515 result = client1.staking.create_staking(0, address, address, amount=staking_amount * 2) 516 assert_code(result, 0) 517 address1, _ = client2.economic.account.generate_account(client2.node.web3, 518 10 ** 18 * 10000000) 519 result = client2.staking.create_staking(0, address1, address1, amount=staking_amount * 3) 520 assert_code(result, 0) 521 522 client2.economic.wait_settlement_blocknum(client2.node) 523 getVerifierList = get_pledge_list(client2.node.ppos.getVerifierList) 524 log.info(getVerifierList) 525 assert len(getVerifierList) == 5 526 527 528 @pytest.mark.P2 529 def test_POP_017(client_consensus, clients_noconsensus, new_genesis_env): 530 """ 531 Increase the number of node candidates - not active 532 :param client_consensus: 533 :param client_new_node: 534 :param new_genesis_env: 535 :return: 536 """ 537 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 538 genesis.economicModel.staking.maxValidators = 5 539 new_genesis_env.set_genesis(genesis.to_dict()) 540 new_genesis_env.deploy_all() 541 param = 6 542 block = param_governance_verify_before_endblock(client_consensus, "staking", "maxValidators", 543 str(param), effectiveflag=False) 544 client1 = clients_noconsensus[0] 545 client2 = clients_noconsensus[1] 546 wait_block_number(client2.node, block) 547 address, _ = client1.economic.account.generate_account(client1.node.web3, 548 10 ** 18 * 10000000) 549 staking_amount = client1.economic.create_staking_limit 550 result = client1.staking.create_staking(0, address, address, amount=staking_amount * 2) 551 assert_code(result, 0) 552 address1, _ = client2.economic.account.generate_account(client2.node.web3, 553 10 ** 18 * 10000000) 554 result = client2.staking.create_staking(0, address1, address1, amount=staking_amount * 3) 555 assert_code(result, 0) 556 557 client2.economic.wait_settlement_blocknum(client2.node) 558 getVerifierList = get_pledge_list(client2.node.ppos.getVerifierList) 559 log.info(getVerifierList) 560 assert len(getVerifierList) == 5 561 562 563 @pytest.mark.P2 564 def test_POP_018(client_consensus, clients_noconsensus, new_genesis_env): 565 """ 566 Reduce the number of node candidates - not in effect 567 :param client_consensus: 568 :param client_new_node: 569 :param new_genesis_env: 570 :return: 571 """ 572 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 573 genesis.economicModel.staking.maxValidators = 6 574 new_genesis_env.set_genesis(genesis.to_dict()) 575 new_genesis_env.deploy_all() 576 client1 = clients_noconsensus[0] 577 client2 = clients_noconsensus[1] 578 579 address, _ = client1.economic.account.generate_account(client1.node.web3, 580 10 ** 18 * 10000000) 581 staking_amount = client1.economic.create_staking_limit 582 583 result = client1.staking.create_staking(0, address, address, amount=staking_amount * 2) 584 assert_code(result, 0) 585 param = 5 586 block = param_governance_verify_before_endblock(client_consensus, "staking", "maxValidators", 587 str(param), effectiveflag=False) 588 wait_block_number(client2.node, block) 589 address1, _ = client2.economic.account.generate_account(client2.node.web3, 590 10 ** 18 * 10000000) 591 result = client2.staking.create_staking(0, address1, address1, amount=staking_amount * 3) 592 assert_code(result, 0) 593 594 client2.economic.wait_settlement_blocknum(client2.node) 595 getVerifierList = get_pledge_list(client2.node.ppos.getVerifierList) 596 log.info(getVerifierList) 597 assert len(getVerifierList) == 6 598 node_id_1 = client1.node.node_id 599 node_id_2 = client2.node.node_id 600 assert node_id_1 in getVerifierList 601 assert node_id_2 in getVerifierList 602 603 604 @pytest.mark.P2 605 def test_POP_019(client_consensus, client_new_node, new_genesis_env): 606 """ 607 Increased lock - up threshold 608 :param client_consensus: 609 :param client_new_node: 610 :param new_genesis_env: 611 :return: 612 """ 613 new_genesis_env.deploy_all() 614 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 615 10 ** 18 * 10000000) 616 result = client_new_node.staking.create_staking(0, address, address) 617 assert_code(result, 0) 618 param = 3 619 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", 620 str(param)) 621 wait_block_number(client_new_node.node, block) 622 623 result = client_new_node.staking.withdrew_staking(address) 624 assert_code(result, 0) 625 amount1 = client_new_node.node.eth.getBalance(address) 626 log.info("The wallet balance:{}".format(amount1)) 627 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) 628 amount2 = client_new_node.node.eth.getBalance(address) 629 log.info("The wallet balance:{}".format(amount2)) 630 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 631 amount3 = client_new_node.node.eth.getBalance(address) 632 log.info("The wallet balance:{}".format(amount3)) 633 staking_amount = client_new_node.economic.create_staking_limit 634 assert amount3 - amount2 == staking_amount 635 636 637 @pytest.mark.P2 638 def test_POP_020(client_consensus, client_new_node, new_genesis_env): 639 """ 640 Reduce lock - up threshold 641 :param client_consensus: 642 :param client_new_node: 643 :param new_genesis_env: 644 :return: 645 """ 646 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 647 unStakeFreezeDuration = 3 648 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration 649 new_genesis_env.set_genesis(genesis.to_dict()) 650 new_genesis_env.deploy_all() 651 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 652 10 ** 18 * 10000000) 653 result = client_new_node.staking.create_staking(0, address, address) 654 assert_code(result, 0) 655 param = 2 656 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", 657 str(param)) 658 wait_block_number(client_new_node.node, block) 659 660 result = client_new_node.staking.withdrew_staking(address) 661 assert_code(result, 0) 662 amount1 = client_new_node.node.eth.getBalance(address) 663 log.info("The wallet balance:{}".format(amount1)) 664 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=1) 665 amount2 = client_new_node.node.eth.getBalance(address) 666 log.info("The wallet balance:{}".format(amount2)) 667 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 668 amount3 = client_new_node.node.eth.getBalance(address) 669 log.info("The wallet balance:{}".format(amount3)) 670 staking_amount = client_new_node.economic.create_staking_limit 671 assert amount3 - amount2 == staking_amount 672 673 674 @pytest.mark.P2 675 def test_POP_021(client_consensus, client_new_node, new_genesis_env): 676 """ 677 Increased lock - time threshold - not in effect 678 :param client_consensus: 679 :param client_new_node: 680 :param new_genesis_env: 681 :return: 682 """ 683 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 684 unStakeFreezeDuration = 2 685 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration 686 new_genesis_env.set_genesis(genesis.to_dict()) 687 new_genesis_env.deploy_all() 688 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 689 10 ** 18 * 10000000) 690 result = client_new_node.staking.create_staking(0, address, address) 691 assert_code(result, 0) 692 693 param = 3 694 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", 695 str(param), effectiveflag=False) 696 wait_block_number(client_new_node.node, block) 697 698 result = client_new_node.staking.withdrew_staking(address) 699 assert_code(result, 0) 700 amount1 = client_new_node.node.eth.getBalance(address) 701 log.info("The wallet balance:{}".format(amount1)) 702 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=1) 703 amount2 = client_new_node.node.eth.getBalance(address) 704 log.info("The wallet balance:{}".format(amount2)) 705 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 706 amount3 = client_new_node.node.eth.getBalance(address) 707 log.info("The wallet balance:{}".format(amount3)) 708 staking_amount = client_new_node.economic.create_staking_limit 709 assert amount3 - amount2 == staking_amount 710 711 712 @pytest.mark.P2 713 def test_POP_022(client_consensus, client_new_node, new_genesis_env): 714 """ 715 Reduced lockup threshold - not in effect 716 :param client_consensus: 717 :param client_new_node: 718 :param new_genesis_env: 719 :return: 720 """ 721 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 722 unStakeFreezeDuration = 3 723 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration 724 new_genesis_env.set_genesis(genesis.to_dict()) 725 new_genesis_env.deploy_all() 726 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 727 10 ** 18 * 10000000) 728 result = client_new_node.staking.create_staking(0, address, address) 729 assert_code(result, 0) 730 param = 2 731 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", 732 str(param), effectiveflag=False) 733 wait_block_number(client_new_node.node, block) 734 735 result = client_new_node.staking.withdrew_staking(address) 736 assert_code(result, 0) 737 amount1 = client_new_node.node.eth.getBalance(address) 738 log.info("The wallet balance:{}".format(amount1)) 739 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) 740 amount2 = client_new_node.node.eth.getBalance(address) 741 log.info("The wallet balance:{}".format(amount2)) 742 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 743 amount3 = client_new_node.node.eth.getBalance(address) 744 log.info("The wallet balance:{}".format(amount3)) 745 staking_amount = client_new_node.economic.create_staking_limit 746 assert amount3 - amount2 == staking_amount 747 748 749 @pytest.mark.P2 750 def test_POP_023(client_consensus, client_new_node, new_genesis_env): 751 """ 752 Return pledge before lock time parameter takes effect 753 :param client_consensus: 754 :param client_new_node: 755 :param new_genesis_env: 756 :return: 757 """ 758 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 759 unStakeFreezeDuration = 2 760 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration 761 new_genesis_env.set_genesis(genesis.to_dict()) 762 new_genesis_env.deploy_all() 763 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 764 10 ** 18 * 10000000) 765 result = client_new_node.staking.create_staking(0, address, address) 766 assert_code(result, 0) 767 log.info("Next settlement period") 768 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 769 result = client_new_node.staking.withdrew_staking(address) 770 assert_code(result, 0) 771 log.info("Withdraw pledge before parameter takes effect") 772 param = 3 773 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", 774 str(param)) 775 wait_block_number(client_new_node.node, block) 776 777 amount1 = client_new_node.node.eth.getBalance(address) 778 log.info("The wallet balance:{}".format(amount1)) 779 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 780 amount2 = client_new_node.node.eth.getBalance(address) 781 log.info("The wallet balance:{}".format(amount2)) 782 staking_amount = client_new_node.economic.create_staking_limit 783 assert amount2 - amount1 == staking_amount