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