def test_UP_FV_015(client_new_node): """ 锁仓账户申请之后到达释放期,账户锁仓不足再新增新的锁仓计划 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create restricting plan and staking address1 = restricting_plan_validation_staking(client, economic, node) # create account2 address2, _ = economic.account.generate_account( node.web3, von_amount(economic.create_staking_limit, 2)) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info[ 'debt'] == economic.create_staking_limit, 'ErrMsg: restricting debt amount {}'.format( info['debt']) # create Restricting Plan delegate_amount = von_amount(economic.create_staking_limit, 1) plan = [{'Epoch': 1, 'Amount': delegate_amount}] result = client.restricting.createRestrictingPlan(address1, plan, address2) assert_code(result, 0) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info['debt'] == 0, 'ErrMsg: restricting debt amount {}'.format( info['debt'])
def test_UP_FV_017(client_new_node): """ 锁仓账户质押,自由资金再增持 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account amount1 = von_amount(economic.create_staking_limit, 2) amount2 = von_amount(economic.create_staking_limit, 1) address1, address2 = create_account_amount(client, amount1, amount2) # create Restricting Plan delegate_amount = von_amount(economic.create_staking_limit, 1) plan = [{'Epoch': 3, 'Amount': delegate_amount}] result = client.restricting.createRestrictingPlan(address1, plan, address1) assert_code(result, 0) # create staking result = client.staking.create_staking(1, address1, address1) assert_code(result, 0) # Apply for additional pledge result = client.staking.increase_staking(0, address1) assert_code(result, 0) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # Apply for additional pledge result = client.staking.increase_staking(0, address1) assert_code(result, 0)
def test_UP_FV_003(client_new_node): """ 多个锁仓期,依次部分释放期返回解锁金额 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account address1, _ = economic.account.generate_account( node.web3, von_amount(economic.create_staking_limit, 2)) # create Restricting Plan amount = von_amount(economic.delegate_limit, 10) plan = [{'Epoch': 1, 'Amount': amount}, {'Epoch': 2, 'Amount': amount}] result = client.restricting.createRestrictingPlan(address1, plan, address1) assert_code(result, 0) # view Restricting Plan again restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan information: {}".format(restricting_info)) assert len(restricting_info['Ret'] ['plans']) == 2, "ErrMsg:Planned releases: {}".format( len(restricting_info['Ret']['plans'])) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # view Restricting Plan restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan information: {}".format(restricting_info)) assert len(restricting_info['Ret'] ['plans']) == 1, "ErrMsg:Planned releases: {}".format( len(restricting_info['Ret']['plans']))
def test_UP_FV_014(client_new_node, reset_environment): """ 锁仓验证人违规被剔除验证人列表,申请赎回委托金 :param client_new_node: :param reset_environment: :return: """ client = client_new_node economic = client.economic node = client.node # create account amount1 = von_amount(economic.create_staking_limit, 2) amount2 = von_amount(economic.create_staking_limit, 1) address1, report_address = create_account_amount(client, amount1, amount2) # create Restricting Plan delegate_amount = von_amount(economic.delegate_limit, 10) plan = [{'Epoch': 3, 'Amount': delegate_amount}] result = client.restricting.createRestrictingPlan(report_address, plan, report_address) assert_code(result, 0) # create staking result = client.staking.create_staking(0, address1, address1) assert_code(result, 0) # Application for Commission result = client.delegate.delegate(1, report_address) assert_code(result, 0) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # for i in range(4): result = check_node_in_list(node.node_id, client.ppos.getValidatorList) log.info("Current node in consensus list status:{}".format(result)) if result: # view current block current_block = node.eth.blockNumber log.info("Current block: {}".format(current_block)) # Report prepareblock signature report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, current_block) log.info("Report information: {}".format(report_information)) result = client.duplicatesign.reportDuplicateSign( 1, report_information, report_address) assert_code(result, 0) time.sleep(3) # Access to pledge information candidate_info = client.ppos.getCandidateInfo(node.node_id) info = candidate_info['Ret'] staking_blocknum = info['StakingBlockNum'] # withdrew delegate result = client.delegate.withdrew_delegate(staking_blocknum, report_address) assert_code(result, 0) break else: # wait consensus block client.economic.wait_consensus_blocknum(node)
def test_AL_IE_002(client_new_node_obj_list): """ 转账到激励池 :param client_new_node_obj_list: :return: """ client1 = client_new_node_obj_list[0] client2 = client_new_node_obj_list[1] economic = client1.economic node = client1.node log.info("Node ID:{}".format(node.node_id)) log.info("Current connection node: {}".format(node.node_mark)) address, _ = client1.economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 4)) address1, _ = client1.economic.account.generate_account(node.web3, 0) address2, _ = client1.economic.account.generate_account(node.web3, 0) log.info("staking address: {}".format(address)) # Free amount application pledge node result = client1.staking.create_staking(0, address1, address) assert_code(result, 0) # Wait for the settlement round to end economic.wait_settlement_blocknum(node) # 获取当前结算周期验证人 verifier_list = node.ppos.getVerifierList() log.info("verifier_list: {}".format(verifier_list)) # view block_reward block_reward, staking_reward = economic.get_current_year_reward(node) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) # view account amount benifit_balance = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance)) # view benifit reward blocknumber = view_benifit_reward(client1, address) # view account amount again benifit_balance1 = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance1)) reward = int(blocknumber * Decimal(str(block_reward))) assert benifit_balance1 == staking_reward + reward, "ErrMsg:benifit_balance: {}".format(benifit_balance1) # Transfer to the incentive pool result = client1.economic.account.sendTransaction(node.web3, '', address, EconomicConfig.INCENTIVEPOOL_ADDRESS, node.eth.gasPrice, 21000, node.web3.toWei(1000, 'ether')) assert result is not None, "ErrMsg:Transfer result {}".format(result) time.sleep(5) # Free amount application pledge node result = client2.staking.create_staking(0, address2, address, amount=von_amount(economic.create_staking_limit, 2)) assert_code(result, 0) # Wait for the settlement round to end economic.wait_settlement_blocknum(client2.node) # view account amount benifit_balance2 = client2.node.eth.getBalance(address2) log.info("benifit_balance: {}".format(benifit_balance2)) # view benifit reward blocknumber = view_benifit_reward(client2, address) # view account amount again benifit_balance3 = client2.node.eth.getBalance(address2) log.info("benifit_balance: {}".format(benifit_balance3)) reward = int(blocknumber * Decimal(str(block_reward))) assert benifit_balance3 == staking_reward + reward, "ErrMsg:benifit_balance: {}".format(benifit_balance3)
def test_UP_FV_013(client_new_node, reset_environment): """ 锁仓验证人违规被剔除验证人列表,申请退回质押金 :param client_new_node: :return: """ client1 = client_new_node economic = client1.economic node = client1.node # create account amount1 = von_amount(economic.create_staking_limit, 3) amount2 = von_amount(economic.create_staking_limit, 1) address1, report_address = create_account_amount(client1, amount1, amount2) # create Restricting Plan delegate_amount = von_amount(economic.create_staking_limit, 2) plan = [{'Epoch': 3, 'Amount': delegate_amount}] result = client1.restricting.createRestrictingPlan(address1, plan, address1) assert_code(result, 0) # view restricting plan again restricting_info = client1.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) # create staking result = client1.staking.create_staking(1, address1, address1) assert_code(result, 0) # view restricting plan again restricting_info = client1.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # for i in range(4): result = check_node_in_list(node.node_id, client1.ppos.getValidatorList) log.info("Current node in consensus list status:{}".format(result)) if result: # view current block current_block = node.eth.blockNumber log.info("Current block: {}".format(current_block)) # Report prepareblock signature report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, current_block) log.info("Report information: {}".format(report_information)) result = client1.duplicatesign.reportDuplicateSign( 1, report_information, report_address) assert_code(result, 0) time.sleep(3) # withdrew staking result = client1.staking.withdrew_staking(address1) assert_code(result, 301103) break else: # wait consensus block client1.economic.wait_consensus_blocknum(node)
def test_AL_NBI_016(client_new_node_obj, reset_environment): """ 被双签处罚槛剔除验证人列表 :param client_new_node_obj: :return: """ client = client_new_node_obj economic = client.economic node = client.node client.economic.env.deploy_all() # create account address1, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) address2, _ = economic.account.generate_account(node.web3, 0) report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether')) # create staking staking_amount = von_amount(economic.create_staking_limit, 1.6) result = client_new_node_obj.staking.create_staking(0, address2, address1, amount=staking_amount) assert_code(result, 0) # wait settlement block economic.wait_settlement_blocknum(node) # Check account balance balance = node.eth.getBalance(address2) log.info("Account Balance:{}".format(balance)) # view block_reward block_reward, staking_reward = economic.get_current_year_reward(node) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) for i in range(4): result = check_node_in_list(client_new_node_obj.node.node_id, client_new_node_obj.ppos.getValidatorList) log.info("Current node in consensus list status:{}".format(result)) if result: # view Current block current_block = client_new_node_obj.node.eth.blockNumber log.info("Current block: {}".format(current_block)) # Report prepareblock signature report_information = mock_duplicate_sign(1, client_new_node_obj.node.nodekey, client_new_node_obj.node.blsprikey, current_block) log.info("Report information: {}".format(report_information)) result = client_new_node_obj.duplicatesign.reportDuplicateSign(1, report_information, report_address) assert_code(result, 0) # wait settlement block economic.wait_settlement_blocknum(node) # Check account balance again balance1 = node.eth.getBalance(address2) log.info("Account Balance:{}".format(balance1)) # count the number of blocks blocknumber = client_new_node_obj.economic.get_block_count_number(node, 10) log.info("blocknumber: {}".format(blocknumber)) total_block_reward = int(Decimal(str(block_reward)) * Decimal(str(blocknumber))) log.info("total_block_reward: {}".format(total_block_reward)) assert balance1 == balance + total_block_reward, "ErrMsg:benifit_balance1:{}".format(balance1) break else: # wait consensus block economic.wait_consensus_blocknum(node)
def test_UP_FV_006(client_new_node): """ 多个锁仓期,质押一部分锁仓金额再依次释放 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account1 address1, _ = client.economic.account.generate_account( client.node.web3, von_amount(economic.create_staking_limit, 2)) # create Restricting Plan amount1 = economic.create_staking_limit amount2 = von_amount(economic.add_staking_limit, 10) plan = [{'Epoch': 1, 'Amount': amount1}, {'Epoch': 2, 'Amount': amount2}] result = client.restricting.createRestrictingPlan(address1, plan, address1) assert_code(result, 0) # create staking staking_amount = economic.create_staking_limit result = client.staking.create_staking(1, address1, address1, amount=staking_amount) assert_code(result, 0) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info[ 'debt'] == amount1 - amount2, 'ErrMsg: restricting debt amount {}'.format( info['debt']) assert info['plans'][0][ 'amount'] == amount2, 'ErrMsg: restricting plans amount {}'.format( info['plans'][0]['amount']) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # view restricting plan again restricting_info = client.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info[ 'debt'] == amount1, 'ErrMsg: restricting debt amount {}'.format( info['debt']) assert info['plans'] is None, 'ErrMsg: restricting plans'.format( info['plans'])
def create_pledge_node(client_new_node_obj, base, multiple=2): """ create pledge node return benifit balance :param client_new_node_obj: :param base: :param multiple: :return: """ log.info("Transfer accounts: {}".format(client_new_node_obj.economic.create_staking_limit * multiple)) account_balance = client_new_node_obj.node.eth.getBalance( client_new_node_obj.economic.account.account_with_money['address']) log.info("address: {} accounts: {}".format(client_new_node_obj.economic.account.account_with_money['address'], account_balance)) # create account address, _ = client_new_node_obj.economic.account.generate_account(client_new_node_obj.node.web3, client_new_node_obj.economic.create_staking_limit * multiple) log.info("address: {} ,amount: {}".format(address, client_new_node_obj.node.eth.getBalance(address))) benifit_address, _ = client_new_node_obj.economic.account.generate_account(client_new_node_obj.node.web3, 0) log.info("address: {} ,amount: {}".format(benifit_address, client_new_node_obj.node.eth.getBalance(benifit_address))) # create staking staking_amount = von_amount(client_new_node_obj.economic.create_staking_limit, base) result = client_new_node_obj.staking.create_staking(0, benifit_address, address, amount=staking_amount) assert_code(result, 0) log.info("Pledge node information: {}".format(client_new_node_obj.ppos.getCandidateInfo(client_new_node_obj.node.node_id))) return address, benifit_address
def test_UP_FV_018(client_new_node): """ 账户自由金额和锁仓金额申请委托同一个验证人,再申请赎回 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account amount1 = von_amount(economic.create_staking_limit, 2) amount2 = von_amount(economic.create_staking_limit, 1) address1, address2 = create_account_amount(client, amount1, amount2) # create Restricting Plan delegate_amount = von_amount(economic.delegate_limit, 10) plan = [{'Epoch': 1, 'Amount': delegate_amount}] result = client.restricting.createRestrictingPlan(address2, plan, address2) assert_code(result, 0) # create staking result = client.staking.create_staking(0, address1, address1) assert_code(result, 0) # Lock in amount Application for delegate result = client.delegate.delegate(1, address2, amount=delegate_amount) assert_code(result, 0) # Free amount Application for delegate result = client.delegate.delegate(0, address2, amount=delegate_amount) assert_code(result, 0) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # Access to pledge information candidate_info = client.ppos.getCandidateInfo(node.node_id) info = candidate_info['Ret'] staking_blocknum = info['StakingBlockNum'] # withdrew delegate withdrew_amount = von_amount(economic.delegate_limit, 15) result = client.delegate.withdrew_delegate(staking_blocknum, address2, amount=withdrew_amount) assert_code(result, 0) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address2) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info['debt'] == von_amount( economic.delegate_limit, 5), 'ErrMsg: restricting debt amount {}'.format(info['debt'])
def restricting_plan_validation_release(client, economic, node): # create account address1, _ = economic.account.generate_account( node.web3, von_amount(economic.create_staking_limit, 2)) # create Restricting Plan amount = economic.create_staking_limit plan = [{'Epoch': 1, 'Amount': amount}] result = client.restricting.createRestrictingPlan(address1, plan, address1) assert_code(result, 0) return address1
def test_PIP_PVF_004(client_consensus, clients_noconsensus, reset_environment): """ 治理修改低0出块率扣除验证人自有质押金块数成功扣除区块奖励块数49999-自由金额质押 :param client_consensus: :param clients_noconsensus: :param reset_environment: :return: """ consensus_client = client_consensus log.info("Current connection consensus node".format( consensus_client.node.node_mark)) first_index = 0 first_client = clients_noconsensus[first_index] log.info("Current connection non-consensus node:{}".format( first_client.node.node_mark)) economic = consensus_client.economic node = consensus_client.node change_parameter_value = '49999' # get pledge amount1 and block reward consensus_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks( consensus_client) # create Parametric proposal param_governance_verify(consensus_client, 'slashing', 'slashBlocksReward', change_parameter_value) log.info("Current block height: {}".format(node.eth.blockNumber)) # Get governable parameters again second_slash_blocks = get_governable_parameter_value( consensus_client, 'slashBlocksReward') assert second_slash_blocks == change_parameter_value, "ErrMsg:Change parameters {}".format( second_slash_blocks) # create account address, _ = economic.account.generate_account( node.web3, von_amount(economic.create_staking_limit, 2)) # create staking result = first_client.staking.create_staking(0, address, address) assert_code(result, 0) # wait settlement block economic.wait_settlement_blocknum(node) candidate_info = consensus_client.ppos.getCandidateInfo( first_client.node.node_id) first_pledge_amount = candidate_info['Ret']['Released'] log.info("Current pledge node amount:{}".format(first_pledge_amount)) for i in range(4): result = check_node_in_list(node.node_id, consensus_client.ppos.getValidatorList) log.info("Current node in consensus list status:{}".format(result)) if result: # Verify changed parameters verify_changed_parameters(clients_noconsensus, first_pledge_amount, block_reward, second_slash_blocks) break else: # wait consensus block economic.wait_consensus_blocknum(node)
def test_AL_NBI_018(new_genesis_env, client_new_node_obj): """ 调整质押和出块奖励比例 :param client_new_node_obj: :return: """ # Change configuration parameters genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.reward.newBlockRate = 60 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" genesis.to_file(new_file) new_genesis_env.deploy_all(new_file) client = client_new_node_obj economic = client.economic node = client.node # create account address1, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) address2, _ = economic.account.generate_account(node.web3, 0) # create pledge result = client.staking.create_staking(0, address1, address1) assert_code(result, 0) # Waiting for the end of the settlement economic.wait_settlement_blocknum(node) # Check account balance balance = node.eth.getBalance(address1) log.info("Account Balance: {}".format(balance)) # Get the number of certifiers in the billing cycle list verifier_list = get_pledge_list(node.ppos.getVerifierList) verifier_num = len(verifier_list) # Get block_reward And pledge rewards amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, 0) block_proportion = str(60 / 100) staking_proportion = str(1 - 60 / 100) block_reward = int(Decimal(str(amount)) * Decimal(str(block_proportion)) / Decimal(str(1600))) staking_reward = int(Decimal(str(amount)) * Decimal(str(staking_proportion)) / Decimal(str(10)) / Decimal( str(verifier_num))) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) # withdrew of pledge result = client.staking.withdrew_staking(address1) assert_code(result, 0) # wait settlement block client.economic.wait_settlement_blocknum(client.node) # wait consensus block client.economic.wait_consensus_blocknum(client.node) # count the number of blocks blocknumber = client.economic.get_block_count_number(client.node, 10) log.info("blocknumber: {}".format(blocknumber)) # Check account balance again balance1 = node.eth.getBalance(address1) log.info("Account Balance: {}".format(balance1)) # Pledged income account to get the bonus amount total_reward = int(Decimal(str(block_reward)) * blocknumber) + staking_reward assert balance + total_reward - balance1 < node.web3.toWei(1, 'ether'), "ErrMsg:benifit_balance: {}".format(balance1)
def test_AL_BI_004(client_consensus_obj): """ 初始验证人退出后重新质押进来 :param client_consensus_obj: :return: """ client = client_consensus_obj economic = client.economic node = client.node # Reset environment economic.env.deploy_all() # Query Developer Fund Amount log.info("nodeid: {}".format(node.node_id)) developer_foundation_balance = node.eth.getBalance(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) log.info("incentive_pool_balance: {}".format(developer_foundation_balance)) staking_balance = client_consensus_obj.node.eth.getBalance(EconomicConfig.STAKING_ADDRESS) log.info("staking_balance: {}".format(staking_balance)) # Built in node return pledge result = client.staking.withdrew_staking(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS) assert_code(result, 0) # Waiting for the end of the 2 settlement economic.wait_settlement_blocknum(node, 2) # create account address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) address1, _ = economic.account.generate_account(node.web3, 0) # Check account balance balance = node.eth.getBalance(address1) log.info("Account Balance: {}".format(balance)) # Node pledge again result = client.staking.create_staking(0, address1, address) assert_code(result, 0) # Waiting for the end of the settlement economic.wait_settlement_blocknum(node) # view block_reward block_reward, staking_reward = economic.get_current_year_reward(node) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) # withdrew of pledge result = client.staking.withdrew_staking(address) assert_code(result, 0) # wait settlement block client.economic.wait_settlement_blocknum(client.node) # wait consensus block client.economic.wait_consensus_blocknum(client.node) # count the number of blocks blocknumber = client.economic.get_block_count_number(client.node, 10) log.info("blocknumber: {}".format(blocknumber)) # Check account balance again balance1 = node.eth.getBalance(address1) log.info("Account Balance: {}".format(balance1)) # Pledged income account to get the bonus amount total_reward = int(Decimal(str(block_reward)) * blocknumber) + staking_reward assert balance1 == balance + total_reward, "ErrMsg:benifit_balance: {}".format(balance1)
def test_UP_FV_007(client_new_node): """ 锁仓账户申请委托到释放期后释放锁定金额不足 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account amount1 = von_amount(economic.create_staking_limit, 2) amount2 = von_amount(economic.create_staking_limit, 1) address1, address2 = create_account_amount(client, amount1, amount2) # create Restricting Plan delegate_amount = von_amount(economic.delegate_limit, 10) plan = [{'Epoch': 1, 'Amount': delegate_amount}] result = client.restricting.createRestrictingPlan(address2, plan, address2) assert_code(result, 0) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address2) log.info("restricting plan informtion: {}".format(restricting_info)) # create staking result = client.staking.create_staking(0, address1, address1) assert_code(result, 0) # Application for Commission result = client.delegate.delegate(1, address2, amount=delegate_amount) assert_code(result, 0) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address2) log.info("restricting plan informtion: {}".format(restricting_info)) # Waiting for the end of the settlement period economic.wait_settlement_blocknum(node) # view restricting plan restricting_info = client.ppos.getRestrictingInfo(address2) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] assert info[ 'debt'] == delegate_amount, 'ErrMsg: restricting debt amount {}'.format( info['debt'])
def test_AL_BI_002(new_genesis_env, staking_cfg): """ 节点出块率为0被处罚,激励池金额增加 :param new_genesis_env: :param staking_cfg: :return: """ # Change configuration parameters genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.slashing.slashBlocksReward = 5 new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" genesis.to_file(new_file) new_genesis_env.deploy_all(new_file) client_noc_list_obj = get_client_noconsensus_list(new_genesis_env, staking_cfg) client1 = client_noc_list_obj[0] client2 = client_noc_list_obj[1] economic = client1.economic node = client1.node log.info("nodeid: {}".format(node.node_id)) # create account address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) # create staking result = client1.staking.create_staking(0, address, address) assert_code(result, 0) # Waiting for a settlement round client2.economic.wait_settlement_blocknum(client2.node) # view incentive account incentive_pool_balance = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) log.info("incentive_pool_balance: {}".format(incentive_pool_balance)) # view block_reward block_reward, staking_reward = economic.get_current_year_reward(node) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) # stop node node.stop() # Waiting for 2 consensus round client2.economic.wait_consensus_blocknum(client2.node, 2) # view verifier list verifier_list = client2.ppos.getVerifierList() log.info("verifier_list: {}".format(verifier_list)) slash_blocks = get_governable_parameter_value(client2, 'slashBlocksReward') # Get the penalty amount penalty_amount = int(Decimal(str(block_reward)) * Decimal(str(slash_blocks))) log.info("penalty_amount: {}".format(penalty_amount)) # view incentive account again incentive_pool_balance1 = client2.node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) log.info("incentive_pool_balance1: {}".format(incentive_pool_balance1)) assert incentive_pool_balance1 == incentive_pool_balance + penalty_amount, "ErrMsg: incentive_pool_balance: {}".format( incentive_pool_balance1)
def test_UP_FV_019(client_new_node): """ 账户自由金额和锁仓金额申请委托同一个验证人,再申请赎回 :param client_new_node: :return: """ client = client_new_node economic = client.economic node = client.node # create account amount = economic.create_staking_limit first_address, second_address = create_account_amount( client, amount, amount) delegate_amount = von_amount(economic.delegate_limit, 10) plan = [{'Epoch': 2, 'Amount': delegate_amount}] # create Restricting Plan1 result = client.restricting.createRestrictingPlan(first_address, plan, first_address) assert_code(result, 0) economic.wait_settlement_blocknum(node) log.info("Current block height:{}".format(node.eth.blockNumber)) # create Restricting Plan2 first_balance1 = node.eth.getBalance(first_address) log.info("first_balance1: {}".format(first_balance1)) result = client.restricting.createRestrictingPlan(second_address, plan, second_address) assert_code(result, 0) economic.wait_settlement_blocknum(node) log.info("Current block height:{}".format(node.eth.blockNumber)) second_balance1 = node.eth.getBalance(second_address) log.info("second_balance1: {}".format(second_balance1)) restricting_info = client.ppos.getRestrictingInfo(first_address) log.info("restricting plan1 informtion: {}".format(restricting_info)) first_balance2 = node.eth.getBalance(first_address) log.info("first_balance2: {}".format(first_balance2)) assert first_balance2 == first_balance1 + delegate_amount economic.wait_settlement_blocknum(node) log.info("Current block height:{}".format(node.eth.blockNumber)) restricting_info = client.ppos.getRestrictingInfo(second_address) log.info("restricting plan2 informtion: {}".format(restricting_info)) second_balance2 = node.eth.getBalance(second_address) log.info("second_balance2: {}".format(second_balance2)) assert second_balance2 == second_balance1 + delegate_amount
def test_AL_FI_004_005(new_genesis_env, staking_cfg): """ AL_FI_004:查看每年区块奖励变化 AL_FI_005:查看每年质押奖励变化 :param new_genesis_env: :param staking_cfg: :return: """ # Initialization genesis file Initial amount node_count = len(new_genesis_env.consensus_node_list) default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether') community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.innerAcc.cdfBalance = community_amount surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000) genesis.alloc = { "lax1zqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrzpqayr": { "balance": "200000000000000000000000000" }, "lax196278ns22j23awdfj9f2d4vz0pedld8au6xelj": { "balance": surplus_amount } } new_file = new_genesis_env.cfg.env_tmp + "/genesis_0.13.0.json" genesis.to_file(new_file) new_genesis_env.deploy_all(new_file) normal_node = new_genesis_env.get_a_normal_node() client = Client(new_genesis_env, normal_node, staking_cfg) economic = client.economic node = client.node log.info("Current connection node:{}".format(node.node_mark)) log.info("Current connection nodeid:{}".format(node.node_id)) address, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2)) log.info("address: {}".format(address)) address1, _ = economic.account.generate_account(node.web3, 0) log.info("address1: {}".format(address1)) end_cycle_timestamp = None for i in range(10): result = client.staking.create_staking(0, address1, address) assert_code(result, 0) # view account amount benifit_balance = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance)) # Wait for the settlement round to end economic.wait_settlement_blocknum(node) # 获取当前结算周期验证人 verifier_list = node.ppos.getVerifierList() log.info("verifier_list: {}".format(verifier_list)) # view block_reward block_reward, staking_reward = economic.get_current_year_reward(node) log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward)) # withdrew of pledge result = client.staking.withdrew_staking(address) assert_code(result, 0) # wait settlement block economic.wait_settlement_blocknum(node) # wait consensus block economic.wait_consensus_blocknum(node) # count the number of blocks blocknumber = economic.get_block_count_number(node, 10) log.info("blocknumber: {}".format(blocknumber)) # view account amount again benifit_balance1 = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance1)) reward = int(blocknumber * Decimal(str(block_reward))) assert benifit_balance1 == benifit_balance + staking_reward + reward, "ErrMsg:benifit_balance: {}".format( benifit_balance1) if i == 0: block_info = node.eth.getBlock(1) log.info("block_info:{}".format(block_info)) first_timestamp = block_info['timestamp'] log.info("First block timestamp: {}".format(first_timestamp)) end_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000) log.info("End time stamp of current issue cycle: {}".format(end_cycle_timestamp)) else: # Waiting for the end of the annual issuance cycle end_cycle_timestamp = end_cycle_timestamp + (economic.additional_cycle_time * 60000) log.info("End time stamp of current issue cycle: {}".format(end_cycle_timestamp)) annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size log.info("The last block height in the last issue cycle: {}".format(annual_last_block)) settlement_block_info = node.eth.getBlock(annual_last_block) settlement_timestamp = settlement_block_info['timestamp'] log.info("High block timestamp at the end of settlement cycle: {}".format(settlement_timestamp)) remaining_additional_time = end_cycle_timestamp - settlement_timestamp log.info("Remaining time of current issuance cycle: {}".format(remaining_additional_time)) result = client.ppos.getAvgPackTime() average_interval = result['Ret'] log.info("Block interval on the chain:{}".format(average_interval)) log.info("Block interval on the chain:{}".format(average_interval)) number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) log.info("Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) log.info("remaining settlement cycles issuance cycle: {}".format(remaining_settlement_cycle)) while remaining_settlement_cycle != 1: tmp_current_block = node.eth.blockNumber if tmp_current_block % economic.settlement_size == 0: time.sleep(economic.interval) tmp_current_block = node.eth.blockNumber last_settlement_block = (math.ceil( tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size log.info("The last block height of the previous settlement period: {}".format(last_settlement_block)) settlement_block_info = node.eth.getBlock(last_settlement_block) settlement_timestamp = settlement_block_info['timestamp'] log.info("High block timestamp at the end of settlement cycle: {}".format(settlement_timestamp)) remaining_additional_time = end_cycle_timestamp - settlement_timestamp log.info("Remaining time of current issuance cycle: {}".format(remaining_additional_time)) result = client.ppos.getAvgPackTime() average_interval = result['Ret'] log.info("Block interval on the chain:{}".format(average_interval)) number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval) log.info("Remaining block height of current issuance cycle: {}".format(number_of_remaining_blocks)) remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size) log.info("remaining settlement cycles issuance cycle: {}".format(remaining_settlement_cycle)) economic.wait_settlement_blocknum(node)
def AL_FI_004_005(new_genesis_env, staking_cfg): """ AL_FI_004:查看每年区块奖励变化 AL_FI_005:查看每年质押奖励变化 :param new_genesis_env: :param staking_cfg: :return: """ # Initialization genesis file Initial amount node_count = len(new_genesis_env.consensus_node_list) default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether') community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000 genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.innerAcc.cdfBalance = community_amount surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000) genesis.alloc = { "1000000000000000000000000000000000000003": { "balance": "200000000000000000000000000" }, "0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": { "balance": surplus_amount } } new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" genesis.to_file(new_file) new_genesis_env.deploy_all(new_file) normal_node = new_genesis_env.get_a_normal_node() client1 = Client(new_genesis_env, normal_node, staking_cfg) economic = client1.economic node = client1.node log.info("Current connection node:{}".format(node.node_mark)) log.info("Current connection nodeid:{}".format(node.node_id)) address, _ = client1.economic.account.generate_account( node.web3, von_amount(economic.create_staking_limit, 2)) log.info("address: {}".format(address)) address1, _ = client1.economic.account.generate_account(node.web3, 0) log.info("address1: {}".format(address1)) for i in range(10): current_block = node.eth.blockNumber log.info("Current query block height: {}".format(node.eth.blockNumber)) annualcycle = (economic.additional_cycle_time * 60) // economic.settlement_size annual_size = annualcycle * economic.settlement_size starting_block_height = math.floor( current_block / annual_size) * annual_size amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS, starting_block_height) log.info("Current annual incentive pool amount: {}".format(amount)) # if i == 0: # current_annual_incentive_pool_amount = 262215742000000000000000000 # else: # current_annual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS) # log.info("Current annual incentive pool amount: {}".format(current_annual_incentive_pool_amount)) # Free amount application pledge node result = client1.staking.create_staking(0, address1, address) assert_code(result, 0) # view account amount benifit_balance = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance)) # Wait for the settlement round to end economic.wait_settlement_blocknum(node) # 获取当前结算周期验证人 verifier_list = node.ppos.getVerifierList() log.info("verifier_list: {}".format(verifier_list)) # view block_reward block_reward, staking_reward = economic.get_current_year_reward( node, amount=amount) log.info("block_reward: {} staking_reward: {}".format( block_reward, staking_reward)) # withdrew of pledge result = client1.staking.withdrew_staking(address) assert_code(result, 0) # wait settlement block client1.economic.wait_settlement_blocknum(node) # wait consensus block client1.economic.wait_consensus_blocknum(node) # count the number of blocks blocknumber = client1.economic.get_block_count_number(client1.node, 10) log.info("blocknumber: {}".format(blocknumber)) # view account amount again benifit_balance1 = node.eth.getBalance(address1) log.info("benifit_balance: {}".format(benifit_balance1)) reward = int(blocknumber * Decimal(str(block_reward))) assert benifit_balance1 == benifit_balance + staking_reward + reward, "ErrMsg:benifit_balance: {}".format( benifit_balance1) # Waiting for the end of the annual increase economic.wait_annual_blocknum(node)