def test_AC_IN_003_008_010(self, new_genesis_env, clients_consensus):
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.gov.textProposalVoteDurationSeconds = 120
new_genesis_env.set_genesis(genesis.to_dict())
new_genesis_env.deploy_all()
pip = clients_consensus[-1].pip
submittpandvote(clients_consensus, 1, 2, 3, 1)
proposalinfo = pip.get_effect_proposal_info_of_vote(pip.cfg.text_proposal)
log.info('Get text proposal information : {}'.format(proposalinfo))
assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 2, 1, 1]
log.info('Stop the node {}'.format(clients_consensus[0].node.node_id))
clients_consensus[0].node.stop()
pip.economic.wait_consensus(pip.node, 2)
assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 2, 1, 1]
report_information = mock_duplicate_sign(1, clients_consensus[1].node.nodekey,
clients_consensus[1].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(1, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 2, 0, 1]
report_information = mock_duplicate_sign(2, clients_consensus[2].node.nodekey,
clients_consensus[2].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip.economic.account.generate_account(pip.node.web3, 10 ** 18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(2, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip.get_accuverifiers_count(proposalinfo.get('ProposalID')) == [4, 2, 0, 0]
def test_PIP_PVF_009(new_genesis_env):
"""
治理修改区块双签-证据有效期（节点质押退回锁定周期-1）
:param new_genesis_env:
:return:
"""
# Change configuration parameters
genesis = from_dict(data_class=Genesis,
data=new_genesis_env.genesis_config)
genesis.economicModel.staking.unStakeFreezeDuration = 3
genesis.economicModel.slashing.maxEvidenceAge = 1
new_file = new_genesis_env.cfg.env_tmp + "/genesis_0.13.0.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
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
change_parameter_value = '2'
# view Parameter value before treatment
first_slash_blocks = get_governable_parameter_value(
first_client, 'maxEvidenceAge')
# create Parametric proposal
param_governance_verify(first_client, 'slashing', 'maxEvidenceAge',
change_parameter_value)
# 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)
assert second_slash_blocks == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(
second_slash_blocks)
report_address, _ = economic.account.generate_account(
node.web3, node.web3.toWei(1000, 'ether'))
# wait consensus block
economic.wait_consensus_blocknum(node)
# Verify changed parameters
first_effective_block = economic.get_front_settlement_switchpoint(
node, int(first_slash_blocks))
log.info("first effective block height: {}".format(first_effective_block))
second_effective_block = economic.get_front_settlement_switchpoint(
node, int(second_slash_blocks))
log.info(
"second effective block height: {}".format(second_effective_block))
# first Report prepareblock signature
report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey,
first_effective_block)
log.info("Report information: {}".format(report_information))
result = first_client.duplicatesign.reportDuplicateSign(
1, report_information, report_address)
assert_code(result, 0)
# second Report prepareblock signature
report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey,
second_effective_block)
log.info("Report information: {}".format(report_information))
result = first_client.duplicatesign.reportDuplicateSign(
1, report_information, report_address)
assert_code(result, 303000)
def test_AC_IN_018_to_025(self, new_genesis_env, clients_consensus):
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.gov.paramProposalVoteDurationSeconds = 0
new_genesis_env.set_genesis(genesis.to_dict())
new_genesis_env.deploy_all()
pip = clients_consensus[0].pip
pip_test = clients_consensus[-1].pip
result = pip.submitParam(pip.node.node_id, str(time.time()), 'slashing', 'slashBlocksReward', '999',
pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('Node submit param proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo_param = pip.get_effect_proposal_info_of_vote(pip.cfg.param_proposal)
log.info('Get param proposal information : {}'.format(proposalinfo_param))
result = pip.submitCancel(pip.node.node_id, str(time.time()), 3, proposalinfo_param.get('ProposalID'),
pip.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('Node submit cancel proposal result : {}'.format(result))
proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(pip.cfg.cancel_proposal)
log.info('Get cancel proposal information : {}'.format(proposalinfo_cancel))
for index in range(3):
client = clients_consensus[index]
result = client.pip.vote(client.node.node_id, proposalinfo_param.get('ProposalID'), index + 1,
client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('Node {} vote param proposal result : {}'.format(client.node.node_id, result))
assert_code(result, 0)
result = client.pip.vote(client.node.node_id, proposalinfo_cancel.get('ProposalID'), index + 1,
client.node.staking_address, transaction_cfg=pip.cfg.transaction_cfg)
log.info('Node {} vote cancel proposal result : {}'.format(client.node.node_id, result))
assert_code(result, 0)
assert pip.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 1, 1, 1]
assert pip.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1]
log.info('Stop the node {}'.format(pip.node.node_id))
pip.node.stop()
pip_test.economic.wait_consensus(pip_test.node, 2)
assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 1, 1, 1]
assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1]
report_information = mock_duplicate_sign(1, clients_consensus[1].node.nodekey,
clients_consensus[1].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10 ** 18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(1, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
time.sleep(2)
assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 1, 0, 1]
assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 1]
report_information = mock_duplicate_sign(2, clients_consensus[2].node.nodekey,
clients_consensus[2].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip_test.economic.account.generate_account(pip_test.node.web3, 10 ** 18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(2, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip_test.get_accuverifiers_count(proposalinfo_param.get('ProposalID')) == [4, 1, 0, 0]
assert pip_test.get_accuverifiers_count(proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 0]
def test_PIP_PVF_008(new_genesis_env):
"""
治理修改区块双签-证据有效期处于已生效期
: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
change_parameter_value = '1'
# view Parameter value before treatment
first_slash_blocks = get_governable_parameter_value(
first_client, 'maxEvidenceAge')
# create Parametric proposal
param_governance_verify(first_client, 'slashing', 'maxEvidenceAge',
change_parameter_value)
# 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)
assert second_slash_blocks == change_parameter_value, "ErrMsg:Parameter value after treatment {}".format(
second_slash_blocks)
report_address, _ = 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, int(second_slash_blocks))
log.info("effective_block block height: {}".format(effective_block))
# wait consensus block
economic.wait_consensus_blocknum(node)
# first Report prepareblock signature
report_information = mock_duplicate_sign(1, node.nodekey, node.blsprikey,
economic.consensus_size + 1)
log.info("Report information: {}".format(report_information))
result = first_client.duplicatesign.reportDuplicateSign(
1, report_information, report_address)
assert_code(result, 303003)
# second 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_CS_CL_010_030(clients_new_node):
"""
:param global_test_env:
:param client_new_node:
:return:
"""
client = clients_new_node[0]
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
value = client.economic.create_staking_limit * 2
result = client.staking.create_staking(0, address, address, amount=value)
assert_code(result, 0)
log.info("The next periods")
client.economic.wait_settlement_blocknum(client.node)
log.info("The next consensus cycle")
client.economic.wait_consensus_blocknum(client.node)
number = client.node.eth.blockNumber
log.info("To report the double sign")
report_information = mock_duplicate_sign(1, client.node.nodekey,
client.node.blsprikey, number)
log.info("Report information: {}".format(report_information))
address, _ = client.economic.account.generate_account(
client.node.web3, 10**18 * 10000000)
result = client.duplicatesign.reportDuplicateSign(1, report_information,
address)
log.info(result)
log.info("The next periods")
client.economic.wait_settlement_blocknum(client.node)
verifierlist = get_pledge_list(client.ppos.getVerifierList)
log.info("verifierlist:{}".format(verifierlist))
assert client.node.node_id not in verifierlist
def test_PIP_PVF_010(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')
assert slash_blocks1 == '2', "ErrMsg:Parameter value before treatment {}".format(slash_blocks1)
# create Parametric proposal
param_governance_verify(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 == '1', "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_block1 = client_con_list_obj[0].economic.get_front_settlement_switchpoint(client_con_list_obj[0].node,
int(slash_blocks1))
log.info("Effective1 block height: {}".format(effective_block1))
# Report1 prepareblock signature
report_information = mock_duplicate_sign(1, client_con_list_obj[0].node.nodekey,
client_con_list_obj[0].node.blsprikey,
effective_block1)
log.info("Report information: {}".format(report_information))
result = client_con_list_obj[0].duplicatesign.reportDuplicateSign(1, report_information, report_address)
assert_code(result, 303003)
def test_PIP_PVF_009(new_genesis_env, client_con_list_obj):
"""
治理修改区块双签-证据有效期（节点质押退回锁定周期-1）
:param new_genesis_env:
:param client_con_list_obj:
:return:
"""
# Change configuration parameters
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.staking.unStakeFreezeDuration = 3
genesis.economicModel.slashing.maxEvidenceAge = 1
new_file = new_genesis_env.cfg.env_tmp + "/genesis.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
# view Parameter value before treatment
slash_blocks1 = get_governable_parameter_value(client_con_list_obj[0], 'maxEvidenceAge')
# create Parametric proposal
param_governance_verify(client_con_list_obj[0], 'slashing', 'maxEvidenceAge', '2')
# view Parameter value before treatment again
slash_blocks2 = get_governable_parameter_value(client_con_list_obj[0], 'maxEvidenceAge')
assert slash_blocks2 == '2', "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_block1 = client_con_list_obj[0].economic.get_front_settlement_switchpoint(client_con_list_obj[0].node,
int(slash_blocks1))
effective_block2 = client_con_list_obj[0].economic.get_front_settlement_switchpoint(client_con_list_obj[0].node,
int(slash_blocks2))
log.info("Effective1 block height: {}".format(effective_block1))
log.info("Effective2 block height: {}".format(effective_block2))
# Report1 prepareblock signature
report_information = mock_duplicate_sign(1, client_con_list_obj[0].node.nodekey,
client_con_list_obj[0].node.blsprikey,
effective_block1)
log.info("Report information: {}".format(report_information))
result = client_con_list_obj[0].duplicatesign.reportDuplicateSign(1, report_information, report_address)
assert_code(result, 0)
# Report2 prepareblock signature
report_information = mock_duplicate_sign(1, client_con_list_obj[0].node.nodekey,
client_con_list_obj[0].node.blsprikey,
effective_block2)
log.info("Report information: {}".format(report_information))
result = client_con_list_obj[0].duplicatesign.reportDuplicateSign(1, report_information, report_address)
assert_code(result, 303000)
def test_UP_FV_014(client_new_node, reset_environment):
"""
锁仓验证人违规被剔除验证人列表，申请赎回委托金
:param client_new_node:
:param reset_environment:
:return:
"""
client = client_new_node
economic = client.economic
node = client.node
# create account
amount1 = von_amount(economic.create_staking_limit, 2)
amount2 = von_amount(economic.create_staking_limit, 1)
address1, report_address = create_account_amount(client, amount1, amount2)
# create Restricting Plan
delegate_amount = von_amount(economic.delegate_limit, 10)
plan = [{'Epoch': 3, 'Amount': delegate_amount}]
result = client.restricting.createRestrictingPlan(report_address, plan,
report_address)
assert_code(result, 0)
# create staking
result = client.staking.create_staking(0, address1, address1)
assert_code(result, 0)
# Application for Commission
result = client.delegate.delegate(1, report_address)
assert_code(result, 0)
# Waiting for the end of the settlement period
economic.wait_settlement_blocknum(node)
#
for i in range(4):
result = check_node_in_list(node.node_id, client.ppos.getValidatorList)
log.info("Current node in consensus list status：{}".format(result))
if result:
# view current block
current_block = node.eth.blockNumber
log.info("Current block: {}".format(current_block))
# Report prepareblock signature
report_information = mock_duplicate_sign(1, node.nodekey,
node.blsprikey,
current_block)
log.info("Report information: {}".format(report_information))
result = client.duplicatesign.reportDuplicateSign(
1, report_information, report_address)
assert_code(result, 0)
time.sleep(3)
# Access to pledge information
candidate_info = client.ppos.getCandidateInfo(node.node_id)
info = candidate_info['Ret']
staking_blocknum = info['StakingBlockNum']
# withdrew delegate
result = client.delegate.withdrew_delegate(staking_blocknum,
report_address)
assert_code(result, 0)
break
else:
# wait consensus block
client.economic.wait_consensus_blocknum(node)
def duplicate_sign(client_obj, report_address, report_block):
if report_block < 41:
report_block = 41
# Report1 prepareblock signature
report_information = mock_duplicate_sign(1, client_obj.node.nodekey,
client_obj.node.blsprikey,
report_block)
log.info("Report information: {}".format(report_information))
result = client_obj.duplicatesign.reportDuplicateSign(1, report_information, report_address)
assert_code(result, 0)
def test_UP_FV_013(client_new_node, reset_environment):
"""
锁仓验证人违规被剔除验证人列表，申请退回质押金
:param client_new_node:
:return:
"""
client1 = client_new_node
economic = client1.economic
node = client1.node
# create account
amount1 = von_amount(economic.create_staking_limit, 3)
amount2 = von_amount(economic.create_staking_limit, 1)
address1, report_address = create_account_amount(client1, amount1, amount2)
# create Restricting Plan
delegate_amount = von_amount(economic.create_staking_limit, 2)
plan = [{'Epoch': 3, 'Amount': delegate_amount}]
result = client1.restricting.createRestrictingPlan(address1, plan,
address1)
assert_code(result, 0)
# view restricting plan again
restricting_info = client1.ppos.getRestrictingInfo(address1)
log.info("restricting plan informtion: {}".format(restricting_info))
# create staking
result = client1.staking.create_staking(1, address1, address1)
assert_code(result, 0)
# view restricting plan again
restricting_info = client1.ppos.getRestrictingInfo(address1)
log.info("restricting plan informtion: {}".format(restricting_info))
# Waiting for the end of the settlement period
economic.wait_settlement_blocknum(node)
#
for i in range(4):
result = check_node_in_list(node.node_id,
client1.ppos.getValidatorList)
log.info("Current node in consensus list status：{}".format(result))
if result:
# view current block
current_block = node.eth.blockNumber
log.info("Current block: {}".format(current_block))
# Report prepareblock signature
report_information = mock_duplicate_sign(1, node.nodekey,
node.blsprikey,
current_block)
log.info("Report information: {}".format(report_information))
result = client1.duplicatesign.reportDuplicateSign(
1, report_information, report_address)
assert_code(result, 0)
time.sleep(3)
# withdrew staking
result = client1.staking.withdrew_staking(address1)
assert_code(result, 301103)
break
else:
# wait consensus block
client1.economic.wait_consensus_blocknum(node)
def duplicate_sign(client, report_address, report_block):
if report_block <= client.economic.consensus_size:
report_block = client.economic.consensus_size + 1
# Report1 prepareblock signature
report_information = mock_duplicate_sign(1, client.node.nodekey,
client.node.blsprikey,
report_block)
log.info("Report information: {}".format(report_information))
result = client.duplicatesign.reportDuplicateSign(1, report_information,
report_address)
assert_code(result, 0)
def test_AL_NBI_016(client_new_node_obj, reset_environment):
"""
被双签处罚槛剔除验证人列表
:param client_new_node_obj:
:return:
"""
client = client_new_node_obj
economic = client.economic
node = client.node
client.economic.env.deploy_all()
# create account
address1, _ = economic.account.generate_account(node.web3, von_amount(economic.create_staking_limit, 2))
address2, _ = economic.account.generate_account(node.web3, 0)
report_address, _ = economic.account.generate_account(node.web3, node.web3.toWei(1000, 'ether'))
# create staking
staking_amount = von_amount(economic.create_staking_limit, 1.6)
result = client_new_node_obj.staking.create_staking(0, address2, address1, amount=staking_amount)
assert_code(result, 0)
# wait settlement block
economic.wait_settlement_blocknum(node)
# Check account balance
balance = node.eth.getBalance(address2)
log.info("Account Balance：{}".format(balance))
# view block_reward
block_reward, staking_reward = economic.get_current_year_reward(node)
log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward))
for i in range(4):
result = check_node_in_list(client_new_node_obj.node.node_id, client_new_node_obj.ppos.getValidatorList)
log.info("Current node in consensus list status：{}".format(result))
if result:
# view Current block
current_block = client_new_node_obj.node.eth.blockNumber
log.info("Current block: {}".format(current_block))
# Report prepareblock signature
report_information = mock_duplicate_sign(1, client_new_node_obj.node.nodekey, client_new_node_obj.node.blsprikey, current_block)
log.info("Report information: {}".format(report_information))
result = client_new_node_obj.duplicatesign.reportDuplicateSign(1, report_information, report_address)
assert_code(result, 0)
# wait settlement block
economic.wait_settlement_blocknum(node)
# Check account balance again
balance1 = node.eth.getBalance(address2)
log.info("Account Balance：{}".format(balance1))
# count the number of blocks
blocknumber = client_new_node_obj.economic.get_block_count_number(node, 10)
log.info("blocknumber: {}".format(blocknumber))
total_block_reward = int(Decimal(str(block_reward)) * Decimal(str(blocknumber)))
log.info("total_block_reward: {}".format(total_block_reward))
assert balance1 == balance + total_block_reward, "ErrMsg:benifit_balance1：{}".format(balance1)
break
else:
# wait consensus block
economic.wait_consensus_blocknum(node)
def test_reportDuplicateSign_receipt(set_not_need_analyze):
client = set_not_need_analyze
node = client.node
economic = client.economic
address, _ = economic.account.generate_account(
node.web3, economic.create_staking_limit * 2)
number = client.node.eth.blockNumber
report_information = mock_duplicate_sign(1, client.node.nodekey,
client.node.blsprikey, number)
address_, _ = economic.account.generate_account(
node.web3, economic.create_staking_limit * 2)
hash = client.duplicatesign.reportDuplicateSign(1, report_information,
address_)
key = "topics"
expected_result = []
check_receipt(node, hash, key, expected_result)
def test_AC_IN_001_002_004_to_006_012_to_014(self, new_genesis_env,
clients_consensus):
# genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
# genesis.economicModel.slashing.maxEvidenceAge = 1
# new_genesis_env.set_genesis(genesis.to_dict())
new_genesis_env.deploy_all()
pip = clients_consensus[-1].pip
result = pip.submitVersion(pip.node.node_id,
str(time.time()),
pip.cfg.version5,
12,
pip.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('Submit version proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo_version = pip.get_effect_proposal_info_of_vote()
log.info('Get version proposal information : {}'.format(
proposalinfo_version))
result = pip.submitCancel(pip.node.node_id,
str(time.time()),
10,
proposalinfo_version.get('ProposalID'),
pip.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('Submit cancel proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo_cancel = pip.get_effect_proposal_info_of_vote(
pip.cfg.cancel_proposal)
log.info('Get cancel proposal information : {}'.format(
proposalinfo_version))
for index in range(3):
log.info(f'index == {index}')
client = clients_consensus[index]
result = version_proposal_vote(client.pip)
assert_code(result, 0)
result = client.pip.vote(client.node.node_id,
proposalinfo_cancel.get('ProposalID'),
index + 1,
client.node.staking_address,
transaction_cfg=pip.cfg.transaction_cfg)
log.info('Node {} vote cancel proposal result : {}'.format(
client.node.node_id, result))
assert_code(result, 0)
log.info(f'blocknumber0000 == {pip.node.block_number}')
log.info(f'getCandidateList == {pip.node.ppos.getCandidateList()}')
assert pip.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0]
assert pip.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1]
log.info('Stop the node {}'.format(clients_consensus[0].node.node_id))
clients_consensus[0].node.stop()
pip.economic.wait_consensus(pip.node, 2)
log.info(pip.node.debug.getWaitSlashingNodeList())
log.info(pip.pip.listGovernParam())
log.info(clients_consensus[1].ppos.getCandidateInfo(
pip.node.node_id, pip.node.staking_address))
assert pip.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0]
assert pip.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1]
log.info(f'blocknumber1111 == {pip.node.block_number}')
report_information = mock_duplicate_sign(
1, clients_consensus[1].node.nodekey,
clients_consensus[1].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip.economic.account.generate_account(
pip.node.web3, 10**18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(
1, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
log.info(f'blocknumber2222 == {pip.node.block_number}')
assert pip.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 2, 0, 0]
assert pip.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 1]
report_information = mock_duplicate_sign(
2, clients_consensus[2].node.nodekey,
clients_consensus[2].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip.economic.account.generate_account(
pip.node.web3, 10**18 * 1000)
result = clients_consensus[-1].duplicatesign.reportDuplicateSign(
2, report_information, address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 1, 0, 0]
assert pip.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 1, 0, 0]
def test_CS_CL_017_018_019(status, clients_new_node, clients_consensus):
"""
:param status:
:param global_test_env:
:param client_con_list_obj:
:param clients_noconsensus:
:return:
"""
client_noconsensus1 = clients_new_node[0]
client_noconsensus2 = clients_new_node[1]
client_consensus1 = clients_consensus[0]
client_consensus2 = clients_consensus[1]
client_consensus3 = clients_consensus[2]
client_consensus4 = clients_consensus[3]
log.info("The next consensus cycle")
client_consensus1.economic.wait_consensus_blocknum(client_consensus1.node,
number=1)
validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList)
log.info("initial validatorlist:{}".format(validatorlist))
blocknumber = client_consensus1.node.eth.blockNumber
log.info("The thrill of being reported{}".format(blocknumber))
log.info("To report the double sign")
report_information1 = mock_duplicate_sign(1,
client_consensus1.node.nodekey,
client_consensus1.node.blsprikey,
blocknumber)
log.info("Report information: {}".format(report_information1))
address, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
result = client_consensus1.duplicatesign.reportDuplicateSign(
1, report_information1, address)
log.info(result)
log.info("The next periods")
client_noconsensus2.economic.wait_settlement_blocknum(
client_noconsensus2.node)
validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList)
log.info("After being reported validatorlist:{}".format(validatorlist))
if status == 0:
address1, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
value = client_noconsensus1.economic.create_staking_limit * 2
result = client_noconsensus1.staking.create_staking(0,
address1,
address1,
amount=value)
assert_code(result, 0)
log.info("The next periods")
client_noconsensus2.economic.wait_settlement_blocknum(
client_noconsensus2.node)
log.info("The next consensus cycle")
client_noconsensus2.economic.wait_consensus_blocknum(
client_noconsensus2.node)
validatorlist = get_pledge_list(
client_noconsensus2.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
assert client_consensus2.node.node_id in validatorlist
assert client_consensus3.node.node_id in validatorlist
assert client_consensus4.node.node_id in validatorlist
assert client_noconsensus1.node.node_id in validatorlist
if status == 1:
address1, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
value = client_noconsensus1.economic.create_staking_limit * 2
result = client_noconsensus1.staking.create_staking(0,
address1,
address1,
amount=value)
assert_code(result, 0)
address2, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
value = client_noconsensus1.economic.create_staking_limit * 2
result = client_noconsensus2.staking.create_staking(0,
address2,
address2,
amount=value)
assert_code(result, 0)
log.info("The next periods")
client_noconsensus2.economic.wait_settlement_blocknum(
client_noconsensus2.node)
log.info("The next consensus cycle")
client_noconsensus2.economic.wait_consensus_blocknum(
client_noconsensus2.node)
validatorlist = get_pledge_list(
client_noconsensus2.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
assert client_consensus2.node.node_id in validatorlist
assert client_consensus3.node.node_id in validatorlist
assert client_consensus4.node.node_id in validatorlist
def test_CS_CL_014_015_016_029(status, global_test_env, client_con_list_obj,
client_noc_list_obj):
"""
:param status:
:param global_test_env:
:param client_con_list_obj:
:param client_noc_list_obj:
:return:
"""
global_test_env.deploy_all()
log.info("The next consensus cycle")
client_con_list_obj[0].economic.wait_consensus_blocknum(
client_con_list_obj[0].node, number=1)
blocknumber = client_con_list_obj[0].node.eth.blockNumber
log.info("To report the double sign")
report_information1 = mock_duplicate_sign(
1, client_con_list_obj[0].node.nodekey,
client_con_list_obj[0].node.blsprikey, blocknumber)
log.info("Report information: {}".format(report_information1))
report_information2 = mock_duplicate_sign(
1, client_con_list_obj[1].node.nodekey,
client_con_list_obj[1].node.blsprikey, blocknumber)
log.info("Report information: {}".format(report_information2))
report_information3 = mock_duplicate_sign(
1, client_con_list_obj[2].node.nodekey,
client_con_list_obj[2].node.blsprikey, blocknumber)
log.info("Report information: {}".format(report_information3))
address_1, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
address_2, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
address_3, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
result = client_con_list_obj[0].duplicatesign.reportDuplicateSign(
1, report_information1, address_1)
log.info(result)
result = client_con_list_obj[1].duplicatesign.reportDuplicateSign(
1, report_information2, address_2)
log.info(result)
result = client_con_list_obj[2].duplicatesign.reportDuplicateSign(
1, report_information3, address_3)
log.info(result)
log.info("The next periods")
client_noc_list_obj[1].economic.wait_settlement_blocknum(
client_noc_list_obj[1].node)
validatorlist = get_pledge_list(
client_con_list_obj[0].ppos.getValidatorList)
log.info("After being reported validatorlist:{}".format(validatorlist))
if status == 0:
address1, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[0].staking.create_staking(0,
address1,
address1,
amount=value)
assert_code(result, 0)
address2, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[1].staking.create_staking(0,
address2,
address2,
amount=value)
assert_code(result, 0)
log.info("The next periods")
client_noc_list_obj[1].economic.wait_settlement_blocknum(
client_noc_list_obj[1].node)
log.info("The next consensus cycle")
client_noc_list_obj[1].economic.wait_consensus_blocknum(
client_noc_list_obj[1].node)
validatorlist = get_pledge_list(
client_noc_list_obj[1].ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
log.info("node1:{}".format(client_noc_list_obj[0].node.node_id))
log.info("node2:{}".format(client_noc_list_obj[1].node.node_id))
log.info("node3:{}".format(client_con_list_obj[3].node.node_id))
assert client_noc_list_obj[0].node.node_id in validatorlist
assert client_noc_list_obj[1].node.node_id in validatorlist
assert client_con_list_obj[3].node.node_id in validatorlist
if status == 1:
address1, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[0].staking.create_staking(0,
address1,
address1,
amount=value)
assert_code(result, 0)
address2, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[1].staking.create_staking(0,
address2,
address2,
amount=value)
assert_code(result, 0)
address3, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[2].staking.create_staking(0,
address3,
address3,
amount=value)
assert_code(result, 0)
log.info("The next periods")
client_noc_list_obj[1].economic.wait_settlement_blocknum(
client_noc_list_obj[1].node)
log.info("The next consensus cycle")
client_noc_list_obj[1].economic.wait_consensus_blocknum(
client_noc_list_obj[1].node)
validatorlist = get_pledge_list(
client_noc_list_obj[1].ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
log.info("node1:{}".format(client_noc_list_obj[0].node.node_id))
log.info("node2:{}".format(client_noc_list_obj[1].node.node_id))
log.info("node3:{}".format(client_noc_list_obj[2].node.node_id))
log.info("node4:{}".format(client_con_list_obj[3].node.node_id))
assert client_noc_list_obj[0].node.node_id in validatorlist
assert client_noc_list_obj[1].node.node_id in validatorlist
assert client_noc_list_obj[2].node.node_id in validatorlist
assert client_con_list_obj[3].node.node_id in validatorlist
if status == 2:
address1, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[0].staking.create_staking(0,
address1,
address1,
amount=value)
assert_code(result, 0)
address2, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[1].staking.create_staking(0,
address2,
address2,
amount=value)
assert_code(result, 0)
address3, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[2].staking.create_staking(0,
address3,
address3,
amount=value)
assert_code(result, 0)
address4, _ = client_noc_list_obj[0].economic.account.generate_account(
client_noc_list_obj[0].node.web3, 10**18 * 10000000)
value = client_noc_list_obj[0].economic.create_staking_limit * 2
result = client_noc_list_obj[3].staking.create_staking(0,
address4,
address4,
amount=value)
assert_code(result, 0)
log.info("The next periods")
client_noc_list_obj[1].economic.wait_settlement_blocknum(
client_noc_list_obj[1].node)
log.info("The next consensus cycle")
client_noc_list_obj[1].economic.wait_consensus_blocknum(
client_noc_list_obj[1].node)
validatorlist = get_pledge_list(
client_noc_list_obj[1].ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
log.info("node:{}".format(client_con_list_obj[3].node.node_id))
assert client_con_list_obj[3].node.node_id in validatorlist
def test_CS_CL_003(clients_new_node, clients_consensus):
"""
The higher the consensus verifier list block, the higher it is replaced
:param client_new_node:
:return:
"""
client_noconsensus1 = clients_new_node[0]
client_noconsensus2 = clients_new_node[1]
client_noconsensus3 = clients_new_node[2]
client_noconsensus4 = clients_new_node[3]
client_consensus1 = clients_consensus[0]
client_consensus2 = clients_consensus[1]
client_consensus3 = clients_consensus[2]
validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist))
log.info("The next consensus cycle")
client_consensus1.economic.wait_consensus_blocknum(client_consensus1.node,
number=1)
blocknumber = client_consensus1.node.eth.blockNumber
log.info("To report the double sign")
report_information1 = mock_duplicate_sign(1,
client_consensus1.node.nodekey,
client_consensus1.node.blsprikey,
blocknumber)
log.info("Report information: {}".format(report_information1))
report_information2 = mock_duplicate_sign(1,
client_consensus2.node.nodekey,
client_consensus2.node.blsprikey,
blocknumber)
log.info("Report information: {}".format(report_information2))
report_information3 = mock_duplicate_sign(1,
client_consensus3.node.nodekey,
client_consensus3.node.blsprikey,
blocknumber)
log.info("Report information: {}".format(report_information3))
address_1, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
address_2, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
address_3, _ = client_noconsensus1.economic.account.generate_account(
client_noconsensus1.node.web3, 10**18 * 10000000)
result = client_consensus1.duplicatesign.reportDuplicateSign(
1, report_information1, address_1)
log.info(result)
result = client_consensus2.duplicatesign.reportDuplicateSign(
1, report_information2, address_2)
log.info(result)
result = client_consensus3.duplicatesign.reportDuplicateSign(
1, report_information3, address_3)
log.info(result)
log.info("The next periods")
client_noconsensus3.economic.wait_settlement_blocknum(
client_noconsensus3.node)
validatorlist = get_pledge_list(client_consensus1.ppos.getValidatorList)
log.info("After being reported validatorlist:{}".format(validatorlist))
staking_address1, _ = client_noconsensus1.economic.account.generate_account(
client_consensus1.node.web3, 10**18 * 10000000)
staking_address2, _ = client_noconsensus1.economic.account.generate_account(
client_consensus1.node.web3, 10**18 * 10000000)
staking_address3, _ = client_noconsensus1.economic.account.generate_account(
client_consensus1.node.web3, 10**18 * 10000000)
staking_address4, _ = client_noconsensus1.economic.account.generate_account(
client_consensus1.node.web3, 10**18 * 10000000)
pledge_amount = client_consensus1.economic.create_staking_limit * 2
log.info("New pledge 4 verifiers")
result = client_noconsensus1.staking.create_staking(0,
staking_address1,
staking_address1,
amount=pledge_amount)
assert_code(result, 0)
result = client_noconsensus2.staking.create_staking(0,
staking_address2,
staking_address2,
amount=pledge_amount)
assert_code(result, 0)
result = client_noconsensus3.staking.create_staking(0,
staking_address3,
staking_address3,
amount=pledge_amount)
assert_code(result, 0)
result = client_noconsensus4.staking.create_staking(0,
staking_address4,
staking_address4,
amount=pledge_amount)
assert_code(result, 0)
log.info("Next settlement period")
client_noconsensus4.economic.wait_settlement_blocknum(
client_noconsensus4.node)
log.info("The next consensus cycle")
client_noconsensus4.economic.wait_consensus_blocknum(
client_noconsensus4.node)
verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList)
log.info("verifierList:{}".format(verifierList))
validatorlist1 = get_pledge_list(client_noconsensus4.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist1))
assert client_noconsensus1.node.node_id in validatorlist1
client_noconsensus4.economic.wait_consensus_blocknum(
client_noconsensus4.node)
verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList)
log.info("verifierList:{}".format(verifierList))
validatorlist2 = get_pledge_list(client_noconsensus4.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist2))
assert client_noconsensus1.node.node_id in validatorlist2
client_noconsensus4.economic.wait_consensus_blocknum(
client_noconsensus4.node)
verifierList = get_pledge_list(client_noconsensus4.ppos.getVerifierList)
log.info("verifierList:{}".format(verifierList))
validatorlist3 = get_pledge_list(client_noconsensus4.ppos.getValidatorList)
log.info("validatorlist:{}".format(validatorlist3))
assert client_noconsensus1.node.node_id in validatorlist3
def test_AC_IN_001_002_004_to_006_012_to_014(self, no_vp_proposal,
client_verifier_obj_list):
pip_obj = client_verifier_obj_list[-1].pip
result = pip_obj.submitVersion(
pip_obj.node.node_id,
str(time.time()),
pip_obj.cfg.version5,
5,
pip_obj.node.staking_address,
transaction_cfg=pip_obj.cfg.transaction_cfg)
log.info('Submit version proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo_version = pip_obj.get_effect_proposal_info_of_vote()
log.info('Get version proposal information : {}'.format(
proposalinfo_version))
result = pip_obj.submitCancel(
pip_obj.node.node_id,
str(time.time()),
4,
proposalinfo_version.get('ProposalID'),
pip_obj.node.staking_address,
transaction_cfg=pip_obj.cfg.transaction_cfg)
log.info('Submit cancel proposal result : {}'.format(result))
assert_code(result, 0)
proposalinfo_cancel = pip_obj.get_effect_proposal_info_of_vote(
pip_obj.cfg.cancel_proposal)
log.info('Get cancel proposal information : {}'.format(
proposalinfo_version))
for index in range(3):
client_obj = client_verifier_obj_list[index]
result = version_proposal_vote(client_obj.pip)
assert_code(result, 0)
result = client_obj.pip.vote(
client_obj.node.node_id,
proposalinfo_cancel.get('ProposalID'),
index + 1,
client_obj.node.staking_address,
transaction_cfg=pip_obj.cfg.transaction_cfg)
log.info('Node {} vote cancel proposal result : {}'.format(
client_obj.node.node_id, result))
assert_code(result, 0)
assert pip_obj.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 3, 0, 0]
assert pip_obj.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 1, 1, 1]
log.info('Stop the node {}'.format(
client_verifier_obj_list[0].node.node_id))
client_verifier_obj_list[0].node.stop()
pip_obj.economic.wait_consensus_blocknum(pip_obj.node, 2)
assert pip_obj.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 2, 0, 0]
assert pip_obj.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 0, 1, 1]
report_information = mock_duplicate_sign(
1, client_verifier_obj_list[1].node.nodekey,
client_verifier_obj_list[1].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip_obj.economic.account.generate_account(
pip_obj.node.web3, 10**18 * 1000)
result = client_verifier_obj_list[
-1].duplicatesign.reportDuplicateSign(1, report_information,
address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip_obj.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 1, 0, 0]
assert pip_obj.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 1]
report_information = mock_duplicate_sign(
2, client_verifier_obj_list[2].node.nodekey,
client_verifier_obj_list[2].node.blsprikey, 41)
log.info("Report information: {}".format(report_information))
address, _ = pip_obj.economic.account.generate_account(
pip_obj.node.web3, 10**18 * 1000)
result = client_verifier_obj_list[
-1].duplicatesign.reportDuplicateSign(2, report_information,
address)
log.info('Node duplicate block result : {}'.format(result))
assert_code(result, 0)
assert pip_obj.get_accuverifiers_count(
proposalinfo_version.get('ProposalID')) == [4, 0, 0, 0]
assert pip_obj.get_accuverifiers_count(
proposalinfo_cancel.get('ProposalID')) == [4, 0, 0, 0]
