def proposal_pips(all_clients): ''' get verifier Client object list :param global_test_env: :return: ''' verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) pip = get_client_by_nodeid(verifier_list[0], all_clients).pip if pip.chain_version != pip.cfg.version0: pip.economic.env.deploy_all() if pip.is_exist_effective_proposal(): proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('proprosalinfo : {}'.format(proposalinfo)) if proposalinfo.get('EndVotingBlock') - pip.node.block_number > 2 * pip.economic.consensus_size \ and proposalinfo.get('NewVersion') == pip.cfg.version5: verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) clients_verifier = get_clients_by_nodeid(verifier_list, all_clients) return [client.pip for client in clients_verifier] else: pip.economic.env.deploy_all() result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 10, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('version proposal result :{}'.format(result)) verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) clients_verifier = get_clients_by_nodeid(verifier_list, all_clients) return [client.pip for client in clients_verifier]
def test_RV_014_015(staking_client): """ After becoming a verifier, there are pledge rewards and block rewards. """ client = staking_client staking_address = client.staking_address node = client.node economic = client.economic economic.wait_settlement(node) log.info("Enter the next cycle") block_reward, staking_reward = economic.get_current_year_reward(node) msg = client.staking.withdrew_staking(staking_address) log.info(msg) balance_1 = node.eth.getBalance(staking_address) log.info(balance_1) log.info("Enter the next cycle") economic.wait_settlement(node, 2) economic.wait_consensus(node) balance_2 = node.eth.getBalance(staking_address) log.info(balance_2) verifier_list = get_pledge_list(node.ppos.getVerifierList) log.info("Current certifier list:{}".format(verifier_list)) validator_list = get_pledge_list(node.ppos.getValidatorList) log.info("Current consensus certifier list:{}".format(validator_list)) block_number = get_block_count_number(node, economic.settlement_size * 3) sum_block_reward = calculate(block_reward, block_number) reward_sum = sum_block_reward + staking_reward log.info("Total amount of reward {}".format(reward_sum)) assert balance_1 + reward_sum + client.staking_amount == balance_2, "The bonus amount is abnormal"
def bv_proposal_pipobj_list(global_test_env, client_verifier_obj, client_list_obj): ''' get verifier Client object list :param global_test_env: :return: ''' pip_obj = client_verifier_obj.pip if pip_obj.chain_version != pip_obj.cfg.version0: global_test_env.deploy_all() if pip_obj.is_exist_effective_proposal(): proposalinfo = pip_obj.get_effect_proposal_info_of_vote() log.info('proprosalinfo : {}'.format(proposalinfo)) if proposalinfo.get('EndVotingBlock') - pip_obj.node.block_number > 2 * pip_obj.economic.consensus_size \ and proposalinfo.get('NewVersion') == pip_obj.cfg.version8: verifier_list = get_pledge_list( client_list_obj[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) client_obj_list = get_client_obj_list(verifier_list, client_list_obj) return [client_obj.pip for client_obj in client_obj_list] else: global_test_env.deploy_all() result = pip_obj.submitVersion(pip_obj.node.node_id, str(time.time_ns()), pip_obj.cfg.version8, 10, pip_obj.node.staking_address, transaction_cfg=pip_obj.cfg.transaction_cfg) log.info('version proposal result :{}'.format(result)) verifier_list = get_pledge_list(client_list_obj[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) client_obj_list = get_client_obj_list(verifier_list, client_list_obj) return [client_obj.pip for client_obj in client_obj_list]
def test_2(self, new_genesis_env, clients_consensus): new_genesis_env.deploy_all() pip = clients_consensus[0].pip submitvpandvote(clients_consensus[0:2]) # replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) proposalinfo = pip.get_effect_proposal_info_of_vote() wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 3) submitvpandvote(clients_consensus[1:4]) proposalinfo = pip.get_effect_proposal_info_of_vote() wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) pip.economic.wait_consensus_blocknum(pip.node) validator = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info(validator) assert pip.node.node_id not in validator programversion = clients_consensus[0].staking.get_version() log.info(programversion) programversion = clients_consensus[1].staking.get_version() log.info(programversion) programversion = clients_consensus[2].staking.get_version() log.info(programversion) programversion = clients_consensus[3].staking.get_version() log.info(programversion) verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info(verifier_list)
def test_RV_023(staking_client, global_test_env): """ Return amount after the highest penalty """ other_node = global_test_env.get_rand_node() client = staking_client staking_address = client.staking_address node = client.node economic = client.economic balance = node.eth.getBalance(staking_address) log.info(balance) candidate_info = client.ppos.getCandidateInfo(node.node_id) log.info(candidate_info) log.info("Stop the new verifier node") node.stop() log.info("Go to the next billing cycle") economic.wait_settlement_blocknum(other_node) msg = get_pledge_list(other_node.ppos.getCandidateList) log.info("Real-time certifier list {}".format(msg)) msg = get_pledge_list(other_node.ppos.getVerifierList) log.info("Current billing cycle certifier {}".format(msg)) msg = get_pledge_list(other_node.ppos.getValidatorList) log.info("Current consensus round certifier {}".format(msg)) log.info("Go to the next billing cycle") economic.wait_settlement_blocknum(other_node, 1) msg = get_pledge_list(other_node.ppos.getCandidateList) log.info("Real-time certifier list {}".format(msg)) verifier_list = get_pledge_list(other_node.ppos.getVerifierList) log.info("Current billing cycle certifier {}".format(verifier_list)) assert node.node_id not in verifier_list, "Expected to opt out of certifier list" balance_before = other_node.eth.getBalance(staking_address) log.info("Query the account balance after being punished: {}".format( balance_before)) log.info("Go to the next billing cycle") economic.wait_settlement_blocknum(other_node, 1) time.sleep(10) balance_after = other_node.eth.getBalance(staking_address) log.info( "The balance after the penalty is refunded to the account:{}".format( balance_after)) assert balance_before + candidate_info["Ret"][ "Released"] == balance_after, "After being sent out and removed from the certifier, the amount is refunded abnormally" msg = other_node.ppos.getCandidateInfo(node.node_id) log.info(msg) node.start() time.sleep(10) staking_result = client.staking.create_staking(0, staking_address, staking_address) assert_code(staking_result, 0) candidate_info = node.ppos.getCandidateInfo(node.node_id) log.info(candidate_info) staking_blocknum = candidate_info["Ret"]["StakingBlockNum"] log.info("Delegation") msg = client.delegate.delegate(0, client.delegate_address, node.node_id) assert_code(msg, 0) msg = client.delegate.withdrew_delegate(staking_blocknum, client.delegate_address, node.node_id) assert_code(msg, 0)
def test_ZB_NP_14_15(new_validator_client): new_validator_client.node.stop() economic = new_validator_client.economic node = economic.env.get_consensus_node_by_index(0) initial_validator, slashing_node_list = gen_validator_list( economic.env.consensus_node_id_list(), new_validator_client.node.node_id) assert_set_validator_list(node, slashing_node_list) current_validator = get_pledge_list(node.ppos.getValidatorList) log.info("current validator: {}".format(current_validator)) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert len(wait_slashing_list) == 0 assert_set_validator_list(node, initial_validator) current_validator = get_pledge_list(node.ppos.getValidatorList) log.info("current validator: {}".format(current_validator)) assert new_validator_client.node.node_id in current_validator economic.wait_consensus(node) # 需要在等一个共识轮才能查看到待处罚信息 assert_set_validator_list(node, slashing_node_list) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(1) assert_set_validator_list(node, initial_validator) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(1) assert_set_validator_list(node, initial_validator) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(101) assert_set_validator_list(node, initial_validator) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(101) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(1) assert_not_slashing( node.ppos.getCandidateInfo(new_validator_client.node.node_id), new_validator_client.staking_amount)
def test_RV_012(global_test_env, clients_noconsensus): """ Candidate cancels pledge """ global_test_env.deploy_all() client1 = clients_noconsensus[0] client2 = clients_noconsensus[1] address1, _ = client1.economic.account.generate_account( client1.node.web3, client1.economic.create_staking_limit * 2) address2, _ = client1.economic.account.generate_account( client1.node.web3, client1.economic.create_staking_limit * 2) result = client1.staking.create_staking( 0, address1, address1, amount=client1.economic.create_staking_limit) assert_code(result, 0) result = client2.staking.create_staking( 0, address2, address2, amount=client2.economic.create_staking_limit) assert_code(result, 0) log.info("Next settlement period") client2.economic.wait_settlement(client2.node) # msg = clients_noconsensus[1].ppos.getVerifierList() # log.info(msg) verifierlist = get_pledge_list(client2.ppos.getVerifierList) log.info("verifierlist:{}".format(verifierlist)) assert client2.node.node_id not in verifierlist msg = client2.staking.withdrew_staking(address2) assert_code(msg, 0)
def test_RV_012(global_test_env, client_noc_list_obj): """ Candidate cancels pledge """ global_test_env.deploy_all() address1, _ = client_noc_list_obj[0].economic.account.generate_account( client_noc_list_obj[0].node.web3, 10**18 * 10000000) address2, _ = client_noc_list_obj[0].economic.account.generate_account( client_noc_list_obj[0].node.web3, 10**18 * 10000000) result = client_noc_list_obj[0].staking.create_staking( 0, address1, address1, amount=client_noc_list_obj[0].economic.create_staking_limit * 2) assert_code(result, 0) result = client_noc_list_obj[1].staking.create_staking( 0, address2, address2, amount=client_noc_list_obj[1].economic.create_staking_limit) assert_code(result, 0) log.info("Next settlement period") client_noc_list_obj[1].economic.wait_settlement_blocknum( client_noc_list_obj[1].node) msg = client_noc_list_obj[1].ppos.getVerifierList() log.info(msg) verifierlist = get_pledge_list(client_noc_list_obj[1].ppos.getVerifierList) log.info("verifierlist:{}".format(verifierlist)) assert client_noc_list_obj[1].node.node_id not in verifierlist msg = client_noc_list_obj[1].staking.withdrew_staking(address2) assert_code(msg, 0)
def test_ZB_NP_30(new_validator_client): new_validator_client.node.stop() economic = new_validator_client.economic node = economic.env.get_consensus_node_by_index(0) initial_validator, slashing_node_list = gen_validator_list( economic.env.consensus_node_id_list(), new_validator_client.node.node_id) assert_set_validator_list(node, slashing_node_list) current_validator = get_pledge_list(node.ppos.getValidatorList) log.info("current validator: {}".format(current_validator)) economic.wait_consensus(node) assert_set_validator_list(node, slashing_node_list) economic.wait_consensus(node) num = economic.get_switchpoint_by_consensus(node, 1) while node.block_number < num: new_validator_client.node.start(False) time.sleep(4) print(new_validator_client.node.block_number, node.block_number) new_validator_client.node.stop() time.sleep(2) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert len(wait_slashing_list) == 0 assert_not_slashing( node.ppos.getCandidateInfo(new_validator_client.node.node_id), new_validator_client.staking_amount)
def preactive_proposal_pips(all_clients): if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \ all_clients[0].pip.cfg.version0 or all_clients[0].pip.is_exist_effective_proposal_for_vote( all_clients[0].pip.cfg.param_proposal ): log.info('There is effective version proposal, restart the chain') all_clients[0].economic.env.deploy_all() verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) log.info('verifierlist :{}'.format(verifier_list)) client_verifiers = get_clients_by_nodeid(verifier_list, all_clients) pips = [client_verifier.pip for client_verifier in client_verifiers] log.info('pips :{}'.format(pips)) result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()), pips[0].cfg.version5, 8, pips[0].node.staking_address, transaction_cfg=pips[0].cfg.transaction_cfg) log.info('submit version proposal, result : {}'.format(result)) proposalinfo = pips[0].get_effect_proposal_info_of_vote() log.info('Version proposalinfo: {}'.format(proposalinfo)) for pip in pips: result = version_proposal_vote(pip) assert_code(result, 0) wait_block_number(pips[0].node, proposalinfo.get('EndVotingBlock')) assert pips[0].get_status_of_proposal(proposalinfo.get('ProposalID')) == 4 return pips
def noproposal_candidate_pips(all_clients) -> List[Pip]: ''' Get verifier Client object list :param global_test_env: :return: ''' if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \ all_clients[0].pip.cfg.version0: log.info('There is effective proposal, Restart the chain') all_clients[0].economic.env.deploy_all() nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier() log.info('candidate not verifier list {}'.format(nodeid_list)) if not nodeid_list: candidate_list = get_pledge_list(all_clients[0].ppos.getCandidateList) log.info('candidate_list{}'.format(candidate_list)) for client in all_clients: if client.node.node_id not in candidate_list: address, _ = client.economic.account.generate_account(client.node.web3, 10**18 * 10000000) result = client.staking.create_staking(0, address, address) log.info('node {} staking result {}'.format(client.node.node_id, result)) client.economic.wait_settlement_blocknum(client.node) nodeid_list = all_clients[0].pip.get_candidate_list_not_verifier() if not nodeid_list: raise Exception('get candidate not verifier failed') clients_candidate = get_clients_by_nodeid(nodeid_list, all_clients) return [client_candidate.pip for client_candidate in clients_candidate]
def client_candidate_obj(global_running_env, staking_cfg): """ Get a candidate node Client object """ client_consensus_obj = get_client_consensus_obj(global_running_env, staking_cfg) client_list_obj = get_client_list_obj(global_running_env, staking_cfg) client_noconsensus_obj_list = get_client_noconsensus_list(global_running_env, staking_cfg) if not client_consensus_obj.staking.get_candidate_list_not_verifier(): log.info('There is no candidate, node stake') candidate_list = get_pledge_list(client_consensus_obj.node.ppos.getCandidateList) for client in client_noconsensus_obj_list: if client.node.node_id not in candidate_list: if client.node.program_version != client.pip.cfg.version0: upload_platon(client.node, client.pip.cfg.PLATON_NEW_BIN0) client.node.restart() log.info('Node {} staking'.format(client.node.node_id)) address, _ = client.economic.account.generate_account(client.node.web3, client.economic.create_staking_limit * 5) result = client.staking.create_staking(0, address, address) log.info('Node {} staking result :{}'.format(client.node.node_id, result)) assert_code(result, 0) client_consensus_obj.economic.wait_settlement_blocknum(client_consensus_obj.node) node_id_list = client_consensus_obj.staking.get_candidate_list_not_verifier() log.info('Get candidate list no verifier {}'.format(node_id_list)) if len(node_id_list) == 0: raise Exception('Get candidate list no verifier failed') return get_client_obj(node_id_list[0], client_list_obj)
def candidate_has_proposal(clients_noconsensus, all_clients): clients_noconsensus[0].economic.env.deploy_all() for client in clients_noconsensus: address, _ = client.economic.account.generate_account( client.node.web3, 10**18 * 10000000) log.info('Node {} staking'.format(client.node.node_id)) result = client.staking.create_staking(0, address, address) log.info('Node {} staking result: {}'.format(client.node.node_id, result)) assert_code(result, 0) client.economic.wait_settlement(client.node) node_id_list = client.pip.get_candidate_list_not_verifier() if not node_id_list: raise Exception('Get candidate list') verifiers = get_pledge_list(client.ppos.getVerifierList) log.info('Verifier list : {}'.format(verifiers)) pip = get_client_by_nodeid(verifiers[0], all_clients).pip result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit version proposal result : {}'.format(result)) assert_code(result, 0) return get_client_by_nodeid(node_id_list[0], all_clients).pip
def preactive_bv_proposal_pipobj_list(global_test_env, client_list_obj): if client_list_obj[0].pip.is_exist_effective_proposal() or client_list_obj[0].pip.chain_version != \ client_list_obj[0].pip.cfg.version0: log.info('There is effective version proposal, restart the chain') global_test_env.deploy_all() verifier_list = get_pledge_list(client_list_obj[0].ppos.getVerifierList) log.info('verifierlist :{}'.format(verifier_list)) client_verifier_list_obj = get_client_obj_list(verifier_list, client_list_obj) pip_list_obj = [client_obj.pip for client_obj in client_verifier_list_obj] result = pip_list_obj[0].submitVersion( pip_list_obj[0].node.node_id, str(time.time_ns()), pip_list_obj[0].cfg.version8, 2, pip_list_obj[0].node.staking_address, transaction_cfg=pip_list_obj[0].cfg.transaction_cfg) log.info('submit version proposal, result : {}'.format(result)) proposalinfo = pip_list_obj[0].get_effect_proposal_info_of_vote() log.info('Version proposalinfo: {}'.format(proposalinfo)) for pip_obj in pip_list_obj: result = version_proposal_vote(pip_obj) assert_code(result, 0) wait_block_number(pip_obj.node, proposalinfo.get('EndVotingBlock')) assert pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4 return pip_list_obj
def test_ZB_NP_13(new_validator_client): new_validator_client.node.stop() economic = new_validator_client.economic node = economic.env.get_consensus_node_by_index(0) initial_validator, slashing_node_list = gen_validator_list( economic.env.consensus_node_id_list(), new_validator_client.node.node_id) set_slashing(initial_validator, slashing_node_list, node, economic, "111") economic.wait_consensus(node, 1) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, new_validator_client.node.node_id) == to_int(111) pri = economic.env.account.find_pri_key( new_validator_client.staking_address) node.ppos.withdrewStaking(new_validator_client.node.node_id, pri) log.info("current validator: {}".format( get_pledge_list(node.ppos.getValidatorList))) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert len(wait_slashing_list) == 0 assert_slashing( node.ppos.getCandidateInfo(new_validator_client.node.node_id), new_validator_client.staking_amount)
def test_UV_UPG_2(self, new_genesis_env, clients_consensus, client_noconsensus): new_genesis_env.deploy_all() pip = clients_consensus[0].pip pip_test = client_noconsensus.pip address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10 ** 18 * 10000000) result = client_noconsensus.staking.create_staking(0, address, address, amount=10 ** 18 * 2000000, transaction_cfg=pip_test.cfg.transaction_cfg) log.info('Node {} staking result : {}'.format(pip_test.node.node_id, result)) programversion = client_noconsensus.staking.get_version() assert_code(programversion, pip.cfg.version0) pip_test.economic.wait_settlement_blocknum(pip_test.node) verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_test.node.node_id in verifier_list submitvpandvote(clients_consensus) programversion = clients_consensus[0].staking.get_version() assert_code(programversion, pip.cfg.version0) proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Get version proposal information : {}'.format(proposalinfo)) replace_version_declare(pip_test, pip_test.cfg.PLATON_NEW_BIN, pip_test.cfg.version5) assert_code(result, 0) programversion = client_noconsensus.staking.get_version() assert_code(programversion, pip.cfg.version0) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) verifier_node_version(pip, proposalinfo.get('NewVersion')) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_test.node.node_id in validator_list assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) pip.economic.wait_settlement_blocknum(pip.node) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_test.node.node_id in validator_list verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_test.node.node_id in verifier_list programversion = clients_consensus[0].staking.get_version() assert_code(programversion, pip.cfg.version5) programversion = client_noconsensus.staking.get_version() assert_code(programversion, pip_test.cfg.version5)
def param_governance_verify(client, module, name, newvalue, effectiveflag=True): """ effectiveflag indicates whether it takes effect """ if isinstance(client, Client): pip = client.pip else: raise Exception("client must Client class") if pip.is_exist_effective_proposal_for_vote(pip.cfg.param_proposal) or \ pip.is_exist_effective_proposal_for_vote(pip.cfg.version_proposal): raise Exception( 'There is effective param proposal or version proposal') result = pip.submitParam(pip.node.node_id, str(time.time()), module, name, newvalue, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('submit param proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal) log.info('param proposalinfo : {}'.format(proposalinfo)) all_clients = [] for node_obj in pip.economic.env.get_all_nodes(): all_clients.append( Client( pip.economic.env, node_obj, StakingConfig("externalId", "nodeName", "website", "details"))) client = get_client_by_nodeid(pip.node.node_id, all_clients) verifier_list = get_pledge_list(client.ppos.getVerifierList) log.info('verifierlist : {}'.format(verifier_list)) clients_verifier = get_clients_by_nodeid(verifier_list, all_clients) if effectiveflag: blocknum = 0 for client in clients_verifier: if client.node.block_number < blocknum and blocknum != 0: wait_block_number(client.node, blocknum) result = client.pip.vote( client.node.node_id, proposalinfo.get('ProposalID'), client.pip.cfg.vote_option_yeas, client.node.staking_address, transaction_cfg=client.pip.cfg.transaction_cfg) log.info('Node {} vote proposal result : {}'.format( client.node.node_id, result)) blocknum = client.node.block_number wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) if effectiveflag: assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 2 log.info("blockNumber {}, the {} has become {}".format( proposalinfo.get('EndVotingBlock'), name, newvalue)) else: assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 3 log.info("{} retains the original value".format(name))
def clients_verifier(global_running_env, staking_cfg) -> List[Client]: """ Get verifier node Client object list """ all_clients = get_clients(global_running_env, staking_cfg) verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) return get_clients_by_nodeid(verifier_list, all_clients)
def client_verifier_obj_list(global_running_env, staking_cfg): """ Get verifier node Client object list """ client_list_obj = get_client_list_obj(global_running_env, staking_cfg) verifier_list = get_pledge_list(client_list_obj[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) return get_client_obj_list(verifier_list, client_list_obj)
def preactive_proposal_ca_pipobj_list(global_test_env, client_list_obj, client_noc_list_obj, client_verifier_obj): ''' There is voting stage proposal, get candidate list pip object :param global_test_env: :return: ''' pip_obj = client_list_obj[0].pip if pip_obj.chain_version != pip_obj.cfg.version0 or ( pip_obj.is_exist_effective_proposal and not pip_obj.get_effect_proposal_info_of_vote): log.info( 'The chain has been upgraded or there is preactive proposal,restart!' ) global_test_env.deploy_all() nodeid_list = pip_obj.get_candidate_list_not_verifier() if nodeid_list: if pip_obj.get_effect_proposal_info_of_vote(): proposalinfo = pip_obj.get_effect_proposal_info_of_vote() log.info('get version proposalinfo : {}'.format(proposalinfo)) if proposalinfo.get('NewVersion') == pip_obj.cfg.version8: global_test_env.deploy_all() else: if proposalinfo.get( 'EndVotingBlock' ) - pip_obj.node.block_number > pip_obj.economic.consensus_size: client_ca_obj_list = get_client_obj_list( nodeid_list, client_list_obj) return [ client_obj.pip for client_obj in client_ca_obj_list ] candidate_list = get_pledge_list(client_list_obj[0].ppos.getCandidateList) log.info('candidate_list{}'.format(candidate_list)) for client_obj in client_noc_list_obj: if client_obj.node.node_id not in candidate_list: address, _ = client_obj.economic.account.generate_account( client_obj.node.web3, 10**18 * 10000000) result = client_obj.staking.create_staking(0, address, address) log.info('node {} staking result {}'.format( client_obj.node.node_id, result)) result = client_verifier_obj.pip.submitVersion( client_verifier_obj.pip.node.node_id, str(time.time()), client_verifier_obj.pip.cfg.version5, 10, client_verifier_obj.pip.node.staking_address, transaction_cfg=client_verifier_obj.pip.cfg.transaction_cfg) log.info('Submit version proposal result {}'.format(result)) assert_code(result, 0) nodeid_list = client_list_obj[0].pip.get_candidate_list_not_verifier() if not nodeid_list: raise Exception('get candidate not verifier failed') client_ca_list = get_client_obj_list(nodeid_list, client_list_obj) return [client_ca_obj.pip for client_ca_obj in client_ca_list]
def client_verifier(global_running_env, staking_cfg) -> Client: """ Get a verifier node Client object """ all_clients = get_clients(global_running_env, staking_cfg) verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) for client in all_clients: if client.node.node_id in verifier_list: return client raise Exception('Get a verifier node Client object ')
def client_verifier_obj(global_running_env, staking_cfg): """ Get a verifier node Client object """ client_list_obj = get_client_list_obj(global_running_env, staking_cfg) verifier_list = get_pledge_list(client_list_obj[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) for client in client_list_obj: if client.node.node_id in verifier_list: return client raise Exception('Get a verifier node Client object ')
def test_1(self, new_genesis_env, clients_consensus): pip = clients_consensus[-1].pip submitvpandvote(clients_consensus[0:2]) replace_version_declare(pip, pip.cfg.PLATON_NEW_BIN, pip.cfg.version5) proposalinfo = pip.get_effect_proposal_info_of_vote() wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) submitvpandvote(clients_consensus[:3]) proposalinfo = pip.get_effect_proposal_info_of_vote() wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info(verifier_list) assert pip.node.node_id in verifier_list
def test_UV_UPG_1_UV_UPG_2(self, new_genesis_env, client_con_list_obj, client_noconsensus_obj): new_genesis_env.deploy_all() pip_obj = client_con_list_obj[0].pip pip_obj_test = client_noconsensus_obj.pip address, _ = pip_obj_test.economic.account.generate_account(pip_obj_test.node.web3, 10**18 * 10000000) result = client_noconsensus_obj.staking.create_staking(0, address, address, amount=10**18 * 2000000, transaction_cfg=pip_obj_test.cfg.transaction_cfg) log.info('Node {} staking result : {}'.format(pip_obj_test.node.node_id, result)) pip_obj_test.economic.wait_settlement_blocknum(pip_obj_test.node) verifier_list = get_pledge_list(client_con_list_obj[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_obj_test.node.node_id in verifier_list submitvpandvote(client_con_list_obj) proposalinfo = pip_obj.get_effect_proposal_info_of_vote() log.info('Get version proposal information : {}'.format(proposalinfo)) wait_block_number(pip_obj.node, proposalinfo.get('EndVotingBlock')) assert_code(pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) validator_list = get_pledge_list(client_con_list_obj[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) wait_block_number(pip_obj.node, proposalinfo.get('ActiveBlock')) validator_list = get_pledge_list(client_con_list_obj[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_obj_test.node.node_id not in validator_list assert_code(pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) pip_obj.economic.wait_settlement_blocknum(pip_obj.node) validator_list = get_pledge_list(client_con_list_obj[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_obj_test.node.node_id not in validator_list verifier_list = get_pledge_list(client_con_list_obj[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_obj_test.node.node_id not in verifier_list balance_before = pip_obj.node.eth.getBalance(address, 2 * pip_obj.economic.settlement_size - 1) log.info('Block number {} address balace {}'.format(2 * pip_obj.economic.settlement_size - 1, balance_before)) balance_after = pip_obj.node.eth.getBalance(address, 2 * pip_obj.economic.settlement_size) log.info('Block number {} address balace {}'.format(2 * pip_obj.economic.settlement_size, balance_after)) _, staking_reward = pip_obj_test.economic.get_current_year_reward(pip_obj_test.node, verifier_num=5) assert balance_after - balance_before == staking_reward
def test_RV_002(staking_client): """ The certifier refunds the quality deposit (unreachable unlockable period) Pledge becomes the next cycle verifier, after exiting, exit in the next settlement cycle """ client = staking_client staking_address = client.staking_address node = client.node economic = client.economic staking_address_balance = node.eth.getBalance(staking_address) log.info(staking_address_balance) economic.wait_settlement(node) log.info("Query the certifier for the second billing cycle") node_list = get_pledge_list(client.ppos.getVerifierList) log.info(node_list) assert node.node_id in node_list log.info( "The node applies for a return during the lockout period in the second settlement cycle." ) client.staking.withdrew_staking(staking_address) """Initiation of returning consumes a certain amount of gas""" staking_address_balance_1 = node.eth.getBalance(staking_address) log.info(staking_address_balance_1) log.info("Enter the third billing cycle") economic.wait_settlement(node) staking_address_balance_2 = node.eth.getBalance(staking_address) log.info(staking_address_balance_2) node_list = get_pledge_list(client.ppos.getVerifierList) log.info(node_list) assert node.node_id not in node_list log.info("Enter the 4th billing cycle") economic.wait_settlement(node, 1) msg = client.ppos.getCandidateInfo(node.node_id) log.info(msg) staking_address_balance_3 = node.eth.getBalance(staking_address) log.info(staking_address_balance_3) log.info(staking_address_balance_3 - staking_address_balance_1) assert staking_address_balance_3 - staking_address_balance_1 > client.staking_amount, "The amount of the returned transaction should be greater than the amount of the returned deposit."
def noproposal_pipobj_list(global_test_env, client_list_obj): ''' Get candidate Client object list :param global_test_env: :return: ''' if client_list_obj[0].pip.is_exist_effective_proposal() or client_list_obj[0].pip.chain_version != \ client_list_obj[0].pip.cfg.version0: log.info('There is effective proposal, Restart the chain') global_test_env.deploy_all() verifier_list = get_pledge_list(client_list_obj[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) client_obj_list = get_client_obj_list(verifier_list, client_list_obj) return [client_obj.pip for client_obj in client_obj_list]
def noproposal_pips(all_clients) -> List[Pip]: ''' Get candidate Client object list :param global_test_env: :return: ''' if all_clients[0].pip.is_exist_effective_proposal() or all_clients[0].pip.chain_version != \ all_clients[0].pip.cfg.version0: log.info('There is effective proposal, Restart the chain') all_clients[0].economic.env.deploy_all() verifier_list = get_pledge_list(all_clients[0].ppos.getVerifierList) log.info('verifierlist{}'.format(verifier_list)) clients = get_clients_by_nodeid(verifier_list, all_clients) return [client.pip for client in clients]
def test_ZB_NP_29(update_zero_produce_env, clients_noconsensus): client_a = clients_noconsensus[0] client_b = clients_noconsensus[1] amount = calculate(client_a.economic.create_staking_limit, 5) staking_amount_a = calculate(client_a.economic.create_staking_limit, 1) staking_amount_b = calculate(client_a.economic.create_staking_limit, 2) staking_address, _ = client_a.economic.account.generate_account( client_a.node.web3, amount) result = client_a.staking.create_staking(0, staking_address, staking_address, amount=staking_amount_a, reward_per=10) assert_code(result, 0) economic = client_b.economic economic.wait_settlement(client_b.node) client_a.node.stop() economic = client_b.economic node = economic.env.get_consensus_node_by_index(0) initial_validator, slashing_node_list = gen_validator_list( economic.env.consensus_node_id_list(), client_a.node.node_id) assert_set_validator_list(node, initial_validator) current_validator = get_pledge_list(node.ppos.getValidatorList) log.info("current validator: {}".format(current_validator)) economic.wait_consensus(node, 1) result = client_b.staking.create_staking(0, staking_address, staking_address, amount=staking_amount_b, reward_per=10) assert_code(result, 0) assert_set_validator_list(node, slashing_node_list) economic.wait_consensus(node) assert_set_validator_list(node, initial_validator) economic.wait_consensus(node) economic.wait_consensus(node, 3) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert get_slash_count(wait_slashing_list, client_a.node.node_id) == to_int(1) economic.wait_consensus(node) wait_slashing_list = node.debug.getWaitSlashingNodeList() assert len(wait_slashing_list) == 0 assert_not_slashing(node.ppos.getCandidateInfo(client_a.node.node_id), staking_amount_a)
def test_RV_013(staking_client): """ The verifier revoks the pledge """ client = staking_client staking_address = client.staking_address node = client.node economic = client.economic log.info("Enter the next cycle") economic.wait_settlement(node, 1) verifier_list = get_pledge_list(node.ppos.getVerifierList) log.info( log.info("Current billing cycle certifier {}".format(verifier_list))) assert node.node_id in verifier_list msg = client.staking.withdrew_staking(staking_address) assert_code(msg, 0)
def test_UV_UPG_1_UV_UPG_2(self, new_genesis_env, clients_consensus, client_noconsensus): new_genesis_env.deploy_all() pip = clients_consensus[0].pip pip_test = client_noconsensus.pip address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10**18 * 10000000) result = client_noconsensus.staking.create_staking(0, address, address, amount=10 ** 18 * 2000000, transaction_cfg=pip_test.cfg.transaction_cfg) log.info('Node {} staking result : {}'.format(pip_test.node.node_mark, result)) programversion = client_noconsensus.staking.get_version() assert_code(programversion, pip.cfg.version0) pip_test.economic.wait_settlement(pip_test.node) verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_test.node.node_id in verifier_list submitvpandvote(clients_consensus, 5) upload_platon(pip_test.node, pip_test.cfg.PLATON_NEW_BIN) programversion = clients_consensus[0].staking.get_version() assert_code(programversion, pip.cfg.version0) proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Get version proposal information : {}'.format(proposalinfo)) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 1) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_test.node.node_id not in validator_list assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) block_reward, staking_reward = pip_test.economic.get_current_year_reward(pip_test.node, verifier_num=5) pip.economic.wait_settlement(client_noconsensus.node) count = get_block_count_number(client_noconsensus.node, 320) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list : {}'.format(validator_list)) assert pip_test.node.node_id not in validator_list verifier_list = get_pledge_list(clients_consensus[0].ppos.getVerifierList) log.info('Get verifier list : {}'.format(verifier_list)) assert pip_test.node.node_id not in verifier_list block_reward, staking_reward = pip.economic.get_current_year_reward(pip.node, 5) log.info(f'block_reward == {block_reward}, staking_reward == {staking_reward}') balance_before = pip.node.eth.getBalance(address, 2 * pip.economic.settlement_size - 1) log.info('Block number {} address balace {}'.format(2 * pip.economic.settlement_size - 1, balance_before)) pip.economic.wait_consensus(pip.node) balance_after = pip.node.eth.getBalance(address, 2 * pip.economic.settlement_size) log.info('Block number {} address balace {}'.format(2 * pip.economic.settlement_size, balance_after)) log.info('Staking reward : {}'.format(staking_reward)) assert balance_after - balance_before == staking_reward