def test_PIP_PVF_017(client_con_list_obj, reset_environment): """ 治理修改区块双签-举报奖励比例处于未生效期 :param client_con_list_obj: :param reset_environment: :return: """ # get pledge_amount1 report_amount1 incentive_pool_account1 report_reward1 pledge_amount1, report_reward1 = information_before_report_reward(client_con_list_obj[0]) # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'slashing', 'duplicateSignReportReward', '60') # view Parameter value after treatment report_reward2 = get_governable_parameter_value(client_con_list_obj[0], 'duplicateSignReportReward') assert report_reward1 == report_reward2, "ErrMsg:Parameter value after treatment {}".format(report_reward2) # wait consensus block client_con_list_obj[0].economic.wait_consensus_blocknum(client_con_list_obj[0].node) # get account amount report_address, report_amount1, incentive_pool_account1 = get_account_amount(client_con_list_obj[0]) # Verify changed parameters current_block = client_con_list_obj[0].node.eth.blockNumber log.info("Current block height: {}".format(current_block)) # Verify changed parameters report duplicate_sign(client_con_list_obj[0], report_address, current_block) # view Pledge amount after punishment proportion_reward, incentive_pool_reward = client_con_list_obj[1].economic.get_report_reward(pledge_amount1) log.info("Whistleblower benefits:{} Incentive pool income:{}".format(proportion_reward, incentive_pool_reward)) # asster account amount asster_income_account_amount(client_con_list_obj[1], report_amount1, incentive_pool_account1, report_address, proportion_reward, incentive_pool_reward)
def test_PIP_PVF_012(client_con_list_obj, reset_environment): """ 治理修改区块双签-最高处罚比例处于未生效期 :param client_con_list_obj: :param reset_environment: :return: """ # view Pledge amount and Parameter value before treatment pledge_amount1, penalty_ratio1 = information_before_penalty_ratio(client_con_list_obj[0]) # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'slashing', 'slashFractionDuplicateSign', '1000') # view Parameter value before treatment again penalty_ratio2 = get_governable_parameter_value(client_con_list_obj[0], 'slashFractionDuplicateSign') assert penalty_ratio1 == penalty_ratio2, "ErrMsg:Parameter value after treatment {}".format(penalty_ratio2) # wait consensus block client_con_list_obj[0].economic.wait_consensus_blocknum(client_con_list_obj[0].node) # create account report_address, _ = client_con_list_obj[0].economic.account.generate_account(client_con_list_obj[0].node.web3, client_con_list_obj[0].node.web3.toWei( 1000, 'ether')) # Verify changed parameters current_block = client_con_list_obj[0].node.eth.blockNumber log.info("Current block height: {}".format(current_block)) # Verify changed parameters report duplicate_sign(client_con_list_obj[0], report_address, current_block) # assret penalty amount assret_penalty_amount(client_con_list_obj, pledge_amount1)
def test_PIP_PVF_007(new_genesis_env, client_con_list_obj): """ 治理修改区块双签-证据有效期处于未生效期 :param new_genesis_env: :param client_con_list_obj: :return: """ # Change configuration parameters adjust_initial_parameters(new_genesis_env) # view Parameter value before treatment slash_blocks1 = get_governable_parameter_value(client_con_list_obj[0], 'maxEvidenceAge') # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'slashing', 'maxEvidenceAge', '1') # view Parameter value before treatment again slash_blocks2 = get_governable_parameter_value(client_con_list_obj[0], 'maxEvidenceAge') assert slash_blocks2 == slash_blocks1, "ErrMsg:Parameter value after treatment {}".format(slash_blocks2) report_address, _ = client_con_list_obj[0].economic.account.generate_account(client_con_list_obj[0].node.web3, client_con_list_obj[0].node.web3.toWei( 1000, 'ether')) # wait consensus block client_con_list_obj[0].economic.wait_consensus_blocknum(client_con_list_obj[0].node) # Verify changed parameters effective_block = client_con_list_obj[0].economic.get_front_settlement_switchpoint(client_con_list_obj[0].node, 2) if effective_block < 41: log.info("Current block: {}".format(client_con_list_obj[0].node.eth.blockNumber)) effective_block = 41 log.info("Effective block height: {}".format(effective_block)) # Report prepareblock signature report_information = mock_duplicate_sign(1, client_con_list_obj[0].node.nodekey, client_con_list_obj[0].node.blsprikey, effective_block) log.info("Report information: {}".format(report_information)) result = client_con_list_obj[0].duplicatesign.reportDuplicateSign(1, report_information, report_address) assert_code(result, 0)
def test_PIP_PVF_016_017(clients_consensus, mark, reset_environment): """ PIP_PVF_016:治理修改区块双签-举报奖励比例投票失败 PIP_PVF_017:治理修改区块双签-举报奖励比例处于未生效期 :param clients_consensus: :param reset_environment: :return: """ first_index = 0 second_index = 1 first_client = clients_consensus[first_index] log.info("Current connection non-consensus first node:{}".format( first_client.node.node_mark)) second_client = clients_consensus[second_index] log.info("Current connection non-consensus second node:{}".format( second_client.node.node_mark)) economic = first_client.economic node = first_client.node change_parameter_value = '60' first_pledge_amount, first_report_reward = information_before_report_reward( first_client) # create Parametric proposal param_governance_verify_before_endblock(first_client, 'slashing', 'duplicateSignReportReward', change_parameter_value, mark) # view Parameter value after treatment second_report_reward = get_governable_parameter_value( first_client, 'duplicateSignReportReward') assert first_report_reward == second_report_reward, "ErrMsg:Parameter value after treatment {}".format( second_report_reward) # wait consensus block economic.wait_consensus_blocknum(node) # get account amount report_address, first_report_amount, first_incentive_pool_account = get_account_amount( first_client) # Verify changed parameters current_block = node.eth.blockNumber log.info("Current block height: {}".format(current_block)) # Verify changed parameters report duplicate_sign(first_client, report_address, current_block) # view Pledge amount after punishment proportion_reward, incentive_pool_reward = economic.get_report_reward( first_pledge_amount) log.info("Whistleblower benefits:{} Incentive pool income:{}".format( proportion_reward, incentive_pool_reward)) # asster account amount asster_income_account_amount(second_client, first_report_amount, first_incentive_pool_account, report_address, proportion_reward, incentive_pool_reward)
def test_PIP_PVF_002(client_con_list_obj, reset_environment): """ 理修改低0出块率扣除验证人自有质押金块数成功处于未生效期 :param client_con_list_obj: :return: """ # get pledge amount1 and block reward pledge_amount1, block_reward, slash_blocks1 = information_before_slash_blocks(client_con_list_obj[0]) # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'slashing', 'slashBlocksReward', '0') # Get governable parameters again slash_blocks2 = get_governable_parameter_value(client_con_list_obj[0], 'slashBlocksReward') assert slash_blocks1 == slash_blocks2, "ErrMsg:slash blocks {}".format(slash_blocks2) # Verify changed parameters Verify_changed_parameters(client_con_list_obj, pledge_amount1, block_reward, slash_blocks1)
def test_PIP_MG_002(client_con_list_obj, reset_environment): """ 治理修改默认每个区块的最大Gas 处于未生效期 :param client_con_list_obj: :param reset_environment: :return: """ # view Parameter value before treatment max_gas_limit1 = get_governable_parameter_value(client_con_list_obj[0], 'maxBlockGasLimit') # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'block', 'maxBlockGasLimit', '4712389') # view Parameter value after treatment max_gas_limit2 = get_governable_parameter_value(client_con_list_obj[0], 'maxBlockGasLimit') assert max_gas_limit2 == max_gas_limit1, "ErrMsg:Parameter value after treatment {}".format(max_gas_limit2)
def test_POP_023(client_consensus, client_new_node, new_genesis_env): """ Return pledge before lock time parameter takes effect :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) unStakeFreezeDuration = 2 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address, address) assert_code(result, 0) log.info("Next settlement period") client_new_node.economic.wait_settlement_blocknum(client_new_node.node) result = client_new_node.staking.withdrew_staking(address) assert_code(result, 0) log.info("Withdraw pledge before parameter takes effect") param = 3 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", str(param)) wait_block_number(client_new_node.node, block) amount1 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount1)) client_new_node.economic.wait_settlement_blocknum(client_new_node.node) amount2 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount2)) staking_amount = client_new_node.economic.create_staking_limit assert amount2 - amount1 == staking_amount
def test_POP_002(client_consensus_obj, client_new_node_obj, new_genesis_env): """ Minimum pledge reduced pledge threshold :param client_consensus_obj: :param client_new_node_obj: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.stakeThreshold = 1500000000000000000000000 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock( client_consensus_obj, "staking", "stakeThreshold", "1000000000000000000000000") log.info(block) wait_block_number(client_new_node_obj.node, block) address, _ = client_new_node_obj.economic.account.generate_account( client_new_node_obj.node.web3, 10**18 * 10000000) result = client_new_node_obj.staking.create_staking( 0, address, address, amount=990000000000000000000000) log.info(result) assert_code(result, 301100) result = client_new_node_obj.staking.create_staking( 0, address, address, amount=1000000000000000000000000) log.info(result) assert_code(result, 0)
def test_POP_022(client_consensus, client_new_node, new_genesis_env): """ Reduced lockup threshold - not in effect :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) unStakeFreezeDuration = 3 genesis.economicModel.staking.unStakeFreezeDuration = unStakeFreezeDuration new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address, address) assert_code(result, 0) param = 2 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", str(param), effectiveflag=False) wait_block_number(client_new_node.node, block) result = client_new_node.staking.withdrew_staking(address) assert_code(result, 0) amount1 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount1)) client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) amount2 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount2)) client_new_node.economic.wait_settlement_blocknum(client_new_node.node) amount3 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount3)) staking_amount = client_new_node.economic.create_staking_limit assert amount3 - amount2 == staking_amount
def test_POP_019(client_consensus, client_new_node, new_genesis_env): """ Increased lock - up threshold :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ new_genesis_env.deploy_all() address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address, address) assert_code(result, 0) param = 3 block = param_governance_verify_before_endblock(client_consensus, "staking", "unStakeFreezeDuration", str(param)) wait_block_number(client_new_node.node, block) result = client_new_node.staking.withdrew_staking(address) assert_code(result, 0) amount1 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount1)) client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) amount2 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount2)) client_new_node.economic.wait_settlement_blocknum(client_new_node.node) amount3 = client_new_node.node.eth.getBalance(address) log.info("The wallet balance:{}".format(amount3)) staking_amount = client_new_node.economic.create_staking_limit assert amount3 - amount2 == staking_amount
def test_POP_017(client_consensus, clients_noconsensus, new_genesis_env): """ Increase the number of node candidates - not active :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.maxValidators = 5 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() param = 6 block = param_governance_verify_before_endblock(client_consensus, "staking", "maxValidators", str(param), effectiveflag=False) client1 = clients_noconsensus[0] client2 = clients_noconsensus[1] wait_block_number(client2.node, block) address, _ = client1.economic.account.generate_account(client1.node.web3, 10 ** 18 * 10000000) staking_amount = client1.economic.create_staking_limit result = client1.staking.create_staking(0, address, address, amount=staking_amount * 2) assert_code(result, 0) address1, _ = client2.economic.account.generate_account(client2.node.web3, 10 ** 18 * 10000000) result = client2.staking.create_staking(0, address1, address1, amount=staking_amount * 3) assert_code(result, 0) client2.economic.wait_settlement_blocknum(client2.node) getVerifierList = get_pledge_list(client2.node.ppos.getVerifierList) log.info(getVerifierList) assert len(getVerifierList) == 5
def test_POP_002(client_consensus, client_new_node, new_genesis_env): """ Minimum pledge reduced pledge threshold :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ old_amount = client_consensus.economic.create_staking_limit + client_consensus.node.web3.toWei(2, "ether") new_amount = client_consensus.economic.create_staking_limit + client_consensus.node.web3.toWei(1, "ether") genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.stakeThreshold = old_amount new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", str(new_amount)) log.info(block) wait_block_number(client_new_node.node, block) address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address, address, amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) log.info(result) assert_code(result, 301100) result = client_new_node.staking.create_staking(0, address, address, amount=new_amount) log.info(result) assert_code(result, 0)
def test_POP_016(client_consensus_obj, client_noc_list_obj, new_genesis_env): """ Reduce the number of alternative nodes :param client_consensus_obj: :param client_new_node_obj: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.maxValidators = 6 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock(client_consensus_obj, "staking", "maxValidators", "5") wait_block_number(client_noc_list_obj[1].node, block) address, _ = 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, address, address, amount=1600000000000000000000000) assert_code(result, 0) address1, _ = client_noc_list_obj[1].economic.account.generate_account( client_noc_list_obj[1].node.web3, 10**18 * 10000000) result = client_noc_list_obj[1].staking.create_staking( 0, address1, address1, amount=1700000000000000000000000) assert_code(result, 0) client_noc_list_obj[1].economic.wait_settlement_blocknum( client_noc_list_obj[1].node) getVerifierList = get_pledge_list( client_noc_list_obj[1].node.ppos.getVerifierList) log.info(getVerifierList) assert len(getVerifierList) == 5
def test_POP_013(client_consensus, client_new_node, new_genesis_env): """ :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) old_amount = client_consensus.economic.delegate_limit * 2 new_amount = client_consensus.economic.delegate_limit genesis.economicModel.staking.operatingThreshold = old_amount new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", str(new_amount), effectiveflag=False) log.info(block) address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) wait_block_number(client_new_node.node, block) result = client_new_node.staking.create_staking(0, address1, address1) assert_code(result, 0) address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.delegate.delegate(0, address2, amount=new_amount) log.info(result) assert_code(result, 301105) result = client_new_node.delegate.delegate(0, address2, amount=old_amount) assert_code(result, 0) result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) assert_code(result, 301104) result = client_new_node.staking.increase_staking(0, address1, amount=old_amount) assert_code(result, 0)
def test_POP_006(client_consensus, client_new_node): """ (hesitation period) increase - entrustment overweight threshold :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ client_consensus.economic.env.deploy_all() old_amount = client_consensus.economic.delegate_limit new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", str(new_amount)) log.info(block) address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) wait_block_number(client_new_node.node, block) result = client_new_node.staking.create_staking(0, address1, address1) assert_code(result, 0) address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.delegate.delegate(0, address2, amount=old_amount) assert_code(result, 301105) result = client_new_node.delegate.delegate(0, address2, amount=new_amount) assert_code(result, 0) result = client_new_node.staking.increase_staking(0, address1, amount=old_amount) assert_code(result, 301104) result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) assert_code(result, 0)
def test_POP_005(client_consensus_obj, client_new_node_obj, new_genesis_env): """ The amendment of the threshold of pledge shall not take effect :param client_consensus_obj: :param get_generate_account: :param client_new_node_obj: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.stakeThreshold = 1000000000000000000000000 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock( client_consensus_obj, "staking", "stakeThreshold", "1500000000000000000000000", effectiveflag=False) log.info(block) address, _ = client_new_node_obj.economic.account.generate_account( client_new_node_obj.node.web3, 10**18 * 10000000) wait_block_number(client_new_node_obj.node, block) result = client_new_node_obj.staking.create_staking( 0, address, address, amount=1000000000000000000000000) assert_code(result, 0)
def test_POP_001_003(client_consensus, client_new_node): """ Increase the threshold of pledge :param client_consensus: :param get_generate_account: :param client_new_node: :return: """ client_consensus.economic.env.deploy_all() old_amount = client_consensus.economic.create_staking_limit new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", str(new_amount)) log.info(block) address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) wait_block_number(client_new_node.node, block) result = client_new_node.staking.create_staking(0, address, address, amount=old_amount) log.info(result) assert_code(result, 301100) result = client_new_node.staking.create_staking(0, address, address, amount=new_amount) log.info(result) assert_code(result, 0) verifier_list = get_pledge_list(client_new_node.ppos.getVerifierList) log.info(verifier_list) client_new_node.economic.wait_settlement_blocknum(client_new_node.node) verifier_list = get_pledge_list(client_new_node.ppos.getVerifierList) assert client_new_node.node.node_id in verifier_list
def test_PIP_MG_001_002(client_consensus, mark, reset_environment): """ PIP_MG_001:治理修改默认每个区块的最大Gas 投票失败 PIP_MG_002:治理修改默认每个区块的最大Gas 处于未生效期 :param client_consensus: :param reset_environment: :return: """ first_client = client_consensus log.info("Current connection non-consensus first node:{}".format( first_client.node.node_mark)) node = first_client.node # view Parameter value before treatment first_max_gas_limit = get_governable_parameter_value( first_client, 'maxBlockGasLimit') # create Parametric proposal block = param_governance_verify_before_endblock(first_client, 'block', 'maxBlockGasLimit', '4712389', mark) # view Parameter value after treatment second_max_gas_limit = get_governable_parameter_value( first_client, 'maxBlockGasLimit') # wait block wait_block_number(node, block) assert second_max_gas_limit == first_max_gas_limit, "ErrMsg:Parameter value after treatment {}".format( second_max_gas_limit)
def test_POP_001_003(client_consensus_obj, client_new_node_obj): """ Increase the threshold of pledge :param client_consensus_obj: :param get_generate_account: :param client_new_node_obj: :return: """ client_consensus_obj.economic.env.deploy_all() block = param_governance_verify_before_endblock( client_consensus_obj, "staking", "stakeThreshold", "1800000000000000000000000") log.info(block) address, _ = client_new_node_obj.economic.account.generate_account( client_new_node_obj.node.web3, 10**18 * 10000000) wait_block_number(client_new_node_obj.node, block) result = client_new_node_obj.staking.create_staking( 0, address, address, amount=179000000000000000000000) log.info(result) assert_code(result, 301100) result = client_new_node_obj.staking.create_staking( 0, address, address, amount=1800000000000000000000000) log.info(result) assert_code(result, 0) verifier_list = get_pledge_list(client_new_node_obj.ppos.getVerifierList) log.info(verifier_list) client_new_node_obj.economic.wait_settlement_blocknum( client_new_node_obj.node) verifier_list = get_pledge_list(client_new_node_obj.ppos.getVerifierList) assert client_new_node_obj.node.node_id in verifier_list
def test_PIP_MG_001(client_con_list_obj, reset_environment): """ 治理修改默认每个区块的最大Gas 投票失败 :param client_con_list_obj: :param reset_environment: :return: """ # # Change configuration parameters # genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) # genesis.config.cbft.period = 50000 # genesis.EconomicModel.Common.MaxEpochMinutes = 14 # genesis.EconomicModel.Common.AdditionalCycleTime = 55 # new_file = new_genesis_env.cfg.env_tmp + "/genesis.json" # genesis.to_file(new_file) # new_genesis_env.deploy_all(new_file) # client_con_list_obj[0].economic.env.deploy_all() # view Parameter value before treatment max_gas_limit1 = get_governable_parameter_value(client_con_list_obj[0], 'maxBlockGasLimit') # create Parametric proposal block = param_governance_verify_before_endblock(client_con_list_obj[0], 'block', 'maxBlockGasLimit', '4712389', False) # view Parameter value after treatment max_gas_limit2 = get_governable_parameter_value(client_con_list_obj[0], 'maxBlockGasLimit') # wait block wait_block_number(client_con_list_obj[0].node, block) assert max_gas_limit2 == max_gas_limit1, "ErrMsg:Parameter value after treatment {}".format(max_gas_limit2)
def test_PIP_PVF_001(client_con_list_obj, reset_environment): """ 治理修改低0出块率扣除验证人自有质押金块数投票失败 :param client_con_list_obj: :return: """ # Initialize environment client_con_list_obj[0].economic.env.deploy_all() time.sleep(3) # get pledge amount1 and block reward pledge_amount1, block_reward, slash_blocks1 = information_before_slash_blocks(client_con_list_obj[0]) # create Parametric proposal param_governance_verify_before_endblock(client_con_list_obj[0], 'slashing', 'slashBlocksReward', '0', False) # Get governable parameters again slash_blocks2 = get_governable_parameter_value(client_con_list_obj[0], 'slashBlocksReward') assert slash_blocks1 == slash_blocks2, "ErrMsg:slash blocks {}".format(slash_blocks2) # Verify changed parameters Verify_changed_parameters(client_con_list_obj, pledge_amount1, block_reward, slash_blocks1)
def test_POP_012(client_consensus, client_new_node): """ :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ client_consensus.economic.env.deploy_all() address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.staking.create_staking(0, address, address) assert_code(result, 0) address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) delegate_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(20, "ether") log.info("Own funds to initiate the commission") result = client_new_node.delegate.delegate(0, address_delegate, amount=delegate_amount) assert_code(result, 0) 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)) wait_block_number(client_new_node.node, block) plan = [{'Epoch': 1, 'Amount': delegate_amount}] result = client_new_node.restricting.createRestrictingPlan(address_delegate, plan, address_delegate) assert_code(result, 0) log.info("Fund of lockup is initiated and entrusted") result = client_new_node.delegate.delegate(1, address_delegate, amount=delegate_amount) assert_code(result, 0) amount_before = client_new_node.node.eth.getBalance(address_delegate) log.info("The wallet balance:{}".format(amount_before)) msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) staking_blocknum = msg["Ret"]["StakingBlockNum"] withdrew_delegate = delegate_amount * 2 - parameters_amount + \ client_consensus.node.web3.toWei(1, "ether") result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate, amount=withdrew_delegate) assert_code(result, 0) amount1_after = client_new_node.node.eth.getBalance(address_delegate) log.info("The wallet balance:{}".format(amount1_after)) amount_dill = amount1_after - amount_before assert delegate_amount - amount_dill < client_new_node.node.web3.toWei(1, "ether") client_new_node.economic.wait_settlement_blocknum(client_new_node.node) amount1_last = client_new_node.node.eth.getBalance(address_delegate) log.info("The wallet balance:{}".format(amount1_last)) assert amount1_last - amount1_after == delegate_amount assert delegate_amount * 2 - (amount1_last - amount_before) < client_new_node.node.web3.toWei(1, "ether")
def test_PIP_PVF_006_007(new_genesis_env, mark): """ 治理修改区块双签-证据有效期投票失败 :param new_genesis_env: :return: """ # Change configuration parameters adjust_initial_parameters(new_genesis_env) first_client = get_client_consensus(new_genesis_env, staking_cfg) log.info("Current connection non-consensus node:{}".format( first_client.node.node_mark)) economic = first_client.economic node = first_client.node # view Parameter value before treatment first_slash_blocks = get_governable_parameter_value( first_client, 'maxEvidenceAge') # create Parametric proposal param_governance_verify_before_endblock(first_client, 'slashing', 'maxEvidenceAge', '1', mark) # view Parameter value before treatment again second_slash_blocks = get_governable_parameter_value( first_client, 'maxEvidenceAge') assert second_slash_blocks == first_slash_blocks, "ErrMsg:Parameter value after treatment {}".format( second_slash_blocks) report_address, _ = first_client.economic.account.generate_account( node.web3, node.web3.toWei(1000, 'ether')) # wait consensus block economic.wait_consensus_blocknum(node) # Verify changed parameters effective_block = economic.get_front_settlement_switchpoint(node, 2) if effective_block < economic.consensus_size: log.info("Current block: {}".format(node.eth.blockNumber)) effective_block = economic.consensus_size + 1 log.info("Effective block height: {}".format(effective_block)) # Report prepareblock signature report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey, effective_block) log.info("Report information: {}".format(report_information)) result = first_client.duplicatesign.reportDuplicateSign( 1, report_information, report_address) assert_code(result, 0)
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_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 test_PIP_PVF_011_012(clients_consensus, mark, reset_environment): """ 治理修改区块双签-最高处罚比例投票失败 :param clients_consensus: :param mark: :param reset_environment: :return: """ first_index = 0 first_client = clients_consensus[first_index] log.info("Current connection non-consensus node:{}".format( first_client.node.node_mark)) economic = first_client.economic node = first_client.node change_parameter_value = '1000' # view Pledge amount and Parameter value before treatment first_pledge_amount, first_penalty_ratio = information_before_penalty_ratio( first_client) # create Parametric proposal param_governance_verify_before_endblock(first_client, 'slashing', 'slashFractionDuplicateSign', change_parameter_value, mark) # view Parameter value after treatment again second_penalty_ratio = get_governable_parameter_value( first_client, 'slashFractionDuplicateSign') assert second_penalty_ratio == first_penalty_ratio, "ErrMsg:Parameter value after treatment {}".format( second_penalty_ratio) # wait consensus block economic.wait_consensus_blocknum(node) # create account report_address, _ = economic.account.generate_account( node.web3, node.web3.toWei(1000, 'ether')) # Verify changed parameters current_block = node.eth.blockNumber log.info("Current block height: {}".format(current_block)) # Verify changed parameters report duplicate_sign(first_client, report_address, current_block) # assret penalty amount assret_penalty_amount(clients_consensus, first_pledge_amount)
def test_PIP_PVF_001_002(clients_consensus, mark, reset_environment): """ PIP_PVF_001:治理修改低0出块率扣除验证人自有质押金块数投票失败 PIP_PVF_002:理修改低0出块率扣除验证人自有质押金块数成功处于未生效期 :param clients_consensus: :return: """ index = 0 first_client = clients_consensus[index] # get pledge amount1 and block reward first_pledge_amount, block_reward, first_slash_blocks = information_before_slash_blocks( first_client) # create Parametric proposal param_governance_verify_before_endblock(first_client, 'slashing', 'slashBlocksReward', '0', mark) # Get governable parameters again second_slash_blocks = get_governable_parameter_value( first_client, 'slashBlocksReward') assert first_slash_blocks == second_slash_blocks, "ErrMsg:slash blocks {}".format( second_slash_blocks) # Verify changed parameters verify_changed_parameters(clients_consensus, first_pledge_amount, block_reward, first_slash_blocks)
def test_POP_009(client_consensus_obj, client_new_node_obj, new_genesis_env): """ (lockup period) reduce the entrustment increase threshold - test :param client_consensus_obj: :param client_new_node_obj: :param new_genesis_env: :return: """ genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.operatingThreshold = 15000000000000000000 new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock(client_consensus_obj, "staking", "operatingThreshold", "14000000000000000000") log.info(block) address1, _ = client_new_node_obj.economic.account.generate_account( client_new_node_obj.node.web3, 10**18 * 10000000) wait_block_number(client_new_node_obj.node, block) result = client_new_node_obj.staking.create_staking(0, address1, address1) assert_code(result, 0) address2, _ = client_new_node_obj.economic.account.generate_account( client_new_node_obj.node.web3, 10**18 * 10000000) log.info("The next cycle") client_new_node_obj.economic.wait_settlement_blocknum( client_new_node_obj.node) result = client_new_node_obj.delegate.delegate(0, address2, amount=13000000000000000000) assert_code(result, 301105) result = client_new_node_obj.delegate.delegate(0, address2, amount=14000000000000000000) assert_code(result, 0) result = client_new_node_obj.staking.increase_staking( 0, address1, amount=13000000000000000000) assert_code(result, 301104) result = client_new_node_obj.staking.increase_staking( 0, address1, amount=14000000000000000000) assert_code(result, 0)
def test_POP_005(client_consensus, client_new_node): """ The amendment of the threshold of pledge shall not take effect :param client_consensus: :param get_generate_account: :param client_new_node: :return: """ client_consensus.economic.env.deploy_all() old_amount = client_consensus.economic.create_staking_limit new_amount = old_amount + client_consensus.node.web3.toWei(1, "ether") block = param_governance_verify_before_endblock(client_consensus, "staking", "stakeThreshold", str(new_amount), effectiveflag=False) log.info(block) address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) wait_block_number(client_new_node.node, block) result = client_new_node.staking.create_staking(0, address, address, amount=old_amount) assert_code(result, 0)
def test_POP_008(client_consensus, client_new_node, new_genesis_env): """ (hesitation period) reduce the entrustment overweight threshold - test :param client_consensus: :param client_new_node: :param new_genesis_env: :return: """ old_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(2, "ether") new_amount = client_consensus.economic.delegate_limit + client_consensus.node.web3.toWei(1, "ether") genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config) genesis.economicModel.staking.operatingThreshold = old_amount new_genesis_env.set_genesis(genesis.to_dict()) new_genesis_env.deploy_all() block = param_governance_verify_before_endblock(client_consensus, "staking", "operatingThreshold", str(new_amount)) log.info(block) address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) wait_block_number(client_new_node.node, block) result = client_new_node.staking.create_staking(0, address1, address1) assert_code(result, 0) address2, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 10 ** 18 * 10000000) result = client_new_node.delegate.delegate(0, address2, amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) assert_code(result, 301105) result = client_new_node.delegate.delegate(0, address2, amount=new_amount) assert_code(result, 0) result = client_new_node.staking.increase_staking(0, address1, amount=new_amount - client_consensus.node.web3.toWei(1, "ether")) assert_code(result, 301104) result = client_new_node.staking.increase_staking(0, address1, amount=new_amount) assert_code(result, 0)