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