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)
