github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos/test_token_init.py (about) 1 import math 2 import time 3 4 import pytest 5 import allure 6 from dacite import from_dict 7 from common.key import get_pub_key, mock_duplicate_sign 8 from common.log import log 9 from client_sdk_python import Web3 10 from decimal import Decimal 11 from tests.conftest import get_clients_noconsensus 12 from tests.lib import (EconomicConfig, 13 Genesis, 14 check_node_in_list, 15 assert_code, 16 von_amount, 17 get_governable_parameter_value, 18 get_pledge_list, HexBytes, 19 wait_block_number) 20 21 22 @pytest.mark.P0 23 def test_IT_IA_002_to_007(new_genesis_env): 24 """ 25 IT_IA_002:链初始化-查看token发行总量账户初始值 26 IT_IA_003:链初始化-查看platON基金会账户初始值 27 IT_IA_004:链初始化-查看激励池账户 28 IT_IA_005:链初始化-查看剩余总账户 29 IT_IA_006:链初始化-查看锁仓账户余额 30 IT_IA_007:链初始化-查看质押账户余额 31 :return:验证链初始化后token各内置账户初始值 32 """ 33 # Initialization genesis file Initial amount 34 node_count = len(new_genesis_env.consensus_node_list) 35 default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether') 36 node = new_genesis_env.get_rand_node() 37 community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000 38 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 39 genesis.economicModel.innerAcc.cdfBalance = community_amount 40 surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000) 41 genesis.alloc = { 42 "1000000000000000000000000000000000000003": { 43 "balance": "200000000000000000000000000" 44 }, 45 "0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": { 46 "balance": surplus_amount 47 } 48 } 49 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 50 genesis.to_file(new_file) 51 new_genesis_env.deploy_all(new_file) 52 53 # Verify the amount of each built-in account 54 foundation_louckup = node.eth.getBalance(EconomicConfig.FOUNDATION_LOCKUP_ADDRESS) 55 log.info('Initial lock up contract address: {} amount:{}'.format(EconomicConfig.FOUNDATION_LOCKUP_ADDRESS, 56 foundation_louckup)) 57 incentive_pool = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 58 log.info('Incentive pool address:{} amount:{}'.format(EconomicConfig.INCENTIVEPOOL_ADDRESS, incentive_pool)) 59 staking = node.eth.getBalance(EconomicConfig.STAKING_ADDRESS) 60 log.info('Address of pledge contract:{} amount:{}'.format(EconomicConfig.STAKING_ADDRESS, staking)) 61 foundation = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS)) 62 log.info('PlatON Foundation address:{} amount:{}'.format(EconomicConfig.FOUNDATION_ADDRESS, foundation)) 63 remain = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.REMAIN_ACCOUNT_ADDRESS)) 64 log.info('Remaining total account address:{} amount:{}'.format(EconomicConfig.REMAIN_ACCOUNT_ADDRESS, remain)) 65 develop = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS)) 66 log.info('Community developer foundation address:{} amount:{}'.format(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS, 67 develop)) 68 reality_total = foundation_louckup + incentive_pool + staking + foundation + remain + develop 69 log.info("Total issuance of Chuangshi block:{}".format(reality_total)) 70 log.info("--------------Dividing line---------------") 71 assert foundation == 0, "ErrMsg:Initial amount of foundation {}".format(foundation) 72 assert foundation_louckup == 259096239000000000000000000, "ErrMsg:Initial lock up amount of foundation {}".format( 73 foundation_louckup) 74 assert staking == default_pledge_amount, "ErrMsg:Amount of initial pledge account: {}".format(staking) 75 assert incentive_pool == 262215742000000000000000000, "ErrMsg:Initial amount of incentive pool {}".format( 76 incentive_pool) 77 assert remain == int(surplus_amount), "ErrMsg:Initial amount of remaining total account {}".format(remain) 78 assert develop == 0, "ErrMsg:Community developer foundation account amount {}".format(develop) 79 assert reality_total == EconomicConfig.TOKEN_TOTAL, "ErrMsg:Initialize release value {}".format(reality_total) 80 81 82 @allure.title("Two distribution-Transfer amount:{value}") 83 @pytest.mark.P0 84 @pytest.mark.parametrize('value', [1000, 0.000000000000000001, 100000000]) 85 def test_IT_SD_004_to_006(client_consensus, value): 86 """ 87 IT_SD_006:二次分配:普通钱包转keyshard钱包 88 IT_SD_004:二次分配:转账金额为1von 89 IT_SD_005:二次分配:转账金额为1亿LAT 90 :param client_consensus: 91 :param value: 92 :return: 93 """ 94 value = client_consensus.node.web3.toWei(value, 'ether') 95 address, _ = client_consensus.economic.account.generate_account(client_consensus.node.web3, value) 96 balance = client_consensus.node.eth.getBalance(address) 97 log.info("transaction address:{},account:{}".format(address, balance)) 98 assert balance == value, "ErrMsg:Transfer amount {}".format(balance) 99 100 101 @pytest.mark.P1 102 @pytest.mark.parametrize('value', [2000, 1000]) 103 def test_IT_SD_002_003(global_test_env, value): 104 """ 105 IT_SD_002:二次分配:账户余额不足 106 IT_SD_003:二次分配:转账手续费不足 107 :param global_test_env: 108 :param value: 109 :return: 110 """ 111 node = global_test_env.get_rand_node() 112 address, _ = global_test_env.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 113 status = True 114 # Account balance insufficient transfer 115 try: 116 address1, _ = global_test_env.account.generate_account(node.web3, 0) 117 transfer_amount = node.web3.toWei(value, 'ether') 118 result = global_test_env.account.sendTransaction(node.web3, '', address, address1, node.web3.platon.gasPrice, 119 21000, transfer_amount) 120 log.info("result: {}".format(result)) 121 status = False 122 except Exception as e: 123 log.info("Use case success, exception information:{} ".format(str(e))) 124 assert status, "ErrMsg:Transfer result {}".format(status) 125 126 127 @pytest.mark.P1 128 def test_IT_SD_011(global_test_env): 129 """ 130 账户转账校验:转账gas费不足 131 :param global_test_env: 132 :return: 133 """ 134 node = global_test_env.get_rand_node() 135 address, _ = global_test_env.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 136 status = True 137 # Insufficient gas fee for transfer 138 try: 139 address1, _ = global_test_env.account.generate_account(node.web3, 0) 140 global_test_env.account.sendTransaction(node.web3, '', address, 141 address1, 142 node.web3.platon.gasPrice, 2100, 500) 143 status = False 144 except Exception as e: 145 log.info("Use case success, exception information:{} ".format(str(e))) 146 assert status, "ErrMsg:Transfer result {}".format(status) 147 148 149 @pytest.mark.P2 150 def test_IT_SD_007(global_test_env): 151 """ 152 账户转账校验:本账户转本账户 153 :return: 154 """ 155 node = global_test_env.get_rand_node() 156 value = node.web3.toWei(1000, 'ether') 157 address, _ = global_test_env.account.generate_account(node.web3, value) 158 balance = node.eth.getBalance(address) 159 log.info("Account balance before transfer:{}".format(balance)) 160 result = global_test_env.account.sendTransaction(node.web3, '', address, address, node.eth.gasPrice, 21000, 100) 161 assert result is not None, "ErrMsg:Transfer result {}".format(result) 162 balance1 = node.eth.getBalance(address) 163 log.info("Account balance after transfer: {}".format(balance1)) 164 log.info("Transaction fee: {}".format(node.web3.platon.gasPrice * 21000)) 165 assert balance == balance1 + node.web3.platon.gasPrice * 21000, "ErrMsg:Account balance after transfer:{}".format( 166 balance1) 167 168 169 @pytest.mark.P0 170 def test_IT_SD_008(global_test_env): 171 """ 172 二次分配:普通账户转platON基金会账户 173 :return: 174 """ 175 node = global_test_env.get_rand_node() 176 value = node.web3.toWei(1000, 'ether') 177 address, _ = global_test_env.account.generate_account(node.web3, value) 178 balance = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 179 result = global_test_env.account.sendTransaction(node.web3, '', address, EconomicConfig.INCENTIVEPOOL_ADDRESS, 180 node.eth.gasPrice, 21000, node.web3.toWei(100, 'ether')) 181 assert result is not None, "ErrMsg:Transfer result {}".format(result) 182 balance1 = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 183 log.info("Account balance after transfer: {}".format(balance1)) 184 log.info("Transaction fee: {}".format(node.web3.platon.gasPrice * 21000)) 185 assert balance1 == balance + node.web3.toWei(100, 186 'ether') + node.web3.platon.gasPrice * 21000, "ErrMsg:Account balance after transfer:{}".format( 187 balance1) 188 189 190 def sendTransaction_input_nonce(client, data, from_address, to_address, gasPrice, gas, value, nonce, 191 check_address=True): 192 node = client.node 193 account = client.economic.account.accounts[from_address] 194 print(account) 195 if check_address: 196 to_address = Web3.toChecksumAddress(to_address) 197 tmp_from_address = Web3.toChecksumAddress(from_address) 198 199 transaction_dict = { 200 "to": to_address, 201 "gasPrice": gasPrice, 202 "gas": gas, 203 "nonce": nonce, 204 "data": data, 205 "chainId": client.economic.account.chain_id, 206 "value": value, 207 'from': tmp_from_address, 208 } 209 signedTransactionDict = node.eth.account.signTransaction( 210 transaction_dict, account['prikey'] 211 ) 212 data = signedTransactionDict.rawTransaction 213 result = HexBytes(node.eth.sendRawTransaction(data)).hex() 214 res = node.eth.waitForTransactionReceipt(result) 215 216 return res 217 218 219 @pytest.mark.P2 220 def test_IT_SD_009(client_consensus): 221 """ 222 同一时间多次转账 223 :return: 224 """ 225 client = client_consensus 226 economic = client.economic 227 node = client.node 228 economic.env.deploy_all() 229 address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 230 address1, _ = economic.account.generate_account(node.web3, 0) 231 nonce = node.eth.getTransactionCount(address) 232 print('nonce: ', nonce) 233 balance = node.eth.getBalance(address1) 234 log.info("balance: {}".format(balance)) 235 sendTransaction_input_nonce(client, '', address, address1, node.eth.gasPrice, 21000, node.web3.toWei(100, 'ether'), 236 nonce) 237 sendTransaction_input_nonce(client, '', address, address1, node.eth.gasPrice, 21000, node.web3.toWei(100, 'ether'), 238 nonce + 1) 239 time.sleep(3) 240 balance1 = node.eth.getBalance(address1) 241 log.info("Account balance after transfer: {}".format(balance1)) 242 assert balance1 == balance + node.web3.toWei(200, 'ether'), "ErrMsg:Account balance after transfer:{}".format( 243 balance1) 244 245 246 @pytest.mark.P2 247 def test_IT_SD_010(client_consensus): 248 """ 249 同一时间多次转账,余额不足 250 :return: 251 """ 252 client = client_consensus 253 economic = client.economic 254 node = client.node 255 economic.env.deploy_all() 256 address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 257 address1, _ = economic.account.generate_account(node.web3, 0) 258 balance = node.eth.getBalance(address1) 259 log.info("balance: {}".format(balance)) 260 try: 261 nonce = node.eth.getTransactionCount(address) 262 log.info('nonce: {}'.format(nonce)) 263 sendTransaction_input_nonce(client, '', address, address1, node.eth.gasPrice, 21000, 264 node.web3.toWei(500, 'ether'), nonce) 265 sendTransaction_input_nonce(client, '', address, address1, node.eth.gasPrice, 21000, 266 node.web3.toWei(600, 'ether'), nonce + 1) 267 except Exception as e: 268 log.info("Use case success, exception information:{} ".format(str(e))) 269 time.sleep(3) 270 balance1 = node.eth.getBalance(address1) 271 log.info("Account balance after transfer: {}".format(balance1)) 272 assert balance1 == balance + node.web3.toWei(500, 'ether'), "ErrMsg:Account balance after transfer:{}".format( 273 balance1) 274 275 276 def consensus_node_pledge_award_assertion(client, address): 277 """ 278 内置节点质押奖励断言 279 :param client: 280 :param address: 281 :return: 282 """ 283 blockNumber = client.node.eth.blockNumber 284 log.info("Current block height:{}".format(blockNumber)) 285 incentive_pool_balance = client.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 286 log.info("Balance of incentive pool:{}".format(incentive_pool_balance)) 287 CandidateInfo = client.ppos.getCandidateInfo(client.node.node_id) 288 log.info("Pledgor node information:{}".format(CandidateInfo)) 289 290 # wait settlement block 291 client.economic.wait_settlement_blocknum(client.node) 292 time.sleep(5) 293 VerifierList = client.ppos.getVerifierList() 294 log.info("Current settlement cycle verifier list:{}".format(VerifierList)) 295 ValidatorList = client.ppos.getValidatorList() 296 log.info("Current consensus cycle verifier list:{}".format(ValidatorList)) 297 # Application for withdrew staking 298 result = client.staking.withdrew_staking(address) 299 assert_code(result, 0) 300 # wait settlement block 301 client.economic.wait_settlement_blocknum(client.node) 302 # view incentive pool amonut 303 incentive_pool_balance2 = client.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 304 log.info( 305 "incentive pool address:{} amount:{}".format(EconomicConfig.INCENTIVEPOOL_ADDRESS, incentive_pool_balance2)) 306 assert incentive_pool_balance2 - incentive_pool_balance < client.node.web3.toWei(1, 307 'ether'), "ErrMsg:Balance of incentive pool:{}".format( 308 incentive_pool_balance2) 309 310 311 def no_consensus_node_pledge_award_assertion(client, benifit_address, from_address): 312 """ 313 非内置节点质押奖励断言 314 :param client: 315 :param benifit_address: 316 :param from_address: 317 :return: 318 """ 319 CandidateInfo = client.ppos.getCandidateInfo(client.node.node_id) 320 log.info("Pledgor node information:{}".format(CandidateInfo)) 321 balance = client.node.eth.getBalance(benifit_address) 322 log.info("benifit address:{} amount: {}".format(benifit_address, balance)) 323 324 # wait settlement block 325 client.economic.wait_settlement_blocknum(client.node) 326 time.sleep(5) 327 VerifierList = client.ppos.getVerifierList() 328 log.info("Current settlement cycle verifier list:{}".format(VerifierList)) 329 ValidatorList = client.ppos.getValidatorList() 330 log.info("Current consensus cycle verifier list:{}".format(ValidatorList)) 331 block_reward, staking_reward = client.economic.get_current_year_reward(client.node) 332 for i in range(4): 333 result = check_node_in_list(client.node.node_id, client.ppos.getValidatorList) 334 log.info("Current node in consensus list status:{}".format(result)) 335 if result: 336 # wait consensus block 337 client.economic.wait_consensus_blocknum(client.node) 338 # Application for withdrew staking 339 result = client.staking.withdrew_staking(from_address) 340 assert_code(result, 0) 341 incentive_pool_balance1 = client.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 342 log.info("incentive pool amount:{}".format(incentive_pool_balance1)) 343 # wait settlement block 344 client.economic.wait_settlement_blocknum(client.node) 345 # Count the number of blocks out of pledge node 346 blocknumber = client.economic.get_block_count_number(client.node, 5) 347 log.info("blocknumber: {}".format(blocknumber)) 348 balance1 = client.node.eth.getBalance(benifit_address) 349 log.info("benifit address:{} amount:{}".format(benifit_address, balance1)) 350 351 # Verify block rewards 352 log.info("Expected bonus:{}".format(Decimal(str(block_reward)) * blocknumber)) 353 assert balance + Decimal(str(block_reward)) * blocknumber - balance1 < client.node.web3.toWei( 354 1, 'ether'), "ErrMsg:benifit address:{} amount:{}".format( 355 benifit_address, balance1) 356 break 357 else: 358 # wait consensus block 359 client.economic.wait_consensus_blocknum(client.node) 360 361 362 @pytest.mark.p1 363 def test_AL_IE_001(client_consensus): 364 """ 365 查看初始激励池总额 366 :param client_consensus: 367 :return: 368 """ 369 client = client_consensus 370 economic = client.economic 371 node = client.node 372 # 初始化环境 373 client.economic.env.deploy_all() 374 # 查询激励池初始金额 375 incentive_pool = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, 0) 376 assert incentive_pool == 262215742000000000000000000, "ErrMsg:Initial amount of incentive pool {}".format( 377 incentive_pool) 378 379 380 @pytest.mark.P2 381 def test_AL_IE_002(clients_new_node): 382 """ 383 转账到激励池 384 :param clients_new_node: 385 :return: 386 """ 387 client1 = clients_new_node[0] 388 client2 = clients_new_node[1] 389 economic = client1.economic 390 node = client1.node 391 log.info("Node ID:{}".format(node.node_id)) 392 log.info("Current connection node: {}".format(node.node_mark)) 393 address, _ = client1.economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 4)) 394 address1, _ = client1.economic.account.generate_account(node.web3, 0) 395 address2, _ = client1.economic.account.generate_account(node.web3, 0) 396 log.info("staking address: {}".format(address)) 397 # Free amount application pledge node 398 result = client1.staking.create_staking(0, address1, address) 399 assert_code(result, 0) 400 # Wait for the settlement round to end 401 economic.wait_settlement_blocknum(node) 402 # 获取当前结算周期验证人 403 verifier_list = node.ppos.getVerifierList() 404 log.info("verifier_list: {}".format(verifier_list)) 405 # view block_reward 406 block_reward, staking_reward = economic.get_current_year_reward(node) 407 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 408 # view account amount 409 benifit_balance = node.eth.getBalance(address1) 410 log.info("benifit_balance: {}".format(benifit_balance)) 411 # view benifit reward 412 blocknumber = view_benifit_reward(client1, address) 413 # view account amount again 414 benifit_balance1 = node.eth.getBalance(address1) 415 log.info("benifit_balance: {}".format(benifit_balance1)) 416 reward = int(blocknumber * Decimal(str(block_reward))) 417 assert benifit_balance1 == staking_reward + reward, "ErrMsg:benifit_balance: {}".format(benifit_balance1) 418 # Transfer to the incentive pool 419 result = client1.economic.account.sendTransaction(node.web3, '', address, EconomicConfig.INCENTIVEPOOL_ADDRESS, 420 node.eth.gasPrice, 21000, node.web3.toWei(1000, 'ether')) 421 assert result is not None, "ErrMsg:Transfer result {}".format(result) 422 time.sleep(5) 423 # Free amount application pledge node 424 result = client2.staking.create_staking(0, address2, address, amount=von_amount(economic.create_staking_limit, 2)) 425 assert_code(result, 0) 426 # Wait for the settlement round to end 427 economic.wait_settlement_blocknum(client2.node) 428 # view account amount 429 benifit_balance2 = client2.node.eth.getBalance(address2) 430 log.info("benifit_balance: {}".format(benifit_balance2)) 431 # view benifit reward 432 blocknumber = view_benifit_reward(client2, address) 433 # view account amount again 434 benifit_balance3 = client2.node.eth.getBalance(address2) 435 log.info("benifit_balance: {}".format(benifit_balance3)) 436 reward = int(blocknumber * Decimal(str(block_reward))) 437 assert benifit_balance3 == staking_reward + reward, "ErrMsg:benifit_balance: {}".format(benifit_balance3) 438 439 440 @pytest.mark.P1 441 def test_AL_IE_003(clients_new_node): 442 """ 443 自由账户创建质押节点且收益地址为激励池 444 :param clients_new_node: 445 :return: 446 """ 447 log.info("Node ID:{}".format(clients_new_node[0].node.node_id)) 448 address, _ = clients_new_node[0].economic.account.generate_account(clients_new_node[0].node.web3, 449 clients_new_node[ 450 0].economic.create_staking_limit * 2) 451 log.info("staking address: {}".format(address)) 452 # Free amount application pledge node 453 result = clients_new_node[0].staking.create_staking(0, EconomicConfig.INCENTIVEPOOL_ADDRESS, address) 454 assert_code(result, 0) 455 consensus_node_pledge_award_assertion(clients_new_node[0], address) 456 457 458 @pytest.mark.P1 459 def test_AL_IE_004(clients_new_node): 460 """ 461 锁仓账户创建质押节点且收益地址为激励池 462 :param clients_new_node: 463 :return: 464 """ 465 log.info("Node ID:{}".format(clients_new_node[1].node.node_id)) 466 address, _ = clients_new_node[1].economic.account.generate_account(clients_new_node[1].node.web3, 467 clients_new_node[ 468 1].economic.create_staking_limit * 2) 469 log.info("staking address: {}".format(address)) 470 # Create restricting plan 471 staking_amount = clients_new_node[1].economic.create_staking_limit 472 log.info("staking amonut:{}".format(staking_amount)) 473 plan = [{'Epoch': 1, 'Amount': staking_amount}] 474 result = clients_new_node[1].restricting.createRestrictingPlan(address, plan, address) 475 assert_code(result, 0) 476 # Lock in amount application pledge node 477 result = clients_new_node[1].staking.create_staking(1, EconomicConfig.INCENTIVEPOOL_ADDRESS, address) 478 assert_code(result, 0) 479 consensus_node_pledge_award_assertion(clients_new_node[1], address) 480 481 482 @pytest.mark.P1 483 def test_AL_BI_001(client_consensus): 484 """ 485 出块手续费奖励(内置验证人) 486 :param client_consensus: 487 :return: 488 """ 489 incentive_pool_balance = client_consensus.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 490 log.info("incentive_pool_balance: {}".format(incentive_pool_balance)) 491 # create account 492 address1, _ = client_consensus.economic.account.generate_account(client_consensus.node.web3, 100) 493 # view incentive account 494 incentive_pool_balance1 = client_consensus.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 495 log.info("incentive_pool_balance: {}".format(incentive_pool_balance1)) 496 assert incentive_pool_balance1 == incentive_pool_balance + 21000 * client_consensus.node.eth.gasPrice, "ErrMsg:incentive_pool balance: {}".format( 497 incentive_pool_balance1) 498 499 500 @pytest.mark.P1 501 def test_AL_BI_002(new_genesis_env, staking_cfg): 502 """ 503 节点出块率为0被处罚,激励池金额增加 504 :param new_genesis_env: 505 :param staking_cfg: 506 :return: 507 """ 508 # Change configuration parameters 509 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 510 genesis.economicModel.slashing.slashBlocksReward = 5 511 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 512 genesis.to_file(new_file) 513 new_genesis_env.deploy_all(new_file) 514 client_noc_list_obj = get_clients_noconsensus(new_genesis_env, staking_cfg) 515 client1 = client_noc_list_obj[0] 516 client2 = client_noc_list_obj[1] 517 economic = client1.economic 518 node = client1.node 519 log.info("nodeid: {}".format(node.node_id)) 520 # create account 521 address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 522 # create staking 523 result = client1.staking.create_staking(0, address, address) 524 assert_code(result, 0) 525 # Waiting for a settlement round 526 client2.economic.wait_settlement_blocknum(client2.node) 527 # view incentive account 528 incentive_pool_balance = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 529 log.info("incentive_pool_balance: {}".format(incentive_pool_balance)) 530 # view block_reward 531 block_reward, staking_reward = economic.get_current_year_reward(node) 532 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 533 # stop node 534 node.stop() 535 # Waiting for 2 consensus round 536 client2.economic.wait_consensus_blocknum(client2.node, 2) 537 # view verifier list 538 verifier_list = client2.ppos.getVerifierList() 539 log.info("verifier_list: {}".format(verifier_list)) 540 slash_blocks = get_governable_parameter_value(client2, 'slashBlocksReward') 541 log.info("slash_blocks".format(slash_blocks)) 542 # Get the penalty amount 543 penalty_amount = int(Decimal(str(block_reward)) * Decimal(str(slash_blocks))) 544 log.info("penalty_amount: {}".format(penalty_amount)) 545 # view incentive account again 546 incentive_pool_balance1 = client2.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 547 log.info("incentive_pool_balance1: {}".format(incentive_pool_balance1)) 548 assert incentive_pool_balance1 == incentive_pool_balance + penalty_amount, "ErrMsg: incentive_pool_balance: {}".format( 549 incentive_pool_balance1) 550 551 552 @pytest.mark.P1 553 def test_AL_BI_003(client_consensus): 554 """ 555 初始内置账户没有基金会Staking奖励和出块奖励 556 :param client_consensus: 557 :return: 558 """ 559 # view incentive account 560 incentive_pool_balance = client_consensus.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 561 log.info("incentive_pool_balance: {}".format(incentive_pool_balance)) 562 563 # wait settlement block 564 client_consensus.economic.wait_settlement_blocknum(client_consensus.node) 565 566 # view incentive account again 567 incentive_pool_balance1 = client_consensus.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) 568 log.info("incentive_pool_balance: {}".format(incentive_pool_balance1)) 569 570 assert incentive_pool_balance1 == incentive_pool_balance, "ErrMsg: incentive account: {}".format( 571 incentive_pool_balance1) 572 573 574 @pytest.mark.P1 575 def test_AL_BI_004(client_consensus): 576 """ 577 初始验证人退出后重新质押进来 578 :param client_consensus: 579 :return: 580 """ 581 client = client_consensus 582 economic = client.economic 583 node = client.node 584 # Reset environment 585 economic.env.deploy_all() 586 # Query Developer Fund Amount 587 log.info("nodeid: {}".format(node.node_id)) 588 developer_foundation_balance = node.eth.getBalance(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) 589 log.info("incentive_pool_balance: {}".format(developer_foundation_balance)) 590 staking_balance = client_consensus.node.eth.getBalance(EconomicConfig.STAKING_ADDRESS) 591 log.info("staking_balance: {}".format(staking_balance)) 592 # Built in node return pledge 593 result = client.staking.withdrew_staking(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) 594 assert_code(result, 0) 595 # Waiting for the end of the 2 settlement 596 economic.wait_settlement_blocknum(node, 2) 597 # create account 598 address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 599 address1, _ = economic.account.generate_account(node.web3, 0) 600 # Check account balance 601 balance = node.eth.getBalance(address1) 602 log.info("Account Balance: {}".format(balance)) 603 # Node pledge again 604 result = client.staking.create_staking(0, address1, address) 605 assert_code(result, 0) 606 # Waiting for the end of the settlement 607 economic.wait_settlement_blocknum(node) 608 # view block_reward 609 block_reward, staking_reward = economic.get_current_year_reward(node) 610 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 611 # withdrew of pledge 612 result = client.staking.withdrew_staking(address) 613 assert_code(result, 0) 614 # wait settlement block 615 client.economic.wait_settlement_blocknum(client.node) 616 # wait consensus block 617 client.economic.wait_consensus_blocknum(client.node) 618 # count the number of blocks 619 blocknumber = client.economic.get_block_count_number(client.node, 10) 620 log.info("blocknumber: {}".format(blocknumber)) 621 # Check account balance again 622 balance1 = node.eth.getBalance(address1) 623 log.info("Account Balance: {}".format(balance1)) 624 # Pledged income account to get the bonus amount 625 total_reward = int(Decimal(str(block_reward)) * blocknumber) + staking_reward 626 assert balance1 == balance + total_reward, "ErrMsg:benifit_balance: {}".format(balance1) 627 628 629 def create_pledge_node(client, base, multiple=2): 630 """ 631 create pledge node return benifit balance 632 :param client: 633 :param base: 634 :param multiple: 635 :return: 636 """ 637 log.info("Transfer accounts: {}".format(client.economic.create_staking_limit * multiple)) 638 account_balance = client.node.eth.getBalance( 639 client.economic.account.account_with_money['address']) 640 log.info("address: {} accounts: {}".format(client.economic.account.account_with_money['address'], 641 account_balance)) 642 # create account 643 address, _ = client.economic.account.generate_account(client.node.web3, 644 client.economic.create_staking_limit * multiple) 645 646 log.info("address: {} ,amount: {}".format(address, client.node.eth.getBalance(address))) 647 benifit_address, _ = client.economic.account.generate_account(client.node.web3, 0) 648 log.info( 649 "address: {} ,amount: {}".format(benifit_address, client.node.eth.getBalance(benifit_address))) 650 # create staking 651 staking_amount = von_amount(client.economic.create_staking_limit, base) 652 result = client.staking.create_staking(0, benifit_address, address, amount=staking_amount) 653 assert_code(result, 0) 654 log.info("Pledge node information: {}".format( 655 client.ppos.getCandidateInfo(client.node.node_id))) 656 return address, benifit_address 657 658 659 @pytest.mark.P1 660 def test_AL_NBI_001_to_003(client_new_node): 661 """ 662 AL_NBI_001:非内置验证人Staking奖励(犹豫期) 663 AL_NBI_002:非内置验证人出块奖励(犹豫期) 664 AL_NBI_003:非内置验证人区块手续费奖励(犹豫期) 665 :param client_new_node: 666 :return: 667 """ 668 # create pledge node 669 address, benifit_address = create_pledge_node(client_new_node, 1) 670 # view account amount 671 benifit_balance = client_new_node.node.eth.getBalance(benifit_address) 672 log.info("benifit_balance: {}".format(benifit_balance)) 673 # wait consensus block 674 client_new_node.economic.wait_consensus_blocknum(client_new_node.node) 675 # view account amount again 676 benifit_balance1 = client_new_node.node.eth.getBalance(benifit_address) 677 log.info("benifit_balance: {}".format(benifit_balance1)) 678 assert benifit_balance1 == benifit_balance, "ErrMsg:benifit_balance: {}".format( 679 benifit_balance1) 680 681 682 @pytest.mark.P1 683 def test_AL_NBI_004_to_006(new_genesis_env, client_new_node, reset_environment): 684 """ 685 AL_NBI_004:非内置验证人Staking奖励(候选人) 686 AL_NBI_005:非内置验证人出块奖励(候选人) 687 AL_NBI_006:非内置验证人手续费奖励(候选人) 688 :param new_genesis_env: 689 :return: 690 """ 691 # Change configuration parameters 692 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 693 genesis.economicModel.staking.maxValidators = 4 694 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 695 genesis.to_file(new_file) 696 new_genesis_env.deploy_all(new_file) 697 # create pledge node 698 address, benifit_address = create_pledge_node(client_new_node, 1) 699 # view account amount 700 benifit_balance = client_new_node.node.eth.getBalance(benifit_address) 701 log.info("benifit_balance: {}".format(benifit_balance)) 702 # wait settlement block 703 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, 1) 704 # view account amount again 705 benifit_balance1 = client_new_node.node.eth.getBalance(benifit_address) 706 log.info("benifit_balance: {}".format(benifit_balance1)) 707 assert benifit_balance1 == benifit_balance, "ErrMsg: benifit_balance: {}".format( 708 benifit_balance1) 709 710 711 def view_benifit_reward(client, address): 712 """ 713 withdrew pledge return benifit balance and Number of blocks 714 :param client: 715 :param address: 716 :return: 717 """ 718 # withdrew of pledge 719 result = client.staking.withdrew_staking(address) 720 assert_code(result, 0) 721 # wait settlement block 722 client.economic.wait_settlement_blocknum(client.node) 723 # wait consensus block 724 client.economic.wait_consensus_blocknum(client.node) 725 # count the number of blocks 726 blocknumber = client.economic.get_block_count_number(client.node, 10) 727 log.info("blocknumber: {}".format(blocknumber)) 728 return blocknumber 729 730 731 @pytest.mark.P1 732 @pytest.mark.compatibility 733 def test_AL_NBI_007_to_009(client_new_node): 734 """ 735 AL_NBI_007:非内置验证人Staking奖励(验证人) 736 AL_NBI_008:非内置验证人出块奖励(验证人) 737 AL_NBI_009:非内置验证人手续费奖励(验证人) 738 :param client_new_node: 739 :return: 740 """ 741 # create pledge node 742 address, benifit_address = create_pledge_node(client_new_node, 1.1) 743 # view account amount 744 benifit_balance = client_new_node.node.eth.getBalance(benifit_address) 745 log.info("benifit_balance: {}".format(benifit_balance)) 746 # wait settlement block 747 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 748 # view block_reward 749 block_reward, staking_reward = client_new_node.economic.get_current_year_reward( 750 client_new_node.node) 751 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 752 for i in range(4): 753 result = check_node_in_list(client_new_node.node.node_id, client_new_node.ppos.getValidatorList) 754 log.info("Current node in consensus list status:{}".format(result)) 755 if not result: 756 # view benifit reward 757 blocknumber = view_benifit_reward(client_new_node, address) 758 # view account amount again 759 benifit_balance1 = client_new_node.node.eth.getBalance(benifit_address) 760 log.info("benifit_balance: {}".format(benifit_balance1)) 761 assert benifit_balance + staking_reward + blocknumber * Decimal( 762 str(block_reward)) - benifit_balance1 < client_new_node.node.web3.toWei(1, 763 'ether'), "ErrMsg:benifit_balance: {}".format( 764 benifit_balance1) 765 break 766 else: 767 # wait consensus block 768 client_new_node.economic.wait_consensus_blocknum(client_new_node.node) 769 770 771 def assert_benifit_reward(client, benifit_address, address): 772 """ 773 assert Amount of income address 774 :param client: 775 :param benifit_address: 776 :param address: 777 :return: 778 """ 779 # view account amount 780 benifit_balance = client.node.eth.getBalance(benifit_address) 781 log.info("benifit_balance: {}".format(benifit_balance)) 782 # wait settlement block 783 client.economic.wait_settlement_blocknum(client.node) 784 # view block_reward 785 block_reward, staking_reward = client.economic.get_current_year_reward( 786 client.node) 787 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 788 for i in range(4): 789 result = check_node_in_list(client.node.node_id, client.ppos.getValidatorList) 790 log.info("Current node in consensus list status:{}".format(result)) 791 if result: 792 # view benifit reward 793 blocknumber = view_benifit_reward(client, address) 794 # view account amount again 795 benifit_balance1 = client.node.eth.getBalance(benifit_address) 796 log.info("benifit_balance: {}".format(benifit_balance1)) 797 assert benifit_balance + staking_reward + blocknumber * Decimal( 798 str(block_reward)) - benifit_balance1 < client.node.web3.toWei(1, 799 'ether'), "ErrMsg:benifit_balance: {}".format( 800 benifit_balance1) 801 break 802 else: 803 # wait consensus block 804 client.economic.wait_consensus_blocknum(client.node) 805 806 807 @pytest.mark.P1 808 def test_AL_NBI_010_to_012(client_new_node): 809 """ 810 AL_NBI_010:非内置验证人Staking奖励(共识验证人) 811 AL_NBI_011:非内置验证人出块奖励(共识验证人) 812 AL_NBI_012:非内置验证人手续费出块奖励(共识验证人) 813 :param client_new_node: 814 :return: 815 """ 816 # create pledge node 817 address, benifit_address = create_pledge_node(client_new_node, 1.2) 818 # assert benifit reward 819 assert_benifit_reward(client_new_node, benifit_address, address) 820 821 822 @pytest.mark.P1 823 def test_AL_NBI_013(client_new_node): 824 """ 825 修改节点质押收益地址查看收益变更 826 :param client_new_node: 827 :return: 828 """ 829 # create pledge node 830 address, benifit_address = create_pledge_node(client_new_node, 1.3) 831 # create account 832 benifit_address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 0) 833 # change benifit address 834 result = client_new_node.staking.edit_candidate(address, benifit_address1) 835 assert_code(result, 0) 836 # assert benifit reward 837 assert_benifit_reward(client_new_node, benifit_address1, address) 838 839 840 def query_ccount_amount(client, address): 841 balance = client.node.eth.getBalance(address) 842 log.info("balance: {}".format(balance)) 843 return balance 844 845 846 @pytest.mark.P1 847 def test_AL_NBI_014(client_new_node): 848 """ 849 修改节点质押收益地址查看收益变更(正在出块中) 850 :param client_new_node: 851 :return: 852 """ 853 # create pledge node 854 address, benifit_address = create_pledge_node(client_new_node, 1.4) 855 # wait settlement block 856 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 857 # view block_reward 858 block_reward, staking_reward = client_new_node.economic.get_current_year_reward( 859 client_new_node.node) 860 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 861 # view benifit_address amount again 862 benifit_balance = query_ccount_amount(client_new_node, benifit_address) 863 # change benifit address 864 for i in range(4): 865 result = check_node_in_list(client_new_node.node.node_id, client_new_node.ppos.getValidatorList) 866 log.info("Current node in consensus list status:{}".format(result)) 867 if result: 868 current_block = client_new_node.node.eth.blockNumber 869 log.info("Current block:{}".format(current_block)) 870 for i in range(40): 871 nodeid = get_pub_key(client_new_node.node.url, current_block) 872 current_block = client_new_node.node.eth.blockNumber 873 log.info("当前块高:{}".format(current_block)) 874 time.sleep(3) 875 if nodeid == client_new_node.node.node_id: 876 break 877 # create account 878 benifit_address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 0) 879 # change benifit address 880 result = client_new_node.staking.edit_candidate(address, benifit_address1) 881 assert_code(result, 0) 882 # view benifit reward 883 blocknumber = view_benifit_reward(client_new_node, address) 884 885 # view benifit_address1 amount 886 benifit_balance1 = query_ccount_amount(client_new_node, benifit_address1) 887 assert benifit_balance + benifit_balance1 == int(Decimal(str( 888 block_reward)) * blocknumber) + staking_reward, "ErrMsg:benifit_balance + benifit_balance1: {}".format( 889 benifit_balance + benifit_balance1) 890 891 892 @pytest.mark.P1 893 def test_AL_NBI_015(client_new_node): 894 """ 895 退回质押金并处于锁定期 896 :param client_new_node: 897 :return: 898 """ 899 # create pledge node 900 address, benifit_address = create_pledge_node(client_new_node, 1.5) 901 # wait settlement block 902 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 903 # view account amount 904 benifit_balance = query_ccount_amount(client_new_node, benifit_address) 905 for i in range(4): 906 result = check_node_in_list(client_new_node.node.node_id, client_new_node.ppos.getValidatorList) 907 log.info("Current node in consensus list status:{}".format(result)) 908 if result: 909 # withdrew of pledge 910 result = client_new_node.staking.withdrew_staking(address) 911 assert_code(result, 0) 912 log.info("Current settlement cycle verifier list:{}".format(client_new_node.ppos.getVerifierList())) 913 for i in range(40): 914 client_new_node.economic.account.sendTransaction(client_new_node.node.web3, '', 915 client_new_node.economic.account.account_with_money[ 916 'address'], address, 917 client_new_node.node.web3.platon.gasPrice, 918 21000, 100) 919 time.sleep(1) 920 # view account amount again 921 benifit_balance1 = query_ccount_amount(client_new_node, benifit_address) 922 assert benifit_balance1 > benifit_balance, "ErrMsg: {} > {}".format(benifit_balance1, benifit_balance) 923 break 924 else: 925 # wait consensus block 926 client_new_node.economic.wait_consensus_blocknum(client_new_node.node) 927 928 929 @pytest.mark.P2 930 @pytest.mark.compatibility 931 def test_AL_NBI_016(client_new_node, reset_environment): 932 """ 933 被双签处罚槛剔除验证人列表 934 :param client_new_node: 935 :return: 936 """ 937 client = client_new_node 938 economic = client.economic 939 node = client.node 940 client.economic.env.deploy_all() 941 # create account 942 address1, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 943 address2, _ = economic.account.generate_account(node.web3, 0) 944 report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) 945 # create staking 946 staking_amount = von_amount(economic.create_staking_limit, 1.6) 947 result = client_new_node.staking.create_staking(0, address2, address1, amount=staking_amount) 948 assert_code(result, 0) 949 # wait settlement block 950 economic.wait_settlement_blocknum(node) 951 # Check account balance 952 balance = node.eth.getBalance(address2) 953 log.info("Account Balance:{}".format(balance)) 954 # view block_reward 955 block_reward, staking_reward = economic.get_current_year_reward(node) 956 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 957 for i in range(4): 958 result = check_node_in_list(client_new_node.node.node_id, client_new_node.ppos.getValidatorList) 959 log.info("Current node in consensus list status:{}".format(result)) 960 if result: 961 # view Current block 962 current_block = client_new_node.node.eth.blockNumber 963 log.info("Current block: {}".format(current_block)) 964 # Report prepareblock signature 965 report_information = mock_duplicate_sign(1, client_new_node.node.nodekey, client_new_node.node.blsprikey, 966 current_block) 967 log.info("Report information: {}".format(report_information)) 968 result = client_new_node.duplicatesign.reportDuplicateSign(1, report_information, report_address) 969 assert_code(result, 0) 970 # wait settlement block 971 economic.wait_settlement_blocknum(node) 972 # Check account balance again 973 balance1 = node.eth.getBalance(address2) 974 log.info("Account Balance:{}".format(balance1)) 975 # count the number of blocks 976 blocknumber = client_new_node.economic.get_block_count_number(node, 10) 977 log.info("blocknumber: {}".format(blocknumber)) 978 total_block_reward = int(Decimal(str(block_reward)) * Decimal(str(blocknumber))) 979 log.info("total_block_reward: {}".format(total_block_reward)) 980 assert balance1 == balance + total_block_reward, "ErrMsg:benifit_balance1:{}".format(balance1) 981 break 982 else: 983 # wait consensus block 984 economic.wait_consensus_blocknum(node) 985 986 987 @pytest.mark.P2 988 @pytest.mark.compatibility 989 def test_AL_NBI_017(clients_new_node): 990 """ 991 0出块率剔除验证人列表 992 :param clients_new_node: 993 :return: 994 """ 995 clients_new_node[0].economic.env.deploy_all() 996 # create pledge node 997 address, benifit_address = create_pledge_node(clients_new_node[0], 1.6) 998 # wait settlement block 999 clients_new_node[0].economic.wait_settlement_blocknum(clients_new_node[0].node) 1000 log.info("Current settlement cycle verifier list:{}".format(clients_new_node[0].ppos.getVerifierList())) 1001 # view block_reward 1002 block_reward, staking_reward = clients_new_node[0].economic.get_current_year_reward( 1003 clients_new_node[0].node) 1004 log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 1005 # view account amount 1006 benifit_balance = query_ccount_amount(clients_new_node[0], benifit_address) 1007 for i in range(4): 1008 result = check_node_in_list(clients_new_node[0].node.node_id, clients_new_node[0].ppos.getValidatorList) 1009 log.info("Current node in consensus list status:{}".format(result)) 1010 if result: 1011 # stop node 1012 clients_new_node[0].node.stop() 1013 log.info("Current settlement cycle verifier list:{}".format(clients_new_node[1].ppos.getVerifierList())) 1014 # wait settlement block 1015 clients_new_node[1].economic.wait_settlement_blocknum(clients_new_node[1].node) 1016 # view account amount again 1017 benifit_balance1 = query_ccount_amount(clients_new_node[1], benifit_address) 1018 # count the number of blocks 1019 blocknumber = clients_new_node[1].economic.get_block_count_number(clients_new_node[1].node, 5) 1020 log.info("blocknumber: {}".format(blocknumber)) 1021 assert benifit_balance1 == benifit_balance + int( 1022 Decimal(str(block_reward)) * blocknumber), "ErrMsg:benifit_balance1:{}".format(benifit_balance1) 1023 break 1024 else: 1025 # wait consensus block 1026 clients_new_node[0].economic.wait_consensus_blocknum(clients_new_node[0].node) 1027 1028 1029 @pytest.mark.P1 1030 def test_AL_NBI_018(new_genesis_env, client_new_node): 1031 """ 1032 调整质押和出块奖励比例 1033 :param client_new_node: 1034 :return: 1035 """ 1036 # Change configuration parameters 1037 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) 1038 genesis.economicModel.reward.newBlockRate = 60 1039 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" 1040 genesis.to_file(new_file) 1041 new_genesis_env.deploy_all(new_file) 1042 1043 client = client_new_node 1044 economic = client.economic 1045 node = client.node 1046 # create account 1047 address1, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) 1048 address2, _ = economic.account.generate_account(node.web3, 0) 1049 # create pledge 1050 result = client.staking.create_staking(0, address1, address1) 1051 assert_code(result, 0) 1052 # Waiting for the end of the settlement 1053 economic.wait_settlement_blocknum(node) 1054 # Check account balance 1055 balance = node.eth.getBalance(address1) 1056 log.info("Account Balance: {}".format(balance)) 1057 block_reward, staking_reward = economic.get_current_year_reward(node) 1058 # # Get the number of certifiers in the billing cycle list 1059 # verifier_list = get_pledge_list(node.ppos.getVerifierList) 1060 # verifier_num = len(verifier_list) 1061 # # Get block_reward And pledge rewards 1062 # amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, 0) 1063 # block_proportion = str(60 / 100) 1064 # staking_proportion = str(1 - 60 / 100) 1065 # block_reward = int(Decimal(str(amount)) * Decimal(str(block_proportion)) / Decimal(str(1600))) 1066 # staking_reward = int(Decimal(str(amount)) * Decimal(str(staking_proportion)) / Decimal(str(10)) / Decimal( 1067 # str(verifier_num))) 1068 # log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) 1069 # withdrew of pledge 1070 result = client.staking.withdrew_staking(address1) 1071 assert_code(result, 0) 1072 # wait settlement block 1073 client.economic.wait_settlement_blocknum(client.node) 1074 # wait consensus block 1075 client.economic.wait_consensus_blocknum(client.node) 1076 # count the number of blocks 1077 blocknumber = client.economic.get_block_count_number(client.node, 10) 1078 log.info("blocknumber: {}".format(blocknumber)) 1079 # Check account balance again 1080 balance1 = node.eth.getBalance(address1) 1081 log.info("Account Balance: {}".format(balance1)) 1082 # Pledged income account to get the bonus amount 1083 total_reward = int(Decimal(str(block_reward)) * blocknumber) + staking_reward 1084 log.info("total:{}".format(balance + total_reward)) 1085 assert balance + total_reward - balance1 < node.web3.toWei(1, 'ether'), "ErrMsg:benifit_balance: {}".format( 1086 balance1) 1087 1088 # # create pledge node 1089 # address, benifit_address = create_pledge_node(client_new_node, 1.2) 1090 # # assert benifit reward 1091 # assert_benifit_reward(client_new_node, benifit_address, address) 1092 1093 1094 def calculate_block_rewards_and_pledge_rewards(client, incentive_pool_amount, annualcycle): 1095 new_block_rate = client.economic.genesis.economicModel.reward.newBlockRate 1096 block_proportion = str(new_block_rate / 100) 1097 log.info("Get incentive pool to allocate block reward ratio: {}".format(block_proportion)) 1098 verifier_list = get_pledge_list(client.node.ppos.getVerifierList) 1099 verifier_num = len(verifier_list) 1100 log.info("Number of verification nodes in the current settlement cycle: {}".format(verifier_num)) 1101 amount_per_settlement = int(Decimal(str(incentive_pool_amount)) / Decimal(str(annualcycle))) 1102 total_block_rewards = int(Decimal(str(amount_per_settlement)) * Decimal(str(block_proportion))) 1103 per_block_reward = int(Decimal(str(total_block_rewards)) / Decimal(str(client.economic.settlement_size))) 1104 log.info("Total block rewards: {} Each block reward: {}".format(total_block_rewards, per_block_reward)) 1105 staking_reward_total = amount_per_settlement - total_block_rewards 1106 staking_reward = int(Decimal(str(staking_reward_total)) / Decimal(str(verifier_num))) 1107 log.info("Total pledged rewards: {} Amount of pledged rewards in current settlement cycle: {}".format( 1108 staking_reward_total, staking_reward)) 1109 return per_block_reward, staking_reward 1110 1111 1112 def test_AL_NBI_019(client_consensus): 1113 """ 1114 验证第一个结算周期区块奖励和质押奖励 1115 :param client_consensus: 1116 :return: 1117 """ 1118 client = client_consensus 1119 economic = client.economic 1120 node = client.node 1121 log.info("Start resetting the chain") 1122 economic.env.deploy_all() 1123 time.sleep(5) 1124 incentive_pool_balance = 262215742000000000000000000 1125 log.info("Get the initial value of the incentive pool:{}".format(incentive_pool_balance)) 1126 annualcycle = math.ceil((economic.additional_cycle_time * 60) / economic.settlement_size) 1127 log.info("Number of current additional settlement cycles:{}".format(annualcycle)) 1128 annual_size = annualcycle * economic.settlement_size 1129 log.info("Block height of current issuance cycle: {}".format(annual_size)) 1130 per_block_reward, staking_reward = calculate_block_rewards_and_pledge_rewards(client, incentive_pool_balance, annualcycle) 1131 chain_block_reward, chain_staking_reward = economic.get_current_year_reward(node) 1132 log.info("Block rewards on the chain: {}".format(chain_block_reward)) 1133 log.info("Pledge rewards on the chain:{}".format(chain_staking_reward)) 1134 assert per_block_reward == chain_block_reward, "ErrMsg:Block reward for the first settlement cycle {}".format(per_block_reward) 1135 assert staking_reward == chain_staking_reward, "ErrMsg:Pledge rewards for the first settlement cycle {}".format(staking_reward) 1136 1137 1138 def test_AL_NBI_020(client_consensus): 1139 """ 1140 调整出块间隔,查看第二个结算周期出块奖励和质押奖励 1141 :param client_consensus: 1142 :return: 1143 """ 1144 client = client_consensus 1145 economic = client.economic 1146 node = client.node 1147 economic.env.deploy_all() 1148 economic.wait_consensus_blocknum(node) 1149 log.info("Start adjusting the block interval") 1150 for i in range(3): 1151 economic.env.stop_all() 1152 time.sleep(2) 1153 economic.env.start_nodes(economic.env.get_all_nodes(), False) 1154 time.sleep(5) 1155 current_settlement_block_height = economic.get_settlement_switchpoint(node) 1156 log.info("Block height of current settlement cycle: {}".format(current_settlement_block_height)) 1157 wait_block_number(node, current_settlement_block_height) 1158 annualcycle = math.ceil((economic.additional_cycle_time * 60) / economic.settlement_size) 1159 log.info("Number of current additional settlement cycles:{}".format(annualcycle)) 1160 incentive_pool_balance = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, 0) 1161 remaining_incentive_pool_amount = incentive_pool_balance - int(Decimal(str(incentive_pool_balance)) / Decimal(str(annualcycle))) 1162 log.info("Settlement block high incentive pool balance: {}".format(remaining_incentive_pool_amount)) 1163 block_info = node.eth.getBlock(1) 1164 first_timestamp = block_info['timestamp'] 1165 log.info("First block timestamp: {}".format(first_timestamp)) 1166 settlement_block_info = node.eth.getBlock(current_settlement_block_height) 1167 settlement_timestamp = settlement_block_info['timestamp'] 1168 log.info("High block timestamp at the end of the current settlement cycle: {}".format(settlement_timestamp)) 1169 issuing_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000) 1170 log.info("End time stamp of current issue cycle: {}".format(issuing_cycle_timestamp)) 1171 remaining_additional_time = issuing_cycle_timestamp - settlement_timestamp 1172 log.info("Remaining time of current issuance cycle: {}".format(remaining_additional_time)) 1173 average_interval = (settlement_timestamp - first_timestamp) // (economic.settlement_size - 1) 1174 log.info("Block interval in the last settlement cycle: {}".format(average_interval)) 1175 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 1176 log.info("Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) 1177 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 1178 log.info("remaining settlement cycles in the current issuance cycle: {}".format(remaining_settlement_cycle)) 1179 per_block_reward, staking_reward = calculate_block_rewards_and_pledge_rewards(client, remaining_incentive_pool_amount, remaining_settlement_cycle) 1180 chain_block_reward, chain_staking_reward = economic.get_current_year_reward(node) 1181 log.info("Block rewards on the chain: {}".format(chain_block_reward)) 1182 log.info("Pledge rewards on the chain:{}".format(chain_staking_reward)) 1183 result = client.ppos.getAvgPackTime() 1184 chain_time_interval = result['Ret'] 1185 log.info("Block interval on the chain:{}".format(chain_time_interval)) 1186 assert per_block_reward == chain_block_reward, "ErrMsg:Block rewards for the current settlement cycle {}".format( 1187 per_block_reward) 1188 assert staking_reward == chain_staking_reward, "ErrMsg:Pledge rewards for the current settlement cycle {}".format( 1189 staking_reward) 1190 assert average_interval == chain_time_interval, "ErrMsg:Block interval in the last settlement cycle {}".format(average_interval) 1191 1192 1193 def AL_FI_006(client_consensus): 1194 """ 1195 增发周期动态调整 1196 :param client_consensus: 1197 :return: 1198 """ 1199 client = client_consensus 1200 economic = client.economic 1201 node = client.node 1202 economic.env.deploy_all() 1203 log.info("Chain reset completed") 1204 economic.wait_consensus_blocknum(node) 1205 log.info("Start adjusting the block interval") 1206 for i in range(3): 1207 economic.env.stop_all() 1208 time.sleep(2) 1209 economic.env.start_nodes(economic.env.get_all_nodes(), False) 1210 time.sleep(5) 1211 remaining_settlement_cycle = (economic.additional_cycle_time * 60) // economic.settlement_size 1212 annual_size = remaining_settlement_cycle * economic.settlement_size 1213 log.info("Additional issue settlement period:{} Block height of current issuance cycle: {}".format(remaining_settlement_cycle, annual_size)) 1214 economic.wait_settlement_blocknum(node) 1215 while remaining_settlement_cycle != 1: 1216 block_info = node.eth.getBlock(1) 1217 first_timestamp = block_info['timestamp'] 1218 log.info("First block timestamp: {}".format(first_timestamp)) 1219 tmp_current_block = node.eth.blockNumber 1220 if tmp_current_block % economic.settlement_size == 0: 1221 time.sleep(1) 1222 last_settlement_block = (math.ceil(tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size 1223 log.info("The last block height of the previous settlement period: {}".format(last_settlement_block)) 1224 settlement_block_info = node.eth.getBlock(last_settlement_block) 1225 settlement_timestamp = settlement_block_info['timestamp'] 1226 log.info("High block timestamp at the end of the current settlement cycle: {}".format(settlement_timestamp)) 1227 issuing_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60) * 1000 1228 log.info("End time stamp of current issue cycle: {}".format(issuing_cycle_timestamp)) 1229 remaining_additional_time = issuing_cycle_timestamp - settlement_timestamp 1230 log.info("Remaining time of current issuance cycle: {}".format(remaining_additional_time)) 1231 average_interval = (settlement_timestamp - first_timestamp) // (last_settlement_block - 1) 1232 log.info("Block interval in the last settlement cycle: {}".format(average_interval)) 1233 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 1234 log.info("Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) 1235 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 1236 log.info("remaining settlement cycles in the current issuance cycle: {}".format(remaining_settlement_cycle)) 1237 consensus_verification_list = node.ppos.getVerifierList() 1238 log.info("List of consensus validators in the current settlement cycle: {}".format(consensus_verification_list)) 1239 economic.wait_settlement_blocknum(node) 1240 plan_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, annual_size) 1241 annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 1242 # current_increase_last_block = economic.get_settlement_switchpoint(node) 1243 # log.info("The current issue cycle is high: {}".format(current_increase_last_block)) 1244 actual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, annual_last_block) 1245 log.info("Incentive pool actual amount: {}".format(actual_incentive_pool_amount)) 1246 assert actual_incentive_pool_amount > plan_incentive_pool_amount, "ErrMsg:Incentive pool balance {}".format(actual_incentive_pool_amount) 1247 1248 1249 def AL_FI_007(client_consensus): 1250 """ 1251 验证增发第一年出块奖励和质押奖励 1252 :param client_consensus: 1253 :return: 1254 """ 1255 client = client_consensus 1256 economic = client.economic 1257 node = client.node 1258 economic.env.deploy_all() 1259 log.info("Chain reset completed") 1260 economic.wait_consensus_blocknum(node) 1261 log.info("Start adjusting the block interval") 1262 for i in range(3): 1263 economic.env.stop_all() 1264 time.sleep(2) 1265 economic.env.start_nodes(economic.env.get_all_nodes(), False) 1266 time.sleep(5) 1267 remaining_settlement_cycle = (economic.additional_cycle_time * 60) // economic.settlement_size 1268 annual_size = remaining_settlement_cycle * economic.settlement_size 1269 log.info("Additional issue settlement period:{} Block height of current issuance cycle: {}".format( 1270 remaining_settlement_cycle, annual_size)) 1271 economic.wait_settlement_blocknum(node) 1272 block_info = node.eth.getBlock(1) 1273 first_timestamp = block_info['timestamp'] 1274 log.info("First block timestamp: {}".format(first_timestamp)) 1275 issuing_cycle_timestamp = None 1276 while remaining_settlement_cycle != 1: 1277 tmp_current_block = node.eth.blockNumber 1278 if tmp_current_block % economic.settlement_size == 0: 1279 time.sleep(1) 1280 last_settlement_block = (math.ceil(tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size 1281 log.info("The last block height of the previous settlement period: {}".format(last_settlement_block)) 1282 settlement_block_info = node.eth.getBlock(last_settlement_block) 1283 settlement_timestamp = settlement_block_info['timestamp'] 1284 log.info("High block timestamp at the end of the current settlement cycle: {}".format(settlement_timestamp)) 1285 issuing_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000) 1286 log.info("End time stamp of current issue cycle: {}".format(issuing_cycle_timestamp)) 1287 remaining_additional_time = issuing_cycle_timestamp - settlement_timestamp 1288 log.info("Remaining time of current issuance cycle: {}".format(remaining_additional_time)) 1289 average_interval = (settlement_timestamp - first_timestamp) // (last_settlement_block - 1) 1290 log.info("Block interval in the last settlement cycle: {}".format(average_interval)) 1291 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 1292 log.info("Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) 1293 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 1294 log.info("remaining settlement cycles in the current issuance cycle: {}".format(remaining_settlement_cycle)) 1295 consensus_verification_list = node.ppos.getVerifierList() 1296 log.info("List of consensus validators in the current settlement cycle: {}".format(consensus_verification_list)) 1297 economic.wait_settlement_blocknum(node) 1298 annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 1299 log.info("Last block height of last year:{}".format(annual_last_block)) 1300 settlement_block_info = node.eth.getBlock(annual_last_block) 1301 settlement_timestamp = settlement_block_info['timestamp'] 1302 log.info("Second High block timestamp at the end of the current settlement cycle:{}".format(settlement_timestamp)) 1303 second_issuing_cycle_timestamp = issuing_cycle_timestamp + (economic.additional_cycle_time * 60000) 1304 log.info("Second end time stamp of current issue cycle: {}".format(second_issuing_cycle_timestamp)) 1305 remaining_additional_time = second_issuing_cycle_timestamp - settlement_timestamp 1306 log.info("Second Remaining time of current issuance cycle: {}".format(remaining_additional_time)) 1307 average_interval = (settlement_timestamp - first_timestamp) // (annual_last_block - 1) 1308 log.info("Second Block interval in the last settlement cycle: {}".format(average_interval)) 1309 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 1310 log.info("Second Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) 1311 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 1312 log.info("The additional settlement cycle in the second year: {}".format(number_of_remaining_blocks)) 1313 actual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, annual_last_block) 1314 log.info("Incentive pool actual amount: {}".format(actual_incentive_pool_amount)) 1315 per_block_reward, staking_reward = calculate_block_rewards_and_pledge_rewards(client, actual_incentive_pool_amount, remaining_settlement_cycle) 1316 chain_block_reward, chain_staking_reward = economic.get_current_year_reward(node) 1317 log.info("Block rewards on the chain: {}".format(chain_block_reward)) 1318 log.info("Pledge rewards on the chain:{}".format(chain_staking_reward)) 1319 result = client.ppos.getAvgPackTime() 1320 chain_time_interval = result['Ret'] 1321 log.info("Block interval on the chain:{}".format(chain_time_interval)) 1322 assert per_block_reward == chain_block_reward, "ErrMsg:Block rewards for the current settlement cycle {}".format( 1323 per_block_reward) 1324 assert staking_reward == chain_staking_reward, "ErrMsg:Pledge rewards for the current settlement cycle {}".format( 1325 staking_reward) 1326 assert average_interval == chain_time_interval, "ErrMsg:Block interval in the last settlement cycle {}".format(average_interval) 1327 economic.wait_settlement_blocknum(node) 1328 1329 amount_per_settlement = int(Decimal(str(actual_incentive_pool_amount)) / Decimal(str(remaining_settlement_cycle))) 1330 remaining_incentive_pool_balance = actual_incentive_pool_amount - amount_per_settlement 1331 log.info("Amount of remaining incentive pool: {}".format(remaining_incentive_pool_balance)) 1332 first_settlement_cycle = annual_last_block / economic.settlement_size 1333 log.info("Number of first additional issue settlement cycles: {}".format(first_settlement_cycle)) 1334 current_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size 1335 log.info("Current settlement block height: {}".format(current_last_block)) 1336 current_settlement_cycle = current_last_block / economic.settlement_size 1337 log.info("Current latest settlement cycles: {}".format(current_settlement_cycle)) 1338 number = current_settlement_cycle - first_settlement_cycle 1339 log.info("Phase difference period: {}".format(number)) 1340 second_start_info = node.eth.getBlock(int((first_settlement_cycle - (first_settlement_cycle - number)) * economic.settlement_size)) 1341 second_start_timestamp = second_start_info['timestamp'] 1342 log.info("second start timestamp : {}".format(second_start_timestamp)) 1343 second_end_info = node.eth.getBlock(current_last_block) 1344 second_end_timestamp = second_end_info['timestamp'] 1345 log.info("second end timestamp : {}".format(second_end_timestamp)) 1346 average_interval = (second_end_timestamp - second_start_timestamp) // (annual_last_block - 1) 1347 log.info("Second Block interval in the last settlement cycle: {}".format(average_interval)) 1348 1349 remaining_additional_time = second_issuing_cycle_timestamp - second_end_timestamp 1350 log.info("Second Remaining time of current issuance cycle: {}".format(remaining_additional_time)) 1351 number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) 1352 log.info("Second Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) 1353 remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) 1354 log.info("The additional settlement cycle in the second year: {}".format(number_of_remaining_blocks)) 1355 per_block_reward, staking_reward = calculate_block_rewards_and_pledge_rewards(client, remaining_incentive_pool_balance, 1356 remaining_settlement_cycle) 1357 chain_block_reward, chain_staking_reward = economic.get_current_year_reward(node) 1358 log.info("Block rewards on the chain: {}".format(chain_block_reward)) 1359 log.info("Pledge rewards on the chain:{}".format(chain_staking_reward)) 1360 result = client.ppos.getAvgPackTime() 1361 chain_time_interval = result['Ret'] 1362 log.info("Block interval on the chain:{}".format(chain_time_interval)) 1363 assert per_block_reward == chain_block_reward, "ErrMsg:Block rewards for the current settlement cycle {}".format( 1364 per_block_reward) 1365 assert staking_reward == chain_staking_reward, "ErrMsg:Pledge rewards for the current settlement cycle {}".format( 1366 staking_reward) 1367 assert average_interval == chain_time_interval, "ErrMsg:Block interval in the last settlement cycle {}".format( 1368 average_interval)