def clean_db_all(self): """ Close all nodes and delete the database """ log.info("clean db all node") self.clean_db_nodes(self.get_all_nodes())
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_IN_GG_001(self, client_noconsensus): client_noconsensus.economic.env.deploy_all() genesis = from_dict( data_class=Genesis, data=client_noconsensus.economic.env.genesis_config) pip = client_noconsensus.pip.pip result = pip.getGovernParamValue('slashing', 'slashBlocksReward') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.slashing.slashBlocksReward == int( result.get('Ret')) result = pip.getGovernParamValue('slashing', 'maxEvidenceAge') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.slashing.maxEvidenceAge == int( result.get('Ret')) result = pip.getGovernParamValue('slashing', 'slashFractionDuplicateSign') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.slashing.slashFractionDuplicateSign == int( result.get('Ret')) result = pip.getGovernParamValue('slashing', 'duplicateSignReportReward') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.slashing.duplicateSignReportReward == int( result.get('Ret')) result = pip.getGovernParamValue('slashing', 'zeroProduceFreezeDuration') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.slashing.zeroProduceFreezeDuration == int( result.get('Ret')) result = pip.getGovernParamValue('staking', 'stakeThreshold') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.staking.stakeThreshold == int( result.get('Ret')) result = pip.getGovernParamValue('staking', 'operatingThreshold') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.staking.operatingThreshold == int( result.get('Ret')) result = pip.getGovernParamValue('staking', 'unStakeFreezeDuration') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.staking.unStakeFreezeDuration == int( result.get('Ret')) result = pip.getGovernParamValue('staking', 'maxValidators') log.info('Interface getGovernParamValue result : {}'.format(result)) assert genesis.economicModel.staking.maxValidators == int( result.get('Ret')) result = pip.getGovernParamValue('block', 'maxBlockGasLimit') log.info('Interface getGovernParamValue result : {}'.format(result)) assert_code(result, 0)
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_AC_IN_001_002_004_to_006_012_to_014(self, new_genesis_env, clients_consensus): # genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) # genesis.economicModel.slashing.maxEvidenceAge = 1 # new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() pip = clients_consensus[-1].pip result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 12, 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() log.info('Get version proposal information : {}'.format( proposalinfo_version)) result = pip.submitCancel(pip.node.node_id, str(time.time()), 10, 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_version)) for index in range(3): log.info(f'index == {index}') client = clients_consensus[index] result = version_proposal_vote(client.pip) assert_code(result, 0) result = client.pip.vote(client.node.node_id, proposalinfo_cancel.get('ProposalID'), index + 1, client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node {} vote cancel proposal result : {}'.format( client.node.node_id, result)) assert_code(result, 0) log.info(f'blocknumber0000 == {pip.node.block_number}') log.info(f'getCandidateList == {pip.node.ppos.getCandidateList()}') assert pip.get_accuverifiers_count( proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0] assert pip.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] log.info('Stop the node {}'.format(clients_consensus[0].node.node_id)) clients_consensus[0].node.stop() pip.economic.wait_consensus(pip.node, 2) log.info(pip.node.debug.getWaitSlashingNodeList()) log.info(pip.pip.listGovernParam()) log.info(clients_consensus[1].ppos.getCandidateInfo( pip.node.node_id, pip.node.staking_address)) assert pip.get_accuverifiers_count( proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0] assert pip.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] log.info(f'blocknumber1111 == {pip.node.block_number}') report_information = mock_duplicate_sign( 1, clients_consensus[1].node.nodekey, clients_consensus[1].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 1, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) log.info(f'blocknumber2222 == {pip.node.block_number}') assert pip.get_accuverifiers_count( proposalinfo_version.get('ProposalID')) == [4, 2, 0, 0] assert pip.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 1] report_information = mock_duplicate_sign( 2, clients_consensus[2].node.nodekey, clients_consensus[2].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 2, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) assert pip.get_accuverifiers_count( proposalinfo_version.get('ProposalID')) == [4, 1, 0, 0] assert pip.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 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_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 upload_file(self, local_file, remote_file): if local_file and os.path.exists(local_file): self.sftp.put(local_file, remote_file) else: log.info("file: {} not found".format(local_file))
def test_POP_010_011(client_consensus, client_new_node): """ (hesitation period, lockup period) free amount initiate revocation entrustment :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ client_consensus.economic.env.deploy_all() address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) address_delegate_1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address1, address1) assert_code(result, 0) delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(40, "ether") log.info("Entrust the sum{}".format(delegate_amount)) result = client_new_node.delegate.delegate(0, address_delegate_1, amount=delegate_amount) assert_code(result, 0) amount1_before = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount1_before)) parameters_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(10, "ether") block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", str(parameters_amount)) log.info("The value of the proposal parameters{}".format(parameters_amount)) wait_block_number(client_new_node.node, block) log.info("The delegate is initiated after the parameter takes effect") address_delegate_2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.delegate.delegate(0, address_delegate_2, amount=delegate_amount) assert_code(result, 0) amount2_before = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount2_before)) msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) staking_blocknum = msg["Ret"]["StakingBlockNum"] withdrew_delegate_amount = delegate_amount - parameters_amount + client_consensus.node.web3.toWei(1, "ether") result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_1, amount=withdrew_delegate_amount) assert_code(result, 0) amount1_after = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount1_after)) assert amount1_before - amount1_after < client_new_node.node.web3.toWei(1, "ether") result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_2, amount=withdrew_delegate_amount) assert_code(result, 0) amount2_after = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount2_after)) assert amount1_before - amount1_after < client_new_node.node.web3.toWei(1, "ether")
def param_governance_verify(client_obj, module, name, newvalue, effectiveflag=True): """ effectiveflag indicates whether it takes effect """ 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)) wait_block_number(pip_obj.node, proposalinfo.get('EndVotingBlock')) if effectiveflag: assert pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')) == 2 log.info("blockNumber {}, the {} has become {}".format(proposalinfo.get('EndVotingBlock'), name, newvalue)) else: assert pip_obj.get_status_of_proposal(proposalinfo.get('ProposalID')) == 3 log.info("{} retains the original value".format(name))
def test_CH_IN_015(global_test_env): """ View economic model parameters, governance parameters, penalty parameters, and whether the reward parameters are correctly configured parameters """ log.info( "View economic model parameters, governance parameters, penalty parameters, and whether the reward parameters are correctly configured parameters" ) # economic_info = global_test_env.genesis_config['EconomicModel'] if not global_test_env.running: global_test_env.deploy_all() genesis = to_genesis(global_test_env.genesis_config) w3_list = [ one_node.web3 for one_node in global_test_env.consensus_node_list ] for w3 in w3_list: info = w3.debug.economicConfig() assert info['common'][ 'maxEpochMinutes'] == genesis.economicModel.common.maxEpochMinutes assert info['common'][ 'maxConsensusVals'] == genesis.economicModel.common.maxConsensusVals assert info["common"][ "additionalCycleTime"] == genesis.economicModel.common.additionalCycleTime assert info['staking'][ 'stakeThreshold'] == genesis.economicModel.staking.stakeThreshold assert info['staking'][ 'operatingThreshold'] == genesis.economicModel.staking.operatingThreshold assert info['staking'][ 'maxValidators'] == genesis.economicModel.staking.maxValidators # assert info['staking']['hesitateRatio'] == genesis.economicModel.staking.hesitateRatio assert info['staking'][ 'unStakeFreezeDuration'] == genesis.economicModel.staking.unStakeFreezeDuration assert info['slashing'][ 'slashFractionDuplicateSign'] == genesis.economicModel.slashing.slashFractionDuplicateSign assert info['slashing'][ 'duplicateSignReportReward'] == genesis.economicModel.slashing.duplicateSignReportReward assert info['slashing'][ 'slashBlocksReward'] == genesis.economicModel.slashing.slashBlocksReward assert info['slashing'][ 'maxEvidenceAge'] == genesis.economicModel.slashing.maxEvidenceAge assert info['gov'][ 'versionProposalVoteDurationSeconds'] == genesis.economicModel.gov.versionProposalVoteDurationSeconds assert info['gov'][ 'versionProposalSupportRate'] == genesis.economicModel.gov.versionProposalSupportRate assert info['gov'][ 'textProposalVoteDurationSeconds'] == genesis.economicModel.gov.textProposalVoteDurationSeconds assert info['gov'][ 'textProposalVoteRate'] == genesis.economicModel.gov.textProposalVoteRate assert info['gov'][ 'textProposalSupportRate'] == genesis.economicModel.gov.textProposalSupportRate assert info['gov'][ 'cancelProposalVoteRate'] == genesis.economicModel.gov.cancelProposalVoteRate assert info['gov'][ 'cancelProposalSupportRate'] == genesis.economicModel.gov.cancelProposalSupportRate assert info['gov'][ 'paramProposalVoteDurationSeconds'] == genesis.economicModel.gov.paramProposalVoteDurationSeconds assert info['gov'][ 'paramProposalVoteRate'] == genesis.economicModel.gov.paramProposalVoteRate assert info['gov'][ 'paramProposalSupportRate'] == genesis.economicModel.gov.paramProposalSupportRate assert info['reward'][ 'newBlockRate'] == genesis.economicModel.reward.newBlockRate assert info['reward'][ 'platonFoundationYear'] == genesis.economicModel.reward.platONFoundationYear assert w3.toChecksumAddress( info['innerAcc']['platonFundAccount']) == w3.toChecksumAddress( genesis.economicModel.innerAcc.platonFundAccount) assert info['innerAcc'][ 'platonFundBalance'] == genesis.economicModel.innerAcc.platonFundBalance assert w3.toChecksumAddress( info['innerAcc']['cdfAccount']) == w3.toChecksumAddress( genesis.economicModel.innerAcc.cdfAccount) assert info['innerAcc'][ 'cdfBalance'] == genesis.economicModel.innerAcc.cdfBalance
def new_genesis_env(global_test_env): cfg = copy(global_test_env.cfg) yield global_test_env log.info("reset deploy.................") global_test_env.set_cfg(cfg) global_test_env.deploy_all()
def reset_environment(global_test_env): log.info("case execution completed") yield global_test_env.deploy_all()
def reset_env(global_test_env): cfg = copy(global_test_env.cfg) yield log.info("reset deploy.................") global_test_env.cfg = cfg global_test_env.deploy_all()
def test_VO_VE_001_002_VO_CA_001_002_VO_TER_002_VO_TER_004( self, new_genesis_env, clients_consensus, client_noconsensus): pip = clients_consensus[0].pip genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.gov.versionProposalVoteDurationSeconds = 3200 genesis.economicModel.staking.unStakeFreezeDuration = 2 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version5, 20, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit version proposal information : {}'.format(result)) assert_code(result, 0) proposalinfo_version = pip.get_effect_proposal_info_of_vote( pip.cfg.version_proposal) log.info( 'Get param proposal information : {}'.format(proposalinfo_version)) result = pip.submitCancel(pip.node.node_id, str(time.time()), 10, proposalinfo_version.get('ProposalID'), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit cancel proposal information : {}'.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 = clients_consensus[0].staking.withdrew_staking( clients_consensus[0].node.staking_address) log.info('Node {} withdrew staking result {}'.format( clients_consensus[0].node.node_id, result)) assert_code(result, 0) address = clients_consensus[0].node.staking_address result = version_proposal_vote(pip) log.info('node vote version proposal result {}'.format(result)) assert_code(result, 302020) result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) log.info('node vote cancel proposal result {}'.format(result)) assert_code(result, 302020) address_test, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 100000) result = client_noconsensus.pip.vote( client_noconsensus.node.node_id, proposalinfo_version.get('ProposalID'), pip.cfg.vote_option_yeas, address_test, transaction_cfg=pip.cfg.transaction_cfg) log.info('node {} vote param proposal result {}'.format( client_noconsensus.node.node_id, result)) assert_code(result, 302022) result = client_noconsensus.pip.vote( client_noconsensus.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_yeas, address_test, transaction_cfg=pip.cfg.transaction_cfg) log.info('node {} vote cancel proposal result {}'.format( client_noconsensus.node.node_id, result)) assert_code(result, 302022) pip.economic.wait_settlement_blocknum( pip.node, pip.economic.unstaking_freeze_ratio) result = pip.vote(pip.node.node_id, proposalinfo_version.get('ProposalID'), pip.cfg.vote_option_yeas, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Exited node vote version proposal result {}'.format(result)) assert_code(result, 302022) result = pip.vote(pip.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_nays, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Exited node vote cancel proposal result {}'.format(result)) assert_code(result, 302022)
def test_POP_014(client_consensus, client_new_node): """ Parameter not in effect - initiate redemption :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ client_consensus.economic.env.deploy_all() address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) address_delegate_1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address1, address1) assert_code(result, 0) delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(20, "ether") log.info("Amount entrusted{}".format(delegate_amount)) result = client_new_node.delegate.delegate(0, address_delegate_1, amount=delegate_amount) assert_code(result, 0) amount1_before = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount1_before)) param_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(10, "ether") block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", str(param_amount), effectiveflag=False) wait_block_number(client_new_node.node, block) log.info("The delegate is initiated after the parameter takes effect") address_delegate_2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.delegate.delegate(0, address_delegate_2, amount=delegate_amount) assert_code(result, 0) amount2_before = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount2_before)) msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) staking_blocknum = msg["Ret"]["StakingBlockNum"] withdrew_delegate = delegate_amount - param_amount + client_consensus.node.web3.toWei(1, "ether") result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_1, amount=withdrew_delegate) assert_code(result, 0) amount1_after = client_new_node.node.eth.getBalance(address_delegate_1) log.info("The wallet balance:{}".format(amount1_after)) amount1_dill = amount1_after - amount1_before assert withdrew_delegate - amount1_dill < client_new_node.node.web3.toWei(1, "ether") result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate_2, amount=withdrew_delegate) assert_code(result, 0) amount2_after = client_new_node.node.eth.getBalance(address_delegate_2) log.info("The wallet balance:{}".format(amount2_after)) amount1_dill = amount2_after - amount2_before assert withdrew_delegate - amount1_dill < client_new_node.node.web3.toWei(1, "ether")
def test_VO_TER_001_003_005(self, candidate_has_proposal, client_verifier): pip = candidate_has_proposal pip_test = client_verifier.pip proposalinfo_version = pip_test.get_effect_proposal_info_of_vote() log.info('Get proposal information :{}'.format(proposalinfo_version)) result = pip_test.submitCancel( pip_test.node.node_id, str(time.time()), 1, proposalinfo_version.get('ProposalID'), pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) log.info('Submit cancel proposal result : {}'.format(result)) assert_code(result, 0) result = pip_test.submitText( pip_test.node.node_id, str(time.time()), pip_test.node.staking_address, transaction_cfg=pip_test.cfg.transaction_cfg) log.info('Submit text proposal result : {}'.format(result)) assert_code(result, 0) result = version_proposal_vote(pip) log.info('Candidate node {} vote version proposal result : {}'.format( pip.node.node_id, result)) assert_code(result, 302022) result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) log.info('Candidate node {} vote cancel proposal result : {}'.format( pip.node.node_id, result)) assert_code(result, 302022) result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) log.info('Candidate node {} vote text proposal result : {}'.format( pip.node.node_id, result)) assert_code(result, 302022)
def version_proposal_vote(pip, vote_option=None): proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Version proposalinfo: {}'.format(proposalinfo)) if not proposalinfo: raise Exception('there is no voting version proposal') if proposalinfo.get('NewVersion') == pip.cfg.version5: upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN) log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version5)) elif proposalinfo.get('NewVersion') == pip.cfg.version8: upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN8) log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version8)) elif proposalinfo.get('NewVersion') == pip.cfg.version9: upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN9) log.info('Replace the node {} version to {}'.format(pip.node.node_id, pip.cfg.version9)) else: raise Exception('The new version of the proposal is{}'.format(proposalinfo.get('NewVersion'))) pip.node.restart() log.info('Restart the node {}'.format(pip.node.node_id)) if not vote_option: vote_option = pip.cfg.vote_option_yeas result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), vote_option, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('The node {} vote result {}'.format(pip.node.node_id, result)) return result
def test_UV_TR_002_003_009_010(self, new_genesis_env, clients_consensus): new_genesis_env.deploy_all() pip = clients_consensus[0].pip submitvpandvote(clients_consensus[:3]) proposalinfo_version = pip.get_effect_proposal_info_of_vote() log.info('Get version proposal information {}'.format(proposalinfo_version)) wait_block_number(pip.node, proposalinfo_version.get('ActiveBlock')) assert pip.get_status_of_proposal(proposalinfo_version.get('ProposalID')) == 5 assert pip.chain_version == pip.cfg.version5 assert pip.get_accuverifiers_count(proposalinfo_version.get('ProposalID')) result = pip.submitVersion(pip.node.node_id, str(time.time()), 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() log.info('Get version proposal information : {}'.format(proposalinfo_version)) result = pip.submitCancel(pip.node.node_id, str(time.time()), 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 version proposal information : {}'.format(proposalinfo_cancel)) upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN8) pip.node.restart() result = pip.vote(pip.node.node_id, proposalinfo_version.get('ProposalID'), pip.cfg.vote_option_yeas, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Vote result : {}'.format(result)) assert_code(result, 0) result = pip.vote(pip.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_yeas, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) assert_code(result, 0) log.info('Node {} vote result : {}'.format(pip.node.node_id, result))
def test_UP_FV_009(clients_new_node): """ 锁仓账号申请质押,验证人违规被扣除节点自有质押金k :param clients_new_node: :return: """ client1 = clients_new_node[0] client2 = clients_new_node[1] economic = client1.economic node = client1.node print(node.node_mark) # create restricting plan and staking restricting_balance = node.eth.getBalance(node.ppos.restrictingAddress) staking_balance = node.eth.getBalance(node.ppos.stakingAddress) address1 = restricting_plan_validation_staking(client1, economic, node) # Waiting for the end of the settlement period time.sleep(2) restricting_balance1 = node.eth.getBalance(node.ppos.restrictingAddress) staking_balance1 = node.eth.getBalance(node.ppos.stakingAddress) assert restricting_balance == restricting_balance1 assert staking_balance + economic.create_staking_limit == staking_balance1 economic.wait_settlement(node) # Obtain block bonus and pledge bonus balance = client2.node.eth.getBalance(address1) print(balance) block_reward, staking_reward = client1.economic.get_current_year_reward( node) # Get penalty blocks slash_blocks = get_governable_parameter_value(client1, 'slashBlocksReward') # view restricting plan restricting_info = client1.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']) log.info("Current block height: {}".format(client2.node.eth.blockNumber)) # stop node client1.node.stop() # Waiting for a 3 consensus round client2.economic.wait_consensus(client2.node, 3) log.info("Current block height: {}".format(client2.node.eth.blockNumber)) # view verifier list verifier_list = client2.ppos.getVerifierList() log.info("verifier_list: {}".format(verifier_list)) punishment_amonut = int( Decimal(str(block_reward)) * Decimal(str(slash_blocks))) log.info("punishment_amonut: {}".format(punishment_amonut)) # view restricting plan again restricting_info = client2.ppos.getRestrictingInfo(address1) log.info("restricting plan informtion: {}".format(restricting_info)) info = restricting_info['Ret'] if punishment_amonut < economic.create_staking_limit: assert info[ 'Pledge'] == economic.create_staking_limit - punishment_amonut else: assert_code(restricting_info, 304005) client2.economic.wait_settlement(client2.node, 3) balance1 = client2.node.eth.getBalance(address1) print(balance1) assert balance == balance1
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 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 = economic.delegate_limit * 100 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(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(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(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_AC_IN_018_to_025(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 pip_test = clients_consensus[-1].pip result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '999', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node submit param proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo_param = pip.get_effect_proposal_info_of_vote( pip.cfg.param_proposal) log.info( 'Get param proposal information : {}'.format(proposalinfo_param)) result = pip.submitCancel(pip.node.node_id, str(time.time()), 3, proposalinfo_param.get('ProposalID'), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node submit cancel proposal result : {}'.format(result)) proposalinfo_cancel = pip.get_effect_proposal_info_of_vote( pip.cfg.cancel_proposal) log.info( 'Get cancel proposal information : {}'.format(proposalinfo_cancel)) for index in range(3): client = clients_consensus[index] result = client.pip.vote(client.node.node_id, proposalinfo_param.get('ProposalID'), index + 1, client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node {} vote param proposal result : {}'.format( client.node.node_id, result)) assert_code(result, 0) result = client.pip.vote(client.node.node_id, proposalinfo_cancel.get('ProposalID'), index + 1, client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Node {} vote cancel proposal result : {}'.format( client.node.node_id, result)) assert_code(result, 0) assert pip.get_accuverifiers_count( proposalinfo_param.get('ProposalID')) == [4, 1, 1, 1] assert pip.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] log.info('Stop the node {}'.format(pip.node.node_id)) pip.node.stop() pip_test.economic.wait_consensus(pip_test.node, 2) assert pip_test.get_accuverifiers_count( proposalinfo_param.get('ProposalID')) == [4, 1, 1, 1] assert pip_test.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1] report_information = mock_duplicate_sign( 1, clients_consensus[1].node.nodekey, clients_consensus[1].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip_test.economic.account.generate_account( pip_test.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 1, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) time.sleep(2) assert pip_test.get_accuverifiers_count( proposalinfo_param.get('ProposalID')) == [4, 1, 0, 1] assert pip_test.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 1] report_information = mock_duplicate_sign( 2, clients_consensus[2].node.nodekey, clients_consensus[2].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip_test.economic.account.generate_account( pip_test.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 2, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) assert pip_test.get_accuverifiers_count( proposalinfo_param.get('ProposalID')) == [4, 1, 0, 0] assert pip_test.get_accuverifiers_count( proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 0]
def test_CMD_005(account_env): node, env = account_env returnList = run_ssh_cmd(node.ssh, "{} account update {} --datadir {}".format(node.remote_bin_file, env.remote_account_address, node.remote_data_dir), "88888888", "88888888", "88888888") log.info(f'returnList is {returnList}') assert len(returnList) == 6 assert returnList[5].strip() == "Repeat passphrase:"
def test_AC_IN_003_008_010(self, new_genesis_env, clients_consensus): genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.gov.textProposalVoteDurationSeconds = 120 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() pip = clients_consensus[-1].pip submittpandvote(clients_consensus, 1, 2, 3, 1) proposalinfo = pip.get_effect_proposal_info_of_vote( pip.cfg.text_proposal) log.info('Get text proposal information : {}'.format(proposalinfo)) assert pip.get_accuverifiers_count( proposalinfo.get('ProposalID')) == [4, 2, 1, 1] log.info('Stop the node {}'.format(clients_consensus[0].node.node_id)) clients_consensus[0].node.stop() pip.economic.wait_consensus(pip.node, 2) assert pip.get_accuverifiers_count( proposalinfo.get('ProposalID')) == [4, 2, 1, 1] report_information = mock_duplicate_sign( 1, clients_consensus[1].node.nodekey, clients_consensus[1].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 1, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) assert pip.get_accuverifiers_count( proposalinfo.get('ProposalID')) == [4, 2, 0, 1] report_information = mock_duplicate_sign( 2, clients_consensus[2].node.nodekey, clients_consensus[2].node.blsprikey, 41) log.info("Report information: {}".format(report_information)) address, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 1000) result = clients_consensus[-1].duplicatesign.reportDuplicateSign( 2, report_information, address) log.info('Node duplicate block result : {}'.format(result)) assert_code(result, 0) assert pip.get_accuverifiers_count( proposalinfo.get('ProposalID')) == [4, 2, 0, 0]
def test_VO_VO_001_V0_RE_001_V0_WA_001_V_STA_1_VO_OP_001_VO_OP_002( no_vp_proposal): pip = no_vp_proposal result = pip.submitVersion(pip.node.node_id, str(time.time()), pip.cfg.version8, 2, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit version proposal result : {}'.format(result)) assert_code(result, 0) proposalinfo = pip.get_effect_proposal_info_of_vote() log.info('Get version proposalinfo {}'.format(proposalinfo)) upload_platon(pip.node, pip.cfg.PLATON_NEW_BIN) log.info('Replace the node platon package to {}'.format(pip.cfg.version5)) pip.node.restart() log.info('Restart the node {}'.format(pip.node.node_id)) 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 = 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('vote option {} result {}'.format(pip.cfg.vote_option_nays, result)) assert_code(result, 302002) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), pip.cfg.vote_option_Abstentions, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('vote option {} result {}'.format(pip.cfg.vote_option_Abstentions, result)) assert_code(result, 302002) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), 0, pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('vote option {} result {}'.format(0, result)) assert_code(result, 302002) result = pip.vote(pip.node.node_id, proposalinfo.get('ProposalID'), 'a', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('vote option {} result {}'.format(pip.cfg.vote_option_nays, result)) assert_code(result, 302002) 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) assert_code(result, 302021) node_version = verifier_node_version(pip) result = version_proposal_vote(pip) assert_code(result, 0) verifier_node_version(pip, node_version) 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('vote duplicated result: {}'.format(result)) assert_code(result, 302027) wait_block_number(pip.node, proposalinfo.get('EndVotingBlock')) 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('endblock vote result: {}'.format(result)) assert_code(result, 302026)
def test_IN_LG_005(self, client_noconsensus): result = client_noconsensus.pip.pip.listGovernParam('txpool') log.info('Interface listGovernParam result {}'.format(result)) assert_code(result, 2) assert result.get('Ret') == "Object not found"
def test_VO_TE_001_002_PP_VO_009_010_PP_VO_011_012_PP_VO_014_VO_TER_008_VO_TER_006( self, new_genesis_env, clients_consensus, client_noconsensus): genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.gov.paramProposalVoteDurationSeconds = 640 genesis.economicModel.staking.unStakeFreezeDuration = 2 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() pip = clients_consensus[0].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 information : {}'.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 = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '123', pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit param proposal information : {}'.format(result)) assert_code(result, 0) proposalinfo_param = pip.get_effect_proposal_info_of_vote( pip.cfg.param_proposal) log.info( 'Get param proposal information : {}'.format(proposalinfo_param)) result = pip.submitCancel(pip.node.node_id, str(time.time()), 10, proposalinfo_param.get('ProposalID'), pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Submit cancel proposal information : {}'.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 = clients_consensus[0].staking.withdrew_staking( clients_consensus[0].node.staking_address) log.info('Node {} withdrew staking result {}'.format( clients_consensus[0].node.node_id, result)) assert_code(result, 0) address = clients_consensus[0].node.staking_address result = proposal_vote(pip, proposaltype=pip.cfg.text_proposal) log.info('node vote text proposal result {}'.format(result)) assert_code(result, 302020) result = proposal_vote(pip) log.info('node vote param proposal result {}'.format(result)) assert_code(result, 302020) result = proposal_vote(pip, proposaltype=pip.cfg.cancel_proposal) log.info('node vote cancel proposal result {}'.format(result)) assert_code(result, 302020) address_test, _ = pip.economic.account.generate_account( pip.node.web3, 10**18 * 10000) result = client_noconsensus.pip.vote( client_noconsensus.node.node_id, proposalinfo_text.get('ProposalID'), pip.cfg.vote_option_yeas, address_test, transaction_cfg=pip.cfg.transaction_cfg) log.info('node {} vote text proposal result {}'.format( client_noconsensus.node.node_id, result)) assert_code(result, 302022) result = client_noconsensus.pip.vote( client_noconsensus.node.node_id, proposalinfo_param.get('ProposalID'), pip.cfg.vote_option_yeas, address_test, transaction_cfg=pip.cfg.transaction_cfg) log.info('node {} vote param proposal result {}'.format( client_noconsensus.node.node_id, result)) assert_code(result, 302022) result = client_noconsensus.pip.vote( client_noconsensus.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_yeas, address_test, transaction_cfg=pip.cfg.transaction_cfg) log.info('node {} vote cancel proposal result {}'.format( client_noconsensus.node.node_id, result)) assert_code(result, 302022) pip.economic.wait_settlement_blocknum( pip.node, pip.economic.unstaking_freeze_ratio) result = pip.vote(pip.node.node_id, proposalinfo_text.get('ProposalID'), pip.cfg.vote_option_nays, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Exited node vote text proposal result {}'.format(result)) assert_code(result, 302022) result = pip.vote(pip.node.node_id, proposalinfo_param.get('ProposalID'), pip.cfg.vote_option_nays, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Exited node vote param proposal result {}'.format(result)) assert_code(result, 302022) result = pip.vote(pip.node.node_id, proposalinfo_cancel.get('ProposalID'), pip.cfg.vote_option_nays, address, transaction_cfg=pip.cfg.transaction_cfg) log.info('Exited node vote cancel proposal result {}'.format(result)) assert_code(result, 302022)
def test_LP_IN_001_002(self, no_vp_proposal): pip = no_vp_proposal pip_id = str(time.time()) result = pip.submitParam(pip.node.node_id, pip_id, 'slashing', 'slashBlocksReward', '456', 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('Get param proposal information : {}'.format(proposalinfo)) assert proposalinfo.get('Proposer') == pip.node.node_id assert proposalinfo.get('ProposalType') == pip.cfg.param_proposal log.info('{}'.format(pip.economic.pp_vote_settlement_wheel)) calculated_endvotingblock = math.ceil( proposalinfo.get('SubmitBlock') / pip.economic.settlement_size + pip.economic.pp_vote_settlement_wheel ) * pip.economic.settlement_size assert proposalinfo.get('EndVotingBlock') == calculated_endvotingblock pip_id = str(time.time()) result = pip.submitCancel(pip.node.node_id, pip_id, 1, proposalinfo.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)) assert proposalinfo_cancel.get('Proposer') == pip.node.node_id assert proposalinfo_cancel.get( 'ProposalType') == pip.cfg.cancel_proposal log.info('{}'.format(pip.economic.pp_vote_settlement_wheel)) calculated_endvotingblock = math.ceil( proposalinfo_cancel.get('SubmitBlock') / pip.economic.consensus_size + 1) * pip.economic.consensus_size - 20 assert proposalinfo_cancel.get( 'EndVotingBlock') == calculated_endvotingblock
def clean_all(self): """ Close all nodes and delete the directory of the deployment node """ log.info("clean all node") self.clean_nodes(self.get_all_nodes())