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_blocknum(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 test_AV_IN_002_003(self, client_verifier_obj_list): pip_obj = client_verifier_obj_list[0].pip submitvpandvote(client_verifier_obj_list) proposalinfo = pip_obj.get_effect_proposal_info_of_vote() log.info('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) assert_code(pip_obj.chain_version, pip_obj.cfg.version0) wait_block_number(pip_obj.node, proposalinfo.get('ActiveBlock')) assert_code( pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')), 5) assert_code(pip_obj.chain_version, pip_obj.cfg.version5)
def test_RV_024(staking_client): """ Can not increase and entrust after exiting pledge """ client = staking_client node = client.node staking_address = client.staking_address economic = client.economic log.info("Entering the lockout period") economic.wait_settlement(node) log.info("Node exit pledge") client.staking.withdrew_staking(staking_address) log.info("Node to increase holding") msg = client.staking.increase_staking(0, staking_address, amount=economic.add_staking_limit) assert_code(msg, 301103) log.info("Node to commission") msg = client.delegate.delegate(0, client.delegate_address) assert_code(msg, 301103)
def new_node_has_proposal(client_new_node, client_verifier, client_noconsensus): pip = client_verifier.pip if pip.chain_version != pip.cfg.version0 or pip.is_exist_effective_proposal(pip.cfg.param_proposal): client_new_node.economic.env.deploy_all() if pip.is_exist_effective_proposal(): proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Get version proposal information {}'.format(proposalinfo)) if proposalinfo.get('EndVotingBlock') - pip.node.block_number < 2 * pip.economic.consensus_size: client_new_node.economic.env.deploy_all() result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 5, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) assert_code(result, 0) return client_noconsensus.pip else: return client_new_node.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) assert_code(result, 0) return client_new_node.pip
def test_declareversion(self, client_verifier): pip = client_verifier.pip balance_before = self.get_balance(pip) result = pip.declareVersion(pip.node.node_id, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Declare version result : {}'.format(result)) assert_code(result, 0) version_sign = pip.node.program_version_sign[2:] data = rlp.encode([ rlp.encode(int(2004)), rlp.encode(bytes.fromhex(pip.node.node_id)), rlp.encode(int(pip.node.program_version)), rlp.encode(bytes.fromhex(version_sign)) ]) gas = get_the_dynamic_parameter_gas_fee(data) log.info('Calculated gas : {}'.format(gas)) balance_after = self.get_balance(pip) assert_code(balance_before - balance_after, (gas + 33000) * pip.cfg.transaction_cfg.get('gasPrice'))
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_id, result)) programversion = client_noconsensus.staking.get_version() assert_code(programversion, pip.cfg.version0) pip_test.economic.wait_settlement_blocknum(pip_test.node) log.info(f'blocknem ====== {pip_test.node.eth.blockNumber}') 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)) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 1) validator_list = get_pledge_list(clients_consensus[0].ppos.getValidatorList) log.info('Validator list =====: {}'.format(validator_list)) 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')) log.info(f'blocknem ====== {pip_test.node.eth.blockNumber}') 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) 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 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 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)) 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)) _, staking_reward = pip_test.economic.get_current_year_reward(pip_test.node, verifier_num=5) log.info('Staking reward : {}'.format(staking_reward)) assert balance_after - balance_before == staking_reward
def preactive_large_version_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: 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.pip for client in client_verifiers] result = pips[0].submitVersion(pips[0].node.node_id, str(time.time()), pips[0].cfg.version8, 3, 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(pip.node, proposalinfo.get('EndVotingBlock')) assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 4 return pips
def test_V_STA_6_7(self, submit_cancel, clients_verifier): pip = submit_cancel proposalinfo = pip.get_effect_proposal_info_of_vote( pip.cfg.cancel_proposal) log.info('Cancel proposal info : {}'.format(proposalinfo)) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 10) result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) assert_code(result, 0) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) for client in clients_verifier: if client.node.node_id != pip.node.node_id: pip_test = client.pip break result = pip_test.vote(pip_test.node.node_id, proposalinfo.get('ProposalID'), pip_test.cfg.vote_option_Abstentions, pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) log.info('Node {} vote result {}'.format(pip_test.node.node_id, result)) assert_code(result, 302026)
def staking_delegate_client(client_new_node): staking_amount = client_new_node.economic.create_staking_limit delegate_amount = client_new_node.economic.add_staking_limit staking_address, _ = client_new_node.economic.account.generate_account( client_new_node.node.web3, staking_amount * 2) delegate_address, _ = client_new_node.economic.account.generate_account( client_new_node.node.web3, staking_amount * 2) result = client_new_node.staking.create_staking(0, staking_address, staking_address) assert_code(result, 0) result = client_new_node.delegate.delegate(0, delegate_address, amount=delegate_amount * 2) assert_code(result, 0) msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) staking_blocknum = msg["Ret"]["StakingBlockNum"] setattr(client_new_node, "staking_address", staking_address) setattr(client_new_node, "delegate_address", delegate_address) setattr(client_new_node, "delegate_amount", delegate_amount) setattr(client_new_node, "staking_blocknum", staking_blocknum) yield client_new_node
def test_PR_IN_003(self, client_verifier): pip = client_verifier.pip pip_id = str(time.time()) result = pip.submitText(pip.node.node_id, pip_id, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit text proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo_text = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) log.info('Get text proposal information : {}'.format(proposalinfo_text)) result_text = pip.pip.getProposal(proposalinfo_text.get('ProposalID')) log.info('Interface getProposal-text result : {}'.format(result_text)) assert result_text.get('Ret').get('Proposer') == pip.node.node_id assert result_text.get('Ret').get('ProposalType') == pip.cfg.text_proposal assert result_text.get('Ret').get('PIPID') == pip_id assert result_text.get('Ret').get('SubmitBlock') == proposalinfo_text.get('SubmitBlock') log.info(pip.economic.tp_vote_settlement_wheel) caculated_endvotingblock = math.ceil(proposalinfo_text.get('SubmitBlock') / pip.economic.consensus_size + pip.economic.tp_vote_settlement_wheel) * pip.economic.consensus_size - 20 assert result_text.get('Ret').get('EndVotingBlock') == caculated_endvotingblock
def test_TR_IN_010_005(self, new_genesis_env, clients_consensus): genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() pip = clients_consensus[0].pip submitppandvote(clients_consensus[0:-1], 1, 2, 3) proposalinfo = clients_consensus[0].pip.get_effect_proposal_info_of_vote(clients_consensus[0].pip.cfg.param_proposal) log.info('Param proposal information {}'.format(proposalinfo)) log.info('listparam {}'.format(clients_consensus[0].pip.pip.listGovernParam())) result = pip.pip.getTallyResult(proposalinfo.get('ProposalID')) log.info('Interface getTallyResult info : {}'.format(result)) assert_code(result, 302030) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) assert pip.get_canceledby_of_proposal(proposalinfo.get('ProposalID')) == cancelby assert pip.get_status_of_proposal(proposalinfo.get('ProposalID')) == 3 assert pip.get_yeas_of_proposal(proposalinfo.get('ProposalID')) == 1 assert pip.get_nays_of_proposal(proposalinfo.get('ProposalID')) == 1 assert pip.get_abstentions_of_proposal(proposalinfo.get('ProposalID')) == 1 assert pip.get_accu_verifiers_of_proposal(proposalinfo.get('ProposalID')) == len(clients_consensus)
def test_AC_IN_016_to_018(self, client_verifier): pip = client_verifier.pip result = pip.submitText(pip.node.node_id, str(time.time()), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit text proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo = pip.get_effect_proposal_info_of_vote( pip.cfg.text_proposal) log.info('Get text proposal information : {}'.format(proposalinfo)) result = pip.pip.getAccuVerifiersCount( '0x0c04f578466ead2208dbb15b927ecb27041881e8c16c17cd0db6b3df422e1111', block_hash=get_blockhash(pip.node)) log.info('Interface getAccuVerifiersCount result : {}'.format(result)) assert_code(result, 302006) log.info('{}'.format(get_blockhash(pip.node))) # result = pip.pip.getAccuVerifiersCount(proposalinfo.get('ProposalID'), block_hash='') # log.info('Interface getAccuVerifiersCount result : {}'.format(result)) # assert_code(result, 3) result = pip.pip.getAccuVerifiersCount( proposalinfo.get('ProposalID'), block_hash= '0x5941605fe43ab32fbaf9c6e08dc0970eae50efb7da4248a9a8941f0e50711111' ) log.info('Interface getAccuVerifiersCount result : {}'.format(result)) assert_code(result, 0)
def test_submitText(self, client_verifier_obj): pip_obj = client_verifier_obj.pip pip_id = str(time.time()) data = rlp.encode([ rlp.encode(int(2000)), rlp.encode(bytes.fromhex(pip_obj.node.node_id)), rlp.encode(pip_id) ]) balance_before = self.get_balance(pip_obj) result = pip_obj.submitText( pip_obj.node.node_id, pip_id, pip_obj.node.staking_address, transaction_cfg=pip_obj.cfg.transaction_cfg) log.info('Submit text proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo = pip_obj.get_effect_proposal_info_of_vote( pip_obj.cfg.text_proposal) log.info('Get text proposal information : {}'.format(proposalinfo)) balance_after = self.get_balance(pip_obj) gas = get_the_dynamic_parameter_gas_fee(data) log.info('Calculated gas : {}'.format(gas)) assert_code(balance_before - balance_after, (gas + 350000) * pip_obj.cfg.transaction_cfg.get('gasPrice')) proposal_id = proposalinfo.get('ProposalID')[2:] version_sign = pip_obj.node.program_version_sign[2:] data = rlp.encode([ rlp.encode(int(2003)), rlp.encode(bytes.fromhex(pip_obj.node.node_id)), rlp.encode(bytes.fromhex(proposal_id)), rlp.encode(pip_obj.cfg.vote_option_yeas), rlp.encode(int(pip_obj.node.program_version)), rlp.encode(bytes.fromhex(version_sign)) ]) result = pip_obj.vote(pip_obj.node.node_id, proposalinfo.get('ProposalID'), pip_obj.cfg.vote_option_yeas, pip_obj.node.staking_address, transaction_cfg=pip_obj.cfg.transaction_cfg) log.info('Vote reuslt : {}'.format(result)) assert_code(result, 0) balance_after_vote = pip_obj.node.eth.getBalance( pip_obj.node.staking_address) log.info('After vote text proposal, the address balance : {}'.format( balance_after_vote)) gas = get_the_dynamic_parameter_gas_fee(data) log.info('Calculated gas : {}'.format(gas)) assert_code(balance_after - balance_after_vote, (gas + 32000) * pip_obj.cfg.transaction_cfg.get('gasPrice'))
def test_dsda(client_new_node): """ """ client = client_new_node node = client.node economic = client.economic staking_address, _ = economic.account.generate_account( node.web3, economic.create_staking_limit * 2) staking_address1, _ = economic.account.generate_account( node.web3, economic.create_staking_limit * 2) staking_address2, _ = economic.account.generate_account( node.web3, economic.create_staking_limit * 2) result = client.staking.create_staking(0, staking_address, staking_address) assert_code(result, 0) print(client.node.ppos.getCandidateInfo(node.node_id)) print("1---------------") result = client.staking.edit_candidate(staking_address, staking_address1) assert_code(result, 0) print(client.node.ppos.getCandidateInfo(node.node_id)) print("2---------------") result = client.staking.edit_candidate(staking_address, staking_address2) assert_code(result, 0) print(client.node.ppos.getCandidateInfo(node.node_id)) print("3---------------")
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_V_STA_2_to_5(self, no_vp_proposal, clients_verifier): pip = no_vp_proposal value = len(clients_verifier) - 2 submitvpandvote(clients_verifier[:value], votingrounds=4) proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Get version proposal information : {}'.format(proposalinfo)) result = version_proposal_vote(clients_verifier[-2].pip) log.info('Node {} vote proposal result : {}'.format( clients_verifier[-1].node.node_id, result)) assert_code(result, 0) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) pip = clients_verifier[-1].pip upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN) pip.node.restart() log.info('Replace the platon bin and restart the node {}'.format( pip.node.node_id)) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node {} vote proposal result : {}'.format( clients_verifier[-1].node.node_id, result)) assert_code(result, 302026) log.info('{}'.format( pip.pip.getTallyResult(proposalinfo.get('ProposalID')))) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 4) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node {} vote proposal result : {}'.format( clients_verifier[-1].node.node_id, result)) assert_code(result, 302026) wait_block_number(pip.node, proposalinfo.get('ActiveBlock')) assert_code(pip.get_status_of_proposal(proposalinfo.get('ProposalID')), 5)
def test_PR_IN_001_002(self, no_vp_proposal): pip = no_vp_proposal pip_id = str(time.time()) result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version8, 3, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit version proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo_version = pip.get_effect_proposal_info_of_vote(pip.cfg.version_proposal) log.info('Get version proposal information : {}'.format(proposalinfo_version)) pip_id_cancel = str(time.time()) result = pip.submitCancel(pip.node.node_id, pip_id_cancel, 1, proposalinfo_version.get('ProposalID'), pip.node.staking_address, transaction_cfg=pip .cfg.transaction_cfg) log.info('Submit cancel proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal) log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel)) result_version = pip.pip.getProposal(proposalinfo_version.get('ProposalID')) log.info('Interface getProposal-version result : {}'.format(result_version)) result_cancel = pip.pip.getProposal(proposalinfo_cancel.get('ProposalID')) log.info('Interface getProposal-cancel result : {}'.format(result_cancel)) assert result_version.get('Ret').get('Proposer') == pip.node.node_id assert result_version.get('Ret').get('ProposalType') == pip.cfg.version_proposal assert result_version.get('Ret').get('PIPID') == pip_id assert result_version.get('Ret').get('SubmitBlock') == proposalinfo_version.get('SubmitBlock') caculated_endvotingblock = math.ceil(proposalinfo_version.get('SubmitBlock') / pip.economic.consensus_size + 3) * pip.economic.consensus_size - 20 assert result_version.get('Ret').get('EndVotingBlock') == caculated_endvotingblock assert result_cancel.get('Ret').get('Proposer') == pip.node.node_id assert result_cancel.get('Ret').get('ProposalType') == pip.cfg.cancel_proposal assert result_cancel.get('Ret').get('PIPID') == pip_id_cancel assert result_cancel.get('Ret').get('SubmitBlock') == proposalinfo_cancel.get('SubmitBlock') caculated_endvotingblock = math.ceil(proposalinfo_cancel.get('SubmitBlock') / pip.economic.consensus_size) * \ pip.economic.consensus_size + 20 assert result_cancel.get('Ret').get('EndVotingBlock') == caculated_endvotingblock
def test_VO_VO_003_V_STA_9_V_STA_10_V_STA_11_V0_WA_003_V0_RE_003( voting_text_proposal_verifier_pip, clients_verifier): pip = voting_text_proposal_verifier_pip proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal) address, _ = pip.economic.account.generate_account(pip.node.web3, 10**18 * 10000) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_yeas, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Not staking address vote result {}'.format(result)) assert_code(result, 302021) result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) log.info('vote result {}'.format(result)) assert_code(result, 0) result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) log.info('Repeat vote result {}'.format(result)) assert_code(result, 302027) for client in clients_verifier: if client.node.node_id != pip.node.node_id: pip_test = client.pip break wait_block_number(pip.node, proposalinfo.get('EndVotingBlock') - 10) result = proposal_vote(pip_test, proposaltype=pip.cfg.text_proposal) log.info('Node {} vote result {}'.format(pip_test.node.node_id, result)) assert_code(result, 0) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_nays, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Endvoting block vote result {}'.format(result)) assert_code(result, 302026)
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 param_governance_verify_before_endblock(client_obj, module, name, newvalue, effectiveflag=True): """ effectiveflag indicates whether it takes effect :param client_obj: :param module: :param name: :param newvalue: :param effectiveflag: :return: the EndVotingBlock of the param proposal """ if isinstance(client_obj, Client): pip_obj = client_obj.pip else: raise Exception("client must Client class") if pip_obj.is_exist_effective_proposal_for_vote(pip_obj.cfg.param_proposal) or \ pip_obj.is_exist_effective_proposal_for_vote(pip_obj.cfg.version_proposal): raise Exception('There is effective param proposal or version proposal') result = pip_obj.submitParam(pip_obj.node.node_id, str(time.time()), module, name, newvalue, pip_obj.node.staking_address, transaction_cfg=pip_obj.cfg.transaction_cfg) log.info('submit param proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo = pip_obj.get_effect_proposal_info_of_vote(pip_obj.cfg.param_proposal) log.info('param proposalinfo : {}'.format(proposalinfo)) client_obj_list = [] for node_obj in pip_obj.economic.env.get_all_nodes(): client_obj_list.append(Client(pip_obj.economic.env, node_obj, StakingConfig("externalId", "nodeName", "website", "details"))) client_obj = get_client_obj(pip_obj.node.node_id, client_obj_list) verifier_list = get_pledge_list(client_obj.ppos.getVerifierList) log.info('verifierlist : {}'.format(verifier_list)) client_verifier_obj_list = get_client_obj_list(verifier_list, client_obj_list) if effectiveflag: for client_obj in client_verifier_obj_list: result = client_obj.pip.vote(client_obj.node.node_id, proposalinfo.get('ProposalID'), client_obj.pip.cfg.vote_option_yeas, client_obj.node.staking_address, transaction_cfg=client_obj.pip.cfg.transaction_cfg) log.info('Node {} vote proposal result : {}'.format(client_obj.node.node_id, result)) log.info('The proposal endvoting block is {}'.format(proposalinfo.get('EndVotingBlock'))) return proposalinfo.get('EndVotingBlock')
def bv_proposal_voted_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 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) result = version_proposal_vote(client_obj_list[0].pip) assert_code(result, 0) return [client_obj.pip for client_obj in client_obj_list]
def test_VO_SI_013_VO_SI_014_VO_SI_015_VO_SI_016(self, submit_cancel_param, client_verifier_obj_list): pip_obj = submit_cancel_param for client_obj in client_verifier_obj_list: if pip_obj.node.node_id != client_obj.node.node_id: pip_obj_two = client_obj.pip break result = self.vote_wrong_version(pip_obj, pip_obj.cfg.param_proposal) assert_code(result, 0) result = self.vote_wrong_versionsign(pip_obj_two, pip_obj.cfg.param_proposal) assert_code(result, 0) result = self.vote_wrong_version(pip_obj, pip_obj.cfg.cancel_proposal) assert_code(result, 0) result = self.vote_wrong_versionsign(pip_obj_two, pip_obj.cfg.cancel_proposal) assert_code(result, 0)
def test_VO_SI_013_VO_SI_014_VO_SI_015_VO_SI_016(self, submit_cancel_param, clients_verifier): pip = submit_cancel_param for client in clients_verifier: if pip.node.node_id != client.node.node_id: pip_two = client.pip break result = self.vote_wrong_version(pip, pip.cfg.param_proposal) assert_code(result, 0) result = self.vote_wrong_versionsign(pip_two, pip.cfg.param_proposal) assert_code(result, 0) result = self.vote_wrong_version(pip, pip.cfg.cancel_proposal) assert_code(result, 0) result = self.vote_wrong_versionsign(pip_two, pip.cfg.cancel_proposal) assert_code(result, 0)
def test_RV_005(staking_client): client = staking_client node = client.node staking_address = client.staking_address economic = client.economic log.info("Create a lockout plan") lockup_amount = economic.add_staking_limit * 100 plan = [{'Epoch': 1, 'Amount': lockup_amount}] msg = client.restricting.createRestrictingPlan( staking_address, plan, economic.account.account_with_money["address"]) assert_code(msg, 0) locked_info = client.ppos.getRestrictingInfo(staking_address) log.info(locked_info) before_create_balance = client.amount log.info("Initiate the balance before the pledge {}".format( before_create_balance)) msg = client.staking.increase_staking(1, staking_address) assert_code(msg, 0) economic.wait_settlement(node) msg = client.ppos.getCandidateInfo(node.node_id) log.info("Query pledge {}".format(msg)) assert msg["Ret"][ "Shares"] == client.staking_amount + economic.add_staking_limit assert msg["Ret"]["Released"] == client.staking_amount assert msg["Ret"]["RestrictingPlan"] == economic.add_staking_limit block_reward, staking_reward = economic.get_current_year_reward(node) msg = client.staking.withdrew_staking(staking_address) assert_code(msg, 0) balance_withdrew = node.eth.getBalance(staking_address) log.info( "The second cycle initiated the revocation of the balance{}".format( balance_withdrew)) log.info("Enter the 3rd cycle") economic.wait_settlement(node) balance_settlement = node.eth.getBalance(staking_address) log.info("The balance after launching the revocation in the third cycle{}". format(balance_settlement)) log.info("Enter the 4th cycle") economic.wait_settlement(node, 1) balance_settlement_2 = node.eth.getBalance(staking_address) log.info("The balance after the withdrawal of the fourth cycle {}".format( balance_settlement_2)) """Calculate block reward + pledge reward""" log.info("The following is the number of blocks to get the node") 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 before_create_balance + reward_sum + lockup_amount - balance_settlement_2 < Web3.toWei( 1, "ether" ), "After the expected result unlock period, the money has been refunded + the block reward + pledge reward"
def voting_version_proposal_verifier_pip(client_verifier): pip = client_verifier.pip if pip.chain_version != pip.cfg.version0: log.info('The chain has been upgraded,restart!') client_verifier.economic.env.deploy_all() if pip.is_exist_effective_proposal: if pip.is_exist_effective_proposal_for_vote(): proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('get version proposalinfo : {}'.format(proposalinfo)) if proposalinfo.get( 'EndVotingBlock' ) - pip.node.block_number > pip.economic.consensus_size * 2: return pip client_verifier.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('node {} submit version proposal {}'.format( pip.node.node_id, result)) assert_code(result, 0) return pip
def test_RV_019(staking_client): """ Modify the wallet address, the change of address income normal """ client = staking_client node = client.node staking_address = client.staking_address economic = client.economic ben_address, _ = economic.account.generate_account(node.web3) log.info("ben address balance:{}".format(node.eth.getBalance(ben_address))) log.info("Modify node information") msg = client.staking.edit_candidate(staking_address, ben_address) assert_code(msg, 0) log.info("Enter the second billing cycle") economic.wait_settlement(node) block_reward, staking_reward = economic.get_current_year_reward(node) msg = client.staking.withdrew_staking(staking_address) assert_code(msg, 0) balance_before = node.eth.getBalance(ben_address) log.info( "Exit the new wallet balance after pledge:{}".format(balance_before)) log.info("Enter the third billing cycle") economic.wait_settlement(node, 2) balance_after = node.eth.getBalance(ben_address) log.info( "Balance after the new wallet unlock period {}".format(balance_after)) """Compute Block Reward + Pledge Reward""" log.info("The following is the number of blocks to get the node") 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_after == reward_sum, "Expected new wallet balance == earnings reward"
def test_VO_TER_001_003_005(self, proposal_voted_ca_pipobj_list, client_verifier_obj_list): pip_obj = proposal_voted_ca_pipobj_list[0] proposalinfo_version = client_verifier_obj_list[0].pip.get_effect_proposal_info_of_vote() log.info('Get proposal information :{}'.format(proposalinfo_version)) pip_obj_test = client_verifier_obj_list[0].pip result = pip_obj_test.submitCancel(pip_obj_test.node.node_id, str(time.time()), 1, proposalinfo_version.get('ProposalID'), pip_obj_test.node.staking_address, transaction_cfg=pip_obj_test.cfg.transaction_cfg) log.info('Submit cancel proposal result : {}'.format(result)) assert_code(result, 0) result = pip_obj_test.submitText(pip_obj_test.node.node_id, str(time.time()), pip_obj_test.node.staking_address, transaction_cfg=pip_obj_test.cfg.transaction_cfg) log.info('Submit text proposal result : {}'.format(result)) assert_code(result, 0) result = version_proposal_vote(pip_obj) log.info('Candidate node {} vote version proposal result : {}'.format(pip_obj.node.node_id, result)) assert_code(result, 302022) result = cancel_proposal_vote(pip_obj) log.info('Candidate node {} vote cancel proposal result : {}'.format(pip_obj.node.node_id, result)) assert_code(result, 302022) result = text_proposal_vote(pip_obj) log.info('Candidate node {} vote text proposal result : {}'.format(pip_obj.node.node_id, result)) assert_code(result, 302022)
def test_VP_GA_001(self, no_vp_proposal): pip = no_vp_proposal pip_id = str(time.time()) balance_before = self.get_balance(pip) result = pip.submitVersion(pip.node.node_id, pip_id, pip.cfg.version5, 1, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit version proposal result : {}'.format(result)) assert_code(result, 0) balance_after = self.get_balance(pip) data = rlp.encode([ rlp.encode(int(2001)), rlp.encode(bytes.fromhex(pip.node.node_id)), rlp.encode(pip_id), rlp.encode(int(pip.cfg.version5)), rlp.encode(int(1)) ]) gas = get_the_dynamic_parameter_gas_fee(data) log.info('Calculated gas : {}'.format(gas)) assert_code(balance_before - balance_after, (gas + 480000) * pip.cfg.transaction_cfg.get('gasPrice'))
def test_VO_TER_003_VO_TER_007_VO_TER_005_PP_VO_013(self, no_vp_proposal, client_candidate_obj, client_verifier_obj): ca_pip_obj = client_candidate_obj.pip ve_pip_obj = client_verifier_obj.pip submittpandvote([client_verifier_obj], 2) submitvpandvote([client_verifier_obj], votingrounds=1) proposalinfo_version = ve_pip_obj.get_effect_proposal_info_of_vote() log.info('Version proposal information {}'.format(proposalinfo_version)) result = version_proposal_vote(ca_pip_obj) assert_code(result, 302022) result = proposal_vote(ca_pip_obj, proposaltype=ca_pip_obj.cfg.text_proposal) assert_code(result, 302022) wait_block_number(ca_pip_obj.node, proposalinfo_version.get('EndVotingBlock')) submitcppandvote([client_verifier_obj], [2]) result = proposal_vote(ca_pip_obj, proposaltype=ca_pip_obj.cfg.param_proposal) assert_code(result, 302022) result = proposal_vote(ca_pip_obj, proposaltype=ca_pip_obj.cfg.cancel_proposal) assert_code(result, 302022)