def test_fee_income(self):
platon_ppos = Ppos('http://10.10.8.157:6789',
self.address,
chainid=102,
privatekey=conf.PRIVATE_KEY)
#platon_ppos = self.ppos_link ()
incentive_pool_balance_befor = platon_ppos.eth.getBalance(
conf.INCENTIVEPOOLADDRESS)
log.info('交易前激励池查询余额：{}'.format(incentive_pool_balance_befor))
# 签名转账
address1 = '0x51a9A03153a5c3c203F6D16233e3B7244844A457'
privatekey1 = '25f9fdf3249bb47f239df0c59d23781c271e8b7e9a94e9e694c15717c1941502'
try:
platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(conf.ADDRESS),
Web3.toChecksumAddress(address1), self.gasPrice, self.gas,
self.value, conf.PRIVATE_KEY)
balance = platon_ppos.eth.getBalance(address1)
if balance == Web3.toWei(self.value, 'ether'):
incentive_pool_balance_after = platon_ppos.eth.getBalance(
conf.INCENTIVEPOOLADDRESS)
log.info('交易前激励池查询余额：{}'.format(incentive_pool_balance_after))
difference = incentive_pool_balance_after - incentive_pool_balance_befor
log.info('手续费的金额：{}'.format(difference))
assert difference == self.gas
else:
log.info("转账{}金额错误".format(Web3.toWei(self.value, 'ether')))
except:
status = 1
assert status == 0, '转账失败'
def test_loukupplan_Moredeadline(self, balace1, balace2):
'''
验证一个锁仓计划里有多个解锁期
amount : 锁仓
balace1 : 第一个锁仓期的锁仓金额
balace2 : 第二个锁仓期的锁仓金额
:return:
'''
url = CommonMethod.link_list(self)
platon_ppos = Ppos(url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list()
# 签名转账
result = platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(self.address),
Web3.toChecksumAddress(address1), self.base_gas_price,
self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt(result)
assert return_info is not None, "转账：{}失败".format(self.value)
loukupbalace1 = Web3.toWei(balace1, 'ether')
loukupbalace2 = Web3.toWei(balace2, 'ether')
if (balace1 + balace2) < self.value:
plan = [{
'Epoch': 1,
'Amount': loukupbalace1
}, {
'Epoch': 2,
'Amount': loukupbalace2
}]
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format(
result['Status'])
elif (balace1 + balace2) >= self.value:
plan = [{
'Epoch': 1,
'Amount': loukupbalace1
}, {
'Epoch': 2,
'Amount': loukupbalace2
}]
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == False, "创建锁仓计划返回的状态：{},用例失败".format(
result['Status'])
else:
log.info('锁仓输入的金额:{}出现异常'.format((loukupbalace1 + loukupbalace2)))
Status = 1
assert Status == 0, 'error:创建锁仓失败'
def test_back_unstaking(self):
"""
验证人退回质押金（未到达可解锁期）
质押成为下个周期验证人，退出后，下一个结算周期退出
"""
log.info("转账每个钱包")
for to_account in self.account_list:
self.transaction(self.w3_list[0],
self.address,
to_address=to_account)
log.info("节点1质押金额{} eth".format(self.amount))
self.ppos_noconsensus_1.createStaking(0, self.account_list[0],
self.nodeid_list2[0],
self.externalId, self.nodeName,
self.website, self.details,
self.amount, self.programVersion)
account_1 = self.eth.getBalance(self.account_list[0])
log.info(account_1)
get_block_number(self.w3_list[0])
log.info("查询第2个结算周期的验证人")
node_list = getVerifierList()
log.info(node_list)
assert self.nodeid_list2[0] in node_list
log.info("节点1在第2结算周期，锁定期申请退回")
self.ppos_noconsensus_1.unStaking(nodeId=self.nodeid_list2[0])
"""发起退回消耗一定gas"""
account_2 = self.eth.getBalance(self.account_list[0])
log.info(account_2)
assert account_1 > account_2, "发起退回的交易钱包异常"
log.info("进入第3个结算周期")
get_block_number(w3=self.w3_list[0])
account_3 = self.eth.getBalance(self.account_list[0])
log.info(account_3)
assert account_3 > account_2
assert account_3 - account_2 < Web3.toWei(self.amount, "ether")
log.info(account_3 - account_2)
node_list = getVerifierList()
log.info(node_list)
assert self.nodeid_list2[0] not in node_list
log.info("进入第4个结算周期")
get_block_number(w3=self.w3_list[0])
account_4 = self.eth.getBalance(self.account_list[0])
log.info(account_4)
""" 第3个结算周期结束后质押金额已退 """
log.info(account_4 - account_3)
assert account_4 - account_3 > Web3.toWei(self.amount, "ether")
assert account_4 - account_2 > Web3.toWei(self.amount, "ether")
def test_loukupplan_amount(self):
platon_ppos = Ppos('http://10.10.8.157:6789',
self.address,
chainid=102,
privatekey=conf.PRIVATE_KEY)
# platon_ppos = self.ppos_link ()
address1 = '0x51a9A03153a5c3c203F6D16233e3B7244844A457'
privatekey1 = '25f9fdf3249bb47f239df0c59d23781c271e8b7e9a94e9e694c15717c1941502'
# 签名转账
platon_ppos.send_raw_transaction('',
Web3.toChecksumAddress(conf.ADDRESS),
Web3.toChecksumAddress(address1),
self.gasPrice, self.gas, self.value,
conf.PRIVATE_KEY)
balance = platon_ppos.eth.getBalance(address1)
if balance > 0:
try:
loukupbalace = Web3.toWei(10000, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey1,
from_address=address1,
gasPrice=self.gasPrice,
gas=self.gas)
assert result['status'] == 'false'
except:
status = 1
assert status == 0, '创建锁仓计划失败'
else:
log.info('error:转账失败')
def test_loukupplan_abnormal(self, number, amount):
'''
创建锁仓计划时，参数有效性验证
number : 锁仓解锁期
amount : 锁仓金额
:param number:
:param amount:
:return:
'''
url = CommonMethod.link_list(self)
platon_ppos = Ppos(url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list()
# 签名转账
result = platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(self.address),
Web3.toChecksumAddress(address1), self.base_gas_price,
self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt(result)
assert return_info is not None, "转账：{}失败".format(self.value)
loukupbalace = Web3.toWei(amount, 'ether')
#loukupbalace = amount
plan = [{'Epoch': number, 'Amount': loukupbalace}]
log.info("创建锁仓计划参数：{}".format(plan))
if type(number) == int and type(amount) == int:
if 0 < number <= 36 and 1 <= amount:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, '创建锁仓状态为：{},用例失败'.format(
result['Status'])
else:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == False, '创建锁仓状态为：{},用例失败'.format(
result['Status'])
else:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == False, '创建锁仓状态为：{},用例失败'.format(
result['Status'])
def test_IT_IA_002_to_007(new_genesis_env):
"""
IT_IA_002:链初始化-查看token发行总量账户初始值
IT_IA_003:链初始化-查看platON基金会账户初始值
IT_IA_004:链初始化-查看激励池账户
IT_IA_005:链初始化-查看剩余总账户
IT_IA_006:链初始化-查看锁仓账户余额
IT_IA_007:链初始化-查看质押账户余额
:return:验证链初始化后token各内置账户初始值
"""
# Initialization genesis file Initial amount
node_count = len(new_genesis_env.consensus_node_list)
default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether')
node = new_genesis_env.get_rand_node()
community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.innerAcc.cdfBalance = community_amount
surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount - 200000000000000000000000000)
genesis.alloc = {
"1000000000000000000000000000000000000003": {
"balance": "200000000000000000000000000"
},
"0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": {
"balance": surplus_amount
}
}
new_file = new_genesis_env.cfg.env_tmp + "/genesis.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
# Verify the amount of each built-in account
foundation_louckup = node.eth.getBalance(EconomicConfig.FOUNDATION_LOCKUP_ADDRESS)
log.info('Initial lock up contract address： {} amount：{}'.format(EconomicConfig.FOUNDATION_LOCKUP_ADDRESS,
foundation_louckup))
incentive_pool = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS)
log.info('Incentive pool address：{} amount：{}'.format(EconomicConfig.INCENTIVEPOOL_ADDRESS, incentive_pool))
staking = node.eth.getBalance(EconomicConfig.STAKING_ADDRESS)
log.info('Address of pledge contract：{} amount：{}'.format(EconomicConfig.STAKING_ADDRESS, staking))
foundation = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS))
log.info('PlatON Foundation address：{} amount：{}'.format(EconomicConfig.FOUNDATION_ADDRESS, foundation))
remain = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.REMAIN_ACCOUNT_ADDRESS))
log.info('Remaining total account address：{} amount：{}'.format(EconomicConfig.REMAIN_ACCOUNT_ADDRESS, remain))
develop = node.eth.getBalance(node.web3.toChecksumAddress(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS))
log.info('Community developer foundation address：{} amount：{}'.format(EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
develop))
reality_total = foundation_louckup + incentive_pool + staking + foundation + remain + develop
log.info("Total issuance of Chuangshi block：{}".format(reality_total))
log.info("--------------Dividing line---------------")
assert foundation == 0, "ErrMsg:Initial amount of foundation {}".format(foundation)
assert foundation_louckup == 259096239000000000000000000, "ErrMsg:Initial lock up amount of foundation {}".format(
foundation_louckup)
assert staking == default_pledge_amount, "ErrMsg:Amount of initial pledge account: {}".format(staking)
assert incentive_pool == 262215742000000000000000000, "ErrMsg:Initial amount of incentive pool {}".format(
incentive_pool)
assert remain == int(surplus_amount), "ErrMsg:Initial amount of remaining total account {}".format(remain)
assert develop == 0, "ErrMsg:Community developer foundation account amount {}".format(develop)
assert reality_total == EconomicConfig.TOKEN_TOTAL, "ErrMsg:Initialize release value {}".format(reality_total)
def test_IP_PR_006_1(reset_cfg_env_node):
value = Web3.toWei(100, 'ether')
genesis = reset_cfg_env_node.genesis
genesis.economicModel.staking.operatingThreshold = value
new_file = reset_cfg_env_node.genesis_path
genesis.to_file(new_file)
reset_cfg_env_node.deploy_me(new_file)
config = reset_cfg_env_node.debug.economicConfig()
assert value == config["staking"]["operatingThreshold"]
def test_IP_PR_004(reset_cfg_env_node):
"""
正常范围内的质押Token数
"""
value = Web3.toWei(1000000, "ether")
genesis = reset_cfg_env_node.genesis
genesis.economicModel.staking.stakeThreshold = value
genesis.to_file(reset_cfg_env_node.genesis_path)
reset_cfg_env_node.deploy_me(reset_cfg_env_node.genesis_path)
config = reset_cfg_env_node.debug.economicConfig()
assert value == config["staking"][
"stakeThreshold"], "Inconsistent with the genesis file configuration amount"
def test_loukupplan_abnormal(self, number, amount):
'''
创建锁仓计划时，参数有效性验证
number : 锁仓解锁期
amount : 锁仓金额
:param number:
:param amount:
:return:
'''
address1 = '0x9148528b98a0065D185F01dbc59baB88CdbE7Ad2'
private_key1 = '6ccbf153f7409af1e5df7a1ef77daaca4759f0a6b50ef73fe9ccd5738cc2fda1'
platon_ppos = Ppos('http://10.10.8.157:6789',
self.address,
chainid=102,
privatekey=conf.PRIVATE_KEY)
# platon_ppos = self.ppos_link ()
try:
loukupbalace = Web3.toWei(amount, 'ether')
plan = [{'Epoch': number, 'Amount': loukupbalace}]
#当锁仓金额输入小于 1ether
if number >= 1 and amount < 1:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
conf.PRIVATE_KEY,
from_address=conf.ADDRESS,
gasPrice=self.gasPrice,
gas=self.gas)
assert result['status'] == 'false'
#当锁仓解锁期输入非正整数倍
elif number < 0 or type(number) == float:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
conf.PRIVATE_KEY,
from_address=conf.ADDRESS,
gasPrice=self.gasPrice,
gas=self.gas)
assert result['status'] == 'false'
#当锁仓解锁期大于36个结算期
elif number > 36:
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
conf.PRIVATE_KEY,
from_address=conf.ADDRESS,
gasPrice=self.gasPrice,
gas=self.gas)
assert result['status'] == 'false'
except:
status = 1
assert status == 0, '创建锁仓计划失败'
def test_multiple_unlock_Normal(self):
'''
多个锁仓期，到达部分解锁期返回解锁金额
:return:
'''
url = CommonMethod.link_list (self)
platon_ppos = Ppos (url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list ()
address2, private_key2 = CommonMethod.read_private_key_list ()
# 签名转账
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address1),
self.base_gas_price, self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None,"转账：{}失败".format(self.value)
loukupbalace = Web3.toWei (50, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace},{'Epoch': 2, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回状态为:{} 有误".format (result['Status'])
balance = platon_ppos.eth.getBalance (address2)
log.info ("锁仓之后账户余额：{}".format (balance))
log.info ("当前块高：{}".format (platon_ppos.eth.blockNumber))
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == loukupbalace*2, "锁仓金额：{}有误".format (dict_Info['balance'])
# 验证到达锁仓第一个解锁期之后账户金额
CommonMethod.get_next_settlement_interval (self)
balance2 = platon_ppos.eth.getBalance (address2)
log.info ("到达第一个解锁期后账户余额：{}".format (balance2))
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
balance = platon_ppos.eth.getBalance (address2)
assert dict_Info['balance'] == loukupbalace, "锁仓金额：{}有误".format (dict_Info['balance'])
assert dict_Info['Entry'][0]['amount'] == loukupbalace,"第二个解锁期待释放金额：{}".format(dict_Info['Entry'][0]['amount'])
assert balance2 == loukupbalace, "返回的释放锁仓金额：{} 有误".format (balance)
#验证到达锁仓第二个解锁期之后账户金额
CommonMethod.get_next_settlement_interval (self)
balance3 = platon_ppos.eth.getBalance (address2)
log.info ("到达第二个解锁期后账户余额：{}".format (balance2))
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
balance = platon_ppos.eth.getBalance (address2)
assert dict_Info['balance'] == 0, "锁仓金额：{}有误".format (dict_Info['balance'])
assert balance3 == loukupbalace*2, "返回的释放锁仓金额：{} 有误".format (balance)
def test_loukupplan(self):
'''
验证正常锁仓功能
参数输入：
Epoch：1
Amount：50 ether
:return:
'''
platon_ppos = Ppos('http://10.10.8.157:6789',
self.address,
chainid=102,
privatekey=conf.PRIVATE_KEY)
#platon_ppos = self.ppos_link ()
address1 = '0x472599739f398c24ad8Cdc03476b20D6469eAf46'
privatekey1 = '61279a4b654aef7c3065c0cf550cdce460682875c218de893544a4799b57cc41'
#非签名转账
# platon_ppos.web3.personal.unlockAccount(conf.ADDRESS, conf.PASSWORD, 2222)
# self.ppos_sendTransaction(address1,conf.ADDRESS,self.gas,self.gasPrice,Web3.toWei(10000,'ether'))
#签名转账
platon_ppos.send_raw_transaction('',
Web3.toChecksumAddress(conf.ADDRESS),
Web3.toChecksumAddress(address1),
self.gasPrice, self.gas, self.value,
conf.PRIVATE_KEY)
balance = platon_ppos.eth.getBalance(address1)
log.info("发起锁仓账户的余额:{}", balance)
if balance > 0:
try:
loukupbalace = Web3.toWei(50, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
lockup_before = platon_ppos.eth.getBalance(
conf.FOUNDATIONLOCKUPADDRESS)
#创建锁仓计划
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey1,
from_address=address1,
gasPrice=self.gasPrice)
lockup_after = platon_ppos.eth.getBalance(
conf.FOUNDATIONLOCKUPADDRESS)
#查看锁仓计划明细
RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)
if result['status'] == 'True':
assert RestrictingInfo['balance'] == loukupbalace
else:
log.info("查询锁仓计划信息返回状态为:{}".format(result['status']))
assert lockup_after == lockup_before + loukupbalace
except:
status = 1
assert status == 0, '创建锁仓计划失败'
def test_IP_PR_004_005(value, reset_cfg_env_node):
"""
Abnormal pledge Token number
1、创建验证人最低的质押Token数<10 * 10^18 von
2、创建验证人最低的质押Token数 = 0
"""
value = Web3.toWei(value, "ether")
genesis = reset_cfg_env_node.genesis
genesis.economicModel.staking.stakeThreshold = value
new_file = reset_cfg_env_node.genesis_path
genesis.to_file(new_file)
assert_error_deploy(reset_cfg_env_node, new_file,
"Abnormal pledge Token number")
def test_IP_PR_006_2(value, reset_cfg_env_node):
"""
修改每次委托及赎回的最低Token数
1、委托人每次委托及赎回的最低Token数<10 * 10^18 von
2、委托人每次委托及赎回的最低Token数 = 0
"""
value = Web3.toWei(value, 'ether')
genesis = reset_cfg_env_node.genesis
genesis.economicModel.staking.operatingThreshold = value
new_file = reset_cfg_env_node.genesis_path
genesis.to_file(new_file)
assert_error_deploy(reset_cfg_env_node, new_file,
"The abnormal redemption amount")
def test_unstaking_all(self):
log.info("转账每个钱包")
for to_account in self.account_list:
self.transaction(self.w3_list[0],
self.address,
to_address=to_account)
value_before = self.eth.getBalance(self.account_list[5])
log.info(value_before)
self.ppos_noconsensus_6.createStaking(0, self.account_list[5],
self.nodeid_list2[5],
self.externalId, self.nodeName,
self.website, self.details,
self.amount, self.programVersion)
log.info("进入第2个结算周期")
get_block_number(self.w3_list[0])
log.info("节点6增持金额")
self.ppos_noconsensus_6.addStaking(self.nodeid_list2[5], 0,
self.amount + 1000)
log.info("进入第3个结算周期")
get_block_number(self.w3_list[0])
log.info("节点6发起退回")
self.ppos_noconsensus_6.unStaking(nodeId=self.nodeid_list2[5])
log.info("进入第4个结算周期")
get_block_number(self.w3_list[0])
value = self.eth.getBalance(self.account_list[5])
log.info(value)
assert value < value_before, "钱还在锁定期，预期未退回，实际异常"
log.info("进入第5个结算周期")
get_block_number(self.w3_list[0])
value_after = self.eth.getBalance(self.account_list[5])
log.info(value_after)
log.info(value_after - value_before)
amount_sum = self.amount * 2 + 1000
log.info(Web3.toWei(amount_sum, "ether"))
assert value_after > value_before, "出块奖励异常"
assert value_after > value + Web3.toWei(
amount_sum, "ether"), "解锁期的余额大于锁定期的余额+质押+增持金额，但是发生异常"
def test_unDelegate_part(self):
"""
用例id 106 申请赎回委托
用例id 111 委托人未达到锁定期申请赎回
申请部分赎回
"""
log.info("转账到钱包3")
self.transaction(self.w3_list[0],
self.address,
to_address=self.account_list[2])
log.info("转账到钱包4")
self.transaction(self.w3_list[0],
self.address,
to_address=self.account_list[3])
msg = self.ppos_noconsensus_1.getCandidateInfo(self.nodeid_list2[2])
if msg['Data'] == "":
log.info("质押节点3：{}成为验证节点".format(self.nodeid_list2[2]))
self.ppos_noconsensus_3.createStaking(0, self.account_list[2],
self.nodeid_list2[2],
self.externalId,
self.nodeName, self.website,
self.details, self.amount,
self.programVersion)
log.info("钱包4 {}委托到3 {}".format(self.account_list[3],
self.account_list[2]))
value = 100
self.ppos_noconsensus_4.delegate(0, self.nodeid_list2[2], value)
log.info("查询当前节点质押信息")
msg = self.ppos_noconsensus_3.getCandidateInfo(self.nodeid_list2[2])
stakingBlockNum = msg["Data"]["StakingBlockNum"]
log.info("发起质押的区高{}".format(stakingBlockNum))
delegate_value = 20
self.ppos_noconsensus_4.unDelegate(stakingBlockNum,
self.nodeid_list2[2],
delegate_value)
log.info("查询钱包{}的委托信息".format(self.account_list[3]))
msg = self.ppos_noconsensus_4.getDelegateInfo(stakingBlockNum,
self.account_list[3],
self.nodeid_list2[2])
print(msg)
data = msg["Data"]
"""不清楚msg["Data"]对应value是str类型，需要再转字典"""
data = json.loads(data)
print(data)
assert Web3.toChecksumAddress(data["Addr"]) == self.account_list[3]
assert data["NodeId"] == self.nodeid_list2[2]
print(data["ReleasedHes"])
value = value - delegate_value
result_value = Web3.toWei(value, "ether")
assert data["ReleasedHes"] == result_value
def setup_module():
pt_multi = PlatonContractTransaction(node_url)
for k, w in config_data.wasm.items():
contract_address = contract_deploy(pt_multi, abspath(w),
abspath(config_data.abi[k]))
config_data.contract_address[k] = contract_address
handle(config_data.contract_address)
send_data = {
"to": send_address,
"from": address,
"gas": '9000',
"gasPrice": '1000000000',
"value": Web3.toWei(200, 'ether'),
}
tx_hash = pt_multi.eth.sendTransaction(send_data)
pt_multi.eth.waitForTransactionReceipt(tx_hash)
def test_loukupplan(self):
'''
验证正常锁仓功能
参数输入：
Epoch：1
Amount：50 ether
:return:
'''
url = CommonMethod.link_list(self)
platon_ppos = Ppos(url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list()
# 签名转账
result = platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(self.address),
Web3.toChecksumAddress(address1), self.base_gas_price,
self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt(result)
assert return_info is not None, "转账：{}失败".format(self.value)
#查询锁仓账户的余额
lockup_before = platon_ppos.eth.getBalance(
conf.FOUNDATIONLOCKUPADDRESS)
log.info("发起锁仓账户的余额:{}".format(lockup_before))
#创建锁仓计划
loukupbalace = Web3.toWei(50, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回状态为:{} 有误".format(
result['Status'])
lockup_after = platon_ppos.eth.getBalance(conf.FOUNDATIONLOCKUPADDRESS)
assert lockup_after == lockup_before + loukupbalace, "锁仓账户金额：{}有误".format(
lockup_after)
#查看锁仓计划明细
detail = platon_ppos.GetRestrictingInfo(address1)
assert detail['Status'] == True, "查询锁仓计划信息返回状态为:{}".format(
result['Status'])
RestrictingInfo = json.loads(detail['Data'])
assert RestrictingInfo[
'balance'] == loukupbalace, "创建锁仓计划金额：{}有误".format(lockup_after)
def test_transfer_normal(self):
'''
验证初始化之后账户之间转账
:return:
'''
platon_ppos = self.ppos_link()
address1 = '0x684b43Cf53C78aA567840174a55442d7a9282679'
privatekey1 = 'a5ac52e828e2656309933339cf12d30755f918e368fffc7c265b55da718ff893'
try:
platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(conf.ADDRESS),
Web3.toChecksumAddress(address1), self.gasPrice, self.gas,
self.value, conf.PRIVATE_KEY)
Balance1 = platon_ppos.eth.getBalance('address1')
assert Web3.toWei(self.value, 'ether') == Balance1
except:
status = 1
assert status == 0, '账号余额不足，无法发起转账'
def test_RV_004(staking_client):
client = staking_client
staking_address = client.staking_address
node = client.node
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)
msg = client.ppos.getCandidateInfo(node.node_id)
log.info("Query pledge {}".format(msg))
log.info("Initiating a pledge")
msg = client.staking.withdrew_staking(staking_address)
assert_code(msg, 0)
after_balance_1 = node.eth.getBalance(staking_address)
log.info("Hesitant period to initiate a refunded balance{}".format(
after_balance_1))
"""The balance after return is definitely less than the balance before the pledge, the consumption is less than 1 eth"""
assert before_create_balance - after_balance_1 < Web3.toWei(
1, "ether"), "The returned amount is abnormal"
locked_info = client.ppos.getRestrictingInfo(staking_address)
log.info(locked_info)
msg = client.ppos.getCandidateInfo(node.node_id)
assert_code(msg, 301204)
log.info("Enter the next cycle")
economic.wait_settlement(node)
locked_info = client.ppos.getRestrictingInfo(staking_address)
log.info(locked_info)
after_account = node.eth.getBalance(staking_address)
log.info("Account balance after the lockout is released{}".format(
after_account))
assert after_account - after_balance_1 == lockup_amount, "The amount of the lockout returned is abnormal."
def test_transfer_normal(self):
'''
验证初始化之后账户之间转账
:return:
'''
url = CommonMethod.link_list(self)
platon_ppos = Ppos(url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list()
# 签名转账
result = platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(self.address),
Web3.toChecksumAddress(address1), self.base_gas_price,
self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt(result)
assert return_info is not None, "转账：{}失败".format(self.value)
balance = platon_ppos.eth.getBalance(address1)
log.info("转账金额{}".format(balance))
assert Web3.toWei(self.value,
'ether') == balance, "转账金额:{}失败".format(balance)
def test_transfer_funds(self):
'''
验证初始化之后普通账户转账内置账户
:return:
'''
platon_ppos = self.ppos_link()
lockup_balancebe_before = platon_ppos.eth.getBalance(
conf.INCENTIVEPOOLADDRESS)
# 签名转账
try:
platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(conf.ADDRESS),
Web3.toChecksumAddress(conf.INCENTIVEPOOLADDRESS),
self.gasPrice, self.gas, self.value, conf.PRIVATE_KEY)
lockup_balancebe_after = platon_ppos.eth.getBalance(
conf.INCENTIVEPOOLADDRESS)
assert lockup_balancebe_before + Web3.toWei(
self.value, 'ether') == lockup_balancebe_after
except:
status = 1
assert status == 0, '无法发起转账'
def test_loukupplan_amount(self):
url = CommonMethod.link_list(self)
platon_ppos = Ppos(url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list()
# 签名转账
result = platon_ppos.send_raw_transaction(
'', Web3.toChecksumAddress(self.address),
Web3.toChecksumAddress(address1), self.base_gas_price,
self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt(result)
assert return_info is not None, "转账：{}失败".format(self.value)
loukupbalace = Web3.toWei(10000, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan(
address1,
plan,
privatekey=private_key1,
from_address=address1,
gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == False, '创建锁仓计划返回状态为{}，用例失败'.format(
result['Status'])
def test_AL_FI_004_005(new_genesis_env, client_consensus, staking_cfg):
"""
AL_FI_004:查看每年区块奖励变化
AL_FI_005:查看每年质押奖励变化
:param new_genesis_env:
:param staking_cfg:
:return:
"""
# Initialization genesis file Initial amount
account = client_consensus.economic.account
node_count = len(new_genesis_env.consensus_node_list)
default_pledge_amount = Web3.toWei(node_count * 150000, 'ether')
node = new_genesis_env.get_rand_node()
community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.innerAcc.cdfBalance = community_amount
surplus_amount = str(10250000000000000000000000000 - community_amount - 200000000000000000000000000)
genesis.alloc = {
"lat1zqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrdyjj2v": {
"balance": "200000000000000000000000000"
},
"lat1rzw6lukpltqn9rk5k59apjrf5vmt2ncv8uvfn7": {
"balance": surplus_amount
}
}
new_file = new_genesis_env.cfg.env_tmp + "/genesis_1.0.0.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
normal_node = new_genesis_env.get_a_normal_node()
client = Client(new_genesis_env, normal_node, staking_cfg)
economic = client.economic
node = client.node
log.info("Current connection node：{}".format(node.node_mark))
log.info("Current connection nodeid：{}".format(node.node_id))
address, _ = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
log.info("address: {}".format(address))
address1, _ = economic.account.generate_account(node.web3, 0)
log.info("address1: {}".format(address1))
end_cycle_timestamp = None
for i in range(10):
result = client.staking.create_staking(0, address1, address)
assert_code(result, 0)
# view account amount
benifit_balance = node.eth.getBalance(address1)
log.info("benifit_balance: {}".format(benifit_balance))
# Wait for the settlement round to end
economic.wait_settlement(node)
# 获取当前结算周期验证人
verifier_list = node.ppos.getVerifierList()
log.info("verifier_list: {}".format(verifier_list))
# view block_reward
block_reward, staking_reward = economic.get_current_year_reward(node)
log.info("block_reward: {} staking_reward: {}".format(block_reward, staking_reward))
# withdrew of pledge
result = client.staking.withdrew_staking(address)
assert_code(result, 0)
# wait settlement block
economic.wait_settlement(node)
# wait consensus block
economic.wait_consensus(node)
# count the number of blocks
blocknumber = economic.get_block_count_number(node, roundnum=6)
log.info("blocknumber: {}".format(blocknumber))
# view account amount again
# block_high = economic.get_switchpoint_by_settlement(node) - economic.settlement_size
benifit_balance1 = node.eth.getBalance(address1)
log.info("benifit_balance: {}".format(benifit_balance1))
reward = int(blocknumber * Decimal(str(block_reward)))
assert benifit_balance1 == benifit_balance + staking_reward + reward, "ErrMsg:benifit_balance: {}".format(
benifit_balance1)
if i == 0:
block_info = node.eth.getBlock(1)
log.info("block_info：{}".format(block_info))
first_timestamp = block_info['timestamp']
log.info("First block timestamp： {}".format(first_timestamp))
end_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000)
log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp))
else:
# Waiting for the end of the annual issuance cycle
end_cycle_timestamp = end_cycle_timestamp + (economic.additional_cycle_time * 60000)
log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp))
annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size
log.info("The last block height in the last issue cycle: {}".format(annual_last_block))
settlement_block_info = node.eth.getBlock(annual_last_block)
settlement_timestamp = settlement_block_info['timestamp']
log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp))
remaining_additional_time = end_cycle_timestamp - settlement_timestamp
log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time))
result = client.ppos.getAvgPackTime()
average_interval = result['Ret']
log.info("Block interval on the chain：{}".format(average_interval))
log.info("Block interval on the chain：{}".format(average_interval))
number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval)
log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks))
remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size)
log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle))
while remaining_settlement_cycle != 1:
tmp_current_block = node.eth.blockNumber
if tmp_current_block % economic.settlement_size == 0:
time.sleep(economic.interval)
tmp_current_block = node.eth.blockNumber
last_settlement_block = (math.ceil(
tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size
log.info("The last block height of the previous settlement period： {}".format(last_settlement_block))
settlement_block_info = node.eth.getBlock(last_settlement_block)
settlement_timestamp = settlement_block_info['timestamp']
log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp))
remaining_additional_time = end_cycle_timestamp - settlement_timestamp
log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time))
result = client.ppos.getAvgPackTime()
average_interval = result['Ret']
log.info("Block interval on the chain：{}".format(average_interval))
number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval)
log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks))
remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size)
log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle))
economic.wait_settlement(node)
def test_AL_FI_001_to_003(new_genesis_env, client_consensus, staking_cfg):
"""
AL_FI_001:查看每年释放补贴激励池变化
AL_FI_002:查看每年固定增发变化
AL_FI_003:第十年固定增发token分配
:param new_genesis_env:
:return:
"""
# Initialization genesis file Initial amount
account = client_consensus.economic.account
node_count = len(new_genesis_env.consensus_node_list)
default_pledge_amount = Web3.toWei(node_count * 150000, 'ether')
node = new_genesis_env.get_rand_node()
community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000
genesis = from_dict(data_class=Genesis, data=new_genesis_env.genesis_config)
genesis.economicModel.innerAcc.cdfBalance = community_amount
surplus_amount = str(10250000000000000000000000000 - community_amount - 200000000000000000000000000)
genesis.alloc = {
"lat1zqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrdyjj2v": {
"balance": "200000000000000000000000000"
},
"lat1rzw6lukpltqn9rk5k59apjrf5vmt2ncv8uvfn7": {
"balance": surplus_amount
}
}
new_file = new_genesis_env.cfg.env_tmp + "/genesis_1.0.0.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
client = get_client_consensus(new_genesis_env, staking_cfg)
economic = client.economic
node = client.node
# Query the initial amount of incentive pool
current_incentive_pool = 262215742000000000000000000
# Query the initial amount of a warehouse lock plan
init_foundationlockup = 259096239000000000000000000
# Issued token amount
init_token = 10000000000000000000000000000
# Query developer foundation initial amount
developer_foundation = 0
# Query the initial amount of the foundation
foundation_balance = 0
# Additional amount
total_amount_of_issuance = 0
remaining_settlement_cycle = 0
end_cycle_timestamp = None
# Annual issuance
for i in range(10):
if i == 0:
incentive_pool = current_incentive_pool
log.info("Amount of initial incentive pool： {}".format(incentive_pool))
foundation_lock_up = init_foundationlockup
log.info("Initial Lockup Plan Amount： {}".format(foundation_lock_up))
total_amount_of_issuance = int(init_token + Decimal(str(init_token)) / Decimal(str(40)))
log.info("Current year Total amount of issuance： {}".format(total_amount_of_issuance))
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(economic.account.raw_accounts[1]['address'], 0)
# Query current annual developer foundation amount
DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[2]['address'])
current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, 0)
# Query current annual fund amount
FOUNDATION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[3]['address'])
current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, 0)
log.info("{} Year Incentive Pool Address: {} Balance: {}".format(i + 1, current_annual_incentive_pool_amount, incentive_pool))
log.info('{} Year Foundation Address: {} Balance: {}'.format(i + 1, FOUNDATION_ADDRESS, foundation_balance))
log.info("{} Year Developer Foundation Address:{} Balance:{}".format(i + 1, DEVELOPER_FOUNDATAION_ADDRESS,developer_foundation))
log.info("{} Year Foundation Locking Address: {} Balance: {}".format(i + 1, node.ppos.restrictingAddress, foundation_lock_up))
assert current_annual_incentive_pool_amount == incentive_pool, "{} Year Incentive Pool Address: {} Balance: {}".format(
i + 1, economic.account.raw_accounts[1]['address'], incentive_pool)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Foundation Address:{} Balance:{}".format(
i + 1, economic.account.raw_accounts[3]['address'], developer_foundation)
assert current_annual_foundation_amount == foundation_balance, "{} Year Developer Foundation Address:{} Balance:{}".format(
i + 1, economic.account.raw_accounts[2]['address'], developer_foundation)
# log.info("{} Year additional Balance:{}".format(i + 1, total_amount_of_issuance))
time.sleep(5)
economic.wait_settlement(node)
while remaining_settlement_cycle != 1:
tmp_current_block = node.eth.blockNumber
if tmp_current_block % economic.settlement_size == 0:
time.sleep(1)
block_info = node.eth.getBlock(1)
log.info("block_info：{}".format(block_info))
first_timestamp = block_info['timestamp']
log.info("First block timestamp： {}".format(first_timestamp))
end_cycle_timestamp = first_timestamp + (economic.additional_cycle_time * 60000)
log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp))
last_settlement_block = (math.ceil(tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size
log.info("The last block height of the previous settlement period： {}".format(last_settlement_block))
settlement_block_info = node.eth.getBlock(last_settlement_block)
settlement_timestamp = settlement_block_info['timestamp']
log.info("High block timestamp at the end settlement cycle： {}".format(settlement_timestamp))
remaining_additional_time = end_cycle_timestamp - settlement_timestamp
log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time))
average_interval = (settlement_timestamp - first_timestamp) // (last_settlement_block - 1)
log.info("Block interval in the last settlement cycle： {}".format(average_interval))
number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval)
log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks))
remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size)
log.info(
"remaining settlement cycles in the current issuance cycle： {}".format(remaining_settlement_cycle))
economic.wait_settlement(node)
elif 0 < i < 9:
annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size
log.info("The last block height in the last issue cycle: {}".format(annual_last_block))
# Current annual total issuance
additional_amount = int(Decimal(str(total_amount_of_issuance)) / Decimal(str(40)))
log.info("Current annual quota： {}".format(additional_amount))
# Incentive pool additional amount
incentive_pool_additional_amount = int(Decimal(str(additional_amount)) * Decimal(str((80 / 100))))
log.info("Additional quota for the current annual incentive pool: {}".format(incentive_pool_additional_amount))
# developer foundation s additional amount
developer_foundation_s_additional_amount = additional_amount - incentive_pool_additional_amount
log.info("Current annual developer foundation additional quota: {}".format(developer_foundation_s_additional_amount))
# Total amount of additional issuance
total_amount_of_issuance = total_amount_of_issuance + additional_amount
log.info("Total current hairstyle：{}".format(total_amount_of_issuance))
# Current annual incentive pool amount
current_incentive_pool = current_incentive_pool + incentive_pool_additional_amount + EconomicConfig.release_info[i - 1]['amount']
log.info("Balance to be allocated for the current annual incentive pool：{}".format(current_incentive_pool))
# Current annual Developer Fund Amount
developer_foundation = developer_foundation + developer_foundation_s_additional_amount
log.info("Current Annual Developer Foundation Total： {}".format(developer_foundation))
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(economic.account.raw_accounts[1]['address'], annual_last_block)
# Query current annual developer foundation amount
DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[2]['address'])
current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, annual_last_block)
# Query current annual fund amount
FOUNDATION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[3]['address'])
current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, annual_last_block)
log.info("{} year initialization incentive pool address: {} balance: {}".format(i + 1, economic.account.raw_accounts[1]['address'],
current_incentive_pool))
log.info('{} Year Initialization Foundation Address: {} balance: {}'.format(i + 1,
economic.account.raw_accounts[3]['address'],
foundation_balance))
log.info("{} Year Developer Fund Address: {} balance: {}".format(i + 1,
economic.account.raw_accounts[2]['address'],
developer_foundation))
log.info("{} Year additional balance:{}".format(i + 1, additional_amount))
assert current_annual_incentive_pool_amount == current_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format(
i + 1, economic.account.raw_accounts[1]['address'], current_incentive_pool)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format(
i + 1, economic.account.raw_accounts[2]['address'], developer_foundation)
assert current_annual_foundation_amount == 0, '{} Year Initialization Foundation Address: {} balance: {}'.format(
i + 1, economic.account.raw_accounts[3]['address'], foundation_balance)
# Waiting for the end of the annual issuance cycle
end_cycle_timestamp = end_cycle_timestamp + (economic.additional_cycle_time * 60000)
log.info("End time stamp of current issue cycle： {}".format(end_cycle_timestamp))
settlement_block_info = node.eth.getBlock(annual_last_block)
settlement_timestamp = settlement_block_info['timestamp']
log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp))
remaining_additional_time = end_cycle_timestamp - settlement_timestamp
log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time))
result = client.ppos.getAvgPackTime()
average_interval = result['Ret']
log.info("Block interval on the chain：{}".format(average_interval))
log.info("Block interval on the chain：{}".format(average_interval))
number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval)
log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks))
remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size)
log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle))
while remaining_settlement_cycle != 1:
tmp_current_block = node.eth.blockNumber
if tmp_current_block % economic.settlement_size == 0:
time.sleep(economic.interval)
tmp_current_block = node.eth.blockNumber
last_settlement_block = (math.ceil(
tmp_current_block / economic.settlement_size) - 1) * economic.settlement_size
log.info("The last block height of the previous settlement period： {}".format(last_settlement_block))
settlement_block_info = node.eth.getBlock(last_settlement_block)
settlement_timestamp = settlement_block_info['timestamp']
log.info("High block timestamp at the end of settlement cycle： {}".format(settlement_timestamp))
remaining_additional_time = end_cycle_timestamp - settlement_timestamp
log.info("Remaining time of current issuance cycle： {}".format(remaining_additional_time))
result = client.ppos.getAvgPackTime()
average_interval = result['Ret']
log.info("Block interval on the chain：{}".format(average_interval))
number_of_remaining_blocks = math.ceil(remaining_additional_time / average_interval)
log.info("Remaining block height of current issuance cycle： {}".format(number_of_remaining_blocks))
remaining_settlement_cycle = math.ceil(number_of_remaining_blocks / economic.settlement_size)
log.info("remaining settlement cycles issuance cycle： {}".format(remaining_settlement_cycle))
economic.wait_settlement(node)
else:
annual_last_block = (math.ceil(node.eth.blockNumber / economic.settlement_size) - 1) * economic.settlement_size
# Current annual total issuance
additional_amount = int(Decimal(str(total_amount_of_issuance)) / Decimal(str(40)))
# Incentive pool additional amount
incentive_pool_additional_amount = int(Decimal(str(additional_amount)) * Decimal(str((80 / 100))))
# developer foundation s additional amount
developer_foundation_s_additional_amount = int(
Decimal(str(additional_amount - incentive_pool_additional_amount)) * Decimal(str((50 / 100))))
# Foundation grant additional amount
foundation_grant_amount = additional_amount - incentive_pool_additional_amount - developer_foundation_s_additional_amount
# Total amount of additional issuance
total_amount_of_issuance = total_amount_of_issuance + additional_amount
# Current annual incentive pool amount
current_incentive_pool = current_incentive_pool + incentive_pool_additional_amount
# Current annual Developer Fund Amount
developer_foundation = developer_foundation + developer_foundation_s_additional_amount
# Current annual fund amount
foundation_balance = foundation_balance + foundation_grant_amount
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(economic.account.raw_accounts[1]['address'], annual_last_block)
# Query current annual developer foundation amount
DEVELOPER_FOUNDATAION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[2]['address'])
current_annual_developer_foundation_amount = node.eth.getBalance(DEVELOPER_FOUNDATAION_ADDRESS, annual_last_block)
# Query current annual fund amount
FOUNDATION_ADDRESS = node.web3.toChecksumAddress(economic.account.raw_accounts[3]['address'])
current_annual_foundation_amount = node.eth.getBalance(FOUNDATION_ADDRESS, annual_last_block)
log.info("{} year initialization incentive pool address: {} balance: {}".format(i + 1,
economic.account.raw_accounts[1]['address'],
current_incentive_pool))
log.info('{} Year Initialization Foundation Address: {} balance: {}'.format(i + 1,
economic.account.raw_accounts[3]['address'],
foundation_balance))
log.info("{} Year Developer Fund Address: {} balance: {}".format(i + 1,
economic.account.raw_accounts[2]['address'],
developer_foundation))
log.info("{} Year additional balance:{}".format(i + 1, additional_amount))
assert current_annual_incentive_pool_amount == current_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format(
i + 1, economic.account.raw_accounts[1]['address'], current_incentive_pool)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format(
i + 1, economic.account.raw_accounts[2]['address'], developer_foundation)
assert current_annual_foundation_amount == foundation_balance, '{} Year Initialization Foundation Address: {} balance: {}'.format(
i + 1, economic.account.raw_accounts[3]['address'], foundation_balance)
def AL_FI_004_005(new_genesis_env, staking_cfg):
"""
AL_FI_004:查看每年区块奖励变化
AL_FI_005:查看每年质押奖励变化
:param new_genesis_env:
:param staking_cfg:
:return:
"""
# Initialization genesis file Initial amount
node_count = len(new_genesis_env.consensus_node_list)
default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether')
community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000
genesis = from_dict(data_class=Genesis,
data=new_genesis_env.genesis_config)
genesis.economicModel.innerAcc.cdfBalance = community_amount
surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount -
200000000000000000000000000)
genesis.alloc = {
"1000000000000000000000000000000000000003": {
"balance": "200000000000000000000000000"
},
"0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": {
"balance": surplus_amount
}
}
new_file = new_genesis_env.cfg.env_tmp + "/genesis.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
normal_node = new_genesis_env.get_a_normal_node()
client1 = Client(new_genesis_env, normal_node, staking_cfg)
economic = client1.economic
node = client1.node
log.info("Current connection node：{}".format(node.node_mark))
log.info("Current connection nodeid：{}".format(node.node_id))
address, _ = client1.economic.account.generate_account(
node.web3, von_amount(economic.create_staking_limit, 2))
log.info("address: {}".format(address))
address1, _ = client1.economic.account.generate_account(node.web3, 0)
log.info("address1: {}".format(address1))
for i in range(10):
current_block = node.eth.blockNumber
log.info("Current query block height： {}".format(node.eth.blockNumber))
annualcycle = (economic.additional_cycle_time *
60) // economic.settlement_size
annual_size = annualcycle * economic.settlement_size
starting_block_height = math.floor(
current_block / annual_size) * annual_size
amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS,
starting_block_height)
log.info("Current annual incentive pool amount: {}".format(amount))
# if i == 0:
# current_annual_incentive_pool_amount = 262215742000000000000000000
# else:
# current_annual_incentive_pool_amount = node.eth.getBalance(EconomicConfig.INCENTIVEPOOL_ADDRESS)
# log.info("Current annual incentive pool amount: {}".format(current_annual_incentive_pool_amount))
# Free amount application pledge node
result = client1.staking.create_staking(0, address1, address)
assert_code(result, 0)
# view account amount
benifit_balance = node.eth.getBalance(address1)
log.info("benifit_balance: {}".format(benifit_balance))
# Wait for the settlement round to end
economic.wait_settlement_blocknum(node)
# 获取当前结算周期验证人
verifier_list = node.ppos.getVerifierList()
log.info("verifier_list: {}".format(verifier_list))
# view block_reward
block_reward, staking_reward = economic.get_current_year_reward(
node, amount=amount)
log.info("block_reward: {} staking_reward: {}".format(
block_reward, staking_reward))
# withdrew of pledge
result = client1.staking.withdrew_staking(address)
assert_code(result, 0)
# wait settlement block
client1.economic.wait_settlement_blocknum(node)
# wait consensus block
client1.economic.wait_consensus_blocknum(node)
# count the number of blocks
blocknumber = client1.economic.get_block_count_number(client1.node, 10)
log.info("blocknumber: {}".format(blocknumber))
# view account amount again
benifit_balance1 = node.eth.getBalance(address1)
log.info("benifit_balance: {}".format(benifit_balance1))
reward = int(blocknumber * Decimal(str(block_reward)))
assert benifit_balance1 == benifit_balance + staking_reward + reward, "ErrMsg:benifit_balance: {}".format(
benifit_balance1)
# Waiting for the end of the annual increase
economic.wait_annual_blocknum(node)
def AL_FI_001_to_003(new_genesis_env, staking_cfg):
"""
AL_FI_001:查看每年释放补贴激励池变化
AL_FI_002:查看每年固定增发变化
AL_FI_003:第十年固定增发token分配
:param new_genesis_env:
:return:
"""
# Initialization genesis file Initial amount
node_count = len(new_genesis_env.consensus_node_list)
default_pledge_amount = Web3.toWei(node_count * 1500000, 'ether')
community_amount = default_pledge_amount + 259096239000000000000000000 + 62215742000000000000000000
genesis = from_dict(data_class=Genesis,
data=new_genesis_env.genesis_config)
genesis.economicModel.innerAcc.cdfBalance = community_amount
surplus_amount = str(EconomicConfig.TOKEN_TOTAL - community_amount -
200000000000000000000000000)
genesis.alloc = {
"1000000000000000000000000000000000000003": {
"balance": "200000000000000000000000000"
},
"0x2e95E3ce0a54951eB9A99152A6d5827872dFB4FD": {
"balance": surplus_amount
}
}
new_file = new_genesis_env.cfg.env_tmp + "/genesis.json"
genesis.to_file(new_file)
new_genesis_env.deploy_all(new_file)
client = get_client_consensus_obj(new_genesis_env, staking_cfg)
economic = client.economic
node = client.node
# Query the initial amount of incentive pool
init_incentive_pool = 262215742000000000000000000
# Query the initial amount of a warehouse lock plan
init_foundationlockup = 259096239000000000000000000
# Issued token amount
init_token = 10000000000000000000000000000
# Query developer foundation initial amount
developer_foundation = 0
# Query the initial amount of the foundation
FOUNDATION = 0
# Additional amount
init_tt = 0
# Annual issuance
for i in range(10):
if i == 0:
INCENTIVEPOOL = init_incentive_pool
FOUNDATIONLOCKUP = init_foundationlockup
init_tt = int(init_token +
Decimal(str(init_token)) / Decimal(str(40)))
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(
EconomicConfig.INCENTIVEPOOL_ADDRESS, 0)
# Query current annual developer foundation amount
current_annual_developer_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(
EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS), 0)
# Query current annual fund amount
current_annual_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS),
0)
log.info("{} Year Incentive Pool Address: {} Balance: {}".format(
i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, INCENTIVEPOOL))
log.info('{} Year Foundation Address: {} Balance: {}'.format(
i + 1, EconomicConfig.FOUNDATION_ADDRESS, FOUNDATION))
log.info(
"{} Year Developer Foundation Address:{} Balance:{}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation))
log.info(
"{} Year Foundation Locking Address: {} Balance: {}".format(
i + 1, EconomicConfig.FOUNDATION_LOCKUP_ADDRESS,
FOUNDATIONLOCKUP))
assert current_annual_incentive_pool_amount == init_incentive_pool, "{} Year Incentive Pool Address: {} Balance: {}".format(
i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS, INCENTIVEPOOL)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Foundation Address:{} Balance:{}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation)
assert current_annual_foundation_amount == FOUNDATION, "{} Year Developer Foundation Address:{} Balance:{}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation)
log.info("{} Year additional Balance:{}".format(i + 1, init_tt))
# Waiting for the end of the annual issuance cycle
economic.wait_annual_blocknum(node)
elif 0 < i < 9:
FOUNDATION = 0
# Current annual total issuance
additional_amount = int(Decimal(str(init_tt)) / Decimal(str(40)))
# Incentive pool additional amount
incentive_pool_additional_amount = int(
Decimal(str(additional_amount)) * Decimal(str((80 / 100))))
# developer foundation s additional amount
developer_foundation_s_additional_amount = additional_amount - incentive_pool_additional_amount
# Total amount of additional issuance
init_tt = init_tt + additional_amount
# Current annual incentive pool amount
init_incentive_pool = init_incentive_pool + incentive_pool_additional_amount + EconomicConfig.release_info[
i - 1]['amount']
# Current annual Developer Fund Amount
developer_foundation = developer_foundation + developer_foundation_s_additional_amount
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(
EconomicConfig.INCENTIVEPOOL_ADDRESS)
# Query current annual developer foundation amount
current_annual_developer_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(
EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS))
# Query current annual fund amount
current_annual_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS))
log.info(
"{} year initialization incentive pool address: {} balance: {}"
.format(i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS,
init_incentive_pool))
log.info(
'{} Year Initialization Foundation Address: {} balance: {}'.
format(i + 1, EconomicConfig.FOUNDATION_ADDRESS, FOUNDATION))
log.info("{} Year Developer Fund Address: {} balance: {}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation))
log.info("{} Year additional balance:{}".format(
i + 1, additional_amount))
assert current_annual_incentive_pool_amount == init_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format(
i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS,
init_incentive_pool)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation)
assert current_annual_foundation_amount == 0, '{} Year Initialization Foundation Address: {} balance: {}'.format(
i + 1, EconomicConfig.FOUNDATION_ADDRESS, FOUNDATION)
# Waiting for the end of the annual issuance cycle
economic.wait_annual_blocknum(node)
else:
# Current annual total issuance
additional_amount = int(Decimal(str(init_tt)) / Decimal(str(40)))
# Incentive pool additional amount
incentive_pool_additional_amount = int(
Decimal(str(additional_amount)) * Decimal(str((80 / 100))))
# developer foundation s additional amount
developer_foundation_s_additional_amount = int(
Decimal(
str(additional_amount - incentive_pool_additional_amount))
* Decimal(str((50 / 100))))
# Foundation grant additional amount
foundation_grant_amount = additional_amount - incentive_pool_additional_amount - developer_foundation_s_additional_amount
# Total amount of additional issuance
init_tt = init_tt + additional_amount
# Current annual incentive pool amount
init_incentive_pool = init_incentive_pool + incentive_pool_additional_amount
# Current annual Developer Fund Amount
developer_foundation = developer_foundation + developer_foundation_s_additional_amount
# Current annual fund amount
FOUNDATION = FOUNDATION + foundation_grant_amount
# Query the current annual incentive pool amount
current_annual_incentive_pool_amount = node.eth.getBalance(
EconomicConfig.INCENTIVEPOOL_ADDRESS)
# Query current annual developer foundation amount
current_annual_developer_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(
EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS))
# Query current annual fund amount
current_annual_foundation_amount = node.eth.getBalance(
node.web3.toChecksumAddress(EconomicConfig.FOUNDATION_ADDRESS))
log.info(
"{} year initialization incentive pool address: {} balance: {}"
.format(i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS,
init_incentive_pool))
log.info(
'{} Year Initialization Foundation Address: {} balance: {}'.
format(i + 1, EconomicConfig.FOUNDATION_ADDRESS, FOUNDATION))
log.info("{} Year Developer Fund Address: {} balance: {}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation))
log.info("{} Year additional balance:{}".format(
i + 1, additional_amount))
assert current_annual_incentive_pool_amount == init_incentive_pool, "{} year initialization incentive pool address: {} balance: {}".format(
i + 1, EconomicConfig.INCENTIVEPOOL_ADDRESS,
init_incentive_pool)
assert current_annual_developer_foundation_amount == developer_foundation, "{} Year Developer Fund Address: {} balance: {}".format(
i + 1, EconomicConfig.DEVELOPER_FOUNDATAION_ADDRESS,
developer_foundation)
assert current_annual_foundation_amount == FOUNDATION, '{} Year Initialization Foundation Address: {} balance: {}'.format(
i + 1, EconomicConfig.FOUNDATION_ADDRESS, FOUNDATION)
def test_owe_amountstack_lock_plan(self):
'''
到达解锁时间点，如果账户锁仓不足再新增新的锁仓计划
:return:
'''
nodeId = CommonMethod.get_no_candidate_list (self)
url = CommonMethod.link_list (self)
platon_ppos = Ppos (url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list ()
address2, private_key2 = CommonMethod.read_private_key_list ()
# 签名转账
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address1),
self.base_gas_price, self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账：{}失败".format (self.value)
# 创建锁仓计划
lockupamoutn = 500
loukupbalace = Web3.toWei (lockupamoutn, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format (result['Status'])
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态：{},用例失败".format (result['Status'])
# 给锁仓账号转手续费
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address2),
self.base_gas_price, self.base_gas, self.value,
self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账：{}失败".format (self.value)
balance = platon_ppos.eth.getBalance(address2)
log.info("锁仓账户余额：{}".format(balance))
# 申请质押节点
version = get_version (platon_ppos)
amount = 500
result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details',
amount, version, privatekey=private_key2, from_address=address2,
gasPrice=self.base_gas_price, gas=self.staking_gas)
assert result['Status'] == True, "申请质押返回的状态：{},{},用例失败".format (result['Status'], result['ErrMsg'])
#到达解锁期释放锁仓金额
CommonMethod.get_next_settlement_interval (self)
platon_ppos.GetRestrictingInfo(address2)
balance = platon_ppos.eth.getBalance(address2)
log.info("到达解锁期释放锁仓余额：{}".format(balance))
# 创建锁仓计划
lockupamoutn = 100
loukupbalace = Web3.toWei (lockupamoutn, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format (result['Status'])
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态：{},用例失败".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == Web3.toWei (100, 'ether'), "锁仓金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == True, "锁仓的状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == Web3.toWei (500, 'ether'), "欠释放锁仓金额：{} 有误".format (dict_Info['debt'])
def test_eliminated_verifier_create_lockup(self):
'''
验证人违规被剔除验证人列表，申请质押节点
:return:
'''
nodeId = CommonMethod.get_no_candidate_list (self)
url = CommonMethod.link_list (self)
platon_ppos = Ppos (url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list ()
# 签名转账
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address1),
self.base_gas_price, self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账：{}失败".format (self.value)
balance = platon_ppos.eth.getBalance (address1)
log.info ("{}发起锁仓账户余额:{}".format (address1,balance))
# 创建锁仓计划
lockupamoutn = 900
loukupbalace = Web3.toWei (lockupamoutn, 'ether')
plan = [{'Epoch': 5, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address1, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format (result['Status'])
RestrictingInfo = platon_ppos.GetRestrictingInfo (address1)
assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态：{},用例失败".format (result['Status'])
# 申请质押节点
version = get_version (platon_ppos)
amount = 200
result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details',
amount, version, privatekey=private_key1, from_address=address1,
gasPrice=self.base_gas_price, gas=self.staking_gas)
assert result['Status'] == True, "申请质押返回的状态：{},{},用例失败".format (result['Status'], result['ErrMsg'])
result = platon_ppos.getCandidateInfo(nodeId)
log.info("质押节点信息：{}".format(result))
# 等待成为共识验证人
CommonMethod.get_next_settlement_interval (self)
CandidateInfo = platon_ppos.getCandidateInfo(nodeId)
log.info("验证人信息{}".format(CandidateInfo))
VerifierList = platon_ppos.getVerifierList ()
log.info ("当前验证人列表：{}".format (VerifierList))
ValidatorList = platon_ppos.getValidatorList()
log.info("当前共识验证人列表：{}".format(ValidatorList))
# for dictinfo in CandidateInfo['Data']:
# if nodeId == dictinfo['NodeId']:
# log.info("节点id：{}已成为共识验证人".format(nodeId))
# break
# else:
# log.info("节点id：{}未成为共识验证人".format(nodeId))
# status=0
# assert status == 1
# 获取节点内置质押节点信息
con_node, no_node = get_node_list (self.node_yml_path)
nodes = con_node + no_node
for node in nodes:
if nodeId in node.values ():
node_data = node
# 停止其中一个正在出块的节点信息
self.auto = AutoDeployPlaton ()
self.auto.kill (node_data)
platon_ppos1 = connect_web3 (node_data['url'])
assert not platon_ppos1.isConnected (), "节点：{} 连接异常".format (node_data['host'])
# 等待节点被剔除验证人列表
CommonMethod.get_next_consensus_wheel (self,2)
# 申请质押节点
version = get_version (platon_ppos)
amount = 200
result = platon_ppos.createStaking (1, address1, nodeId, 'externalId', 'nodeName', 'website', 'details',
amount, version, privatekey=private_key1, from_address=address1,
gasPrice=self.base_gas_price, gas=self.staking_gas)
assert result['Status'] == False, "申请质押返回的状态：{},用例失败".format (result['Status'])
def test_unlock_point_pledge_punish_amount(self):
'''
到达解锁期后处罚节点后锁仓账户的余额情况
:return:
'''
nodeId = CommonMethod.get_no_candidate_list (self)
log.info("质押节点ID：{}".format(nodeId))
url = CommonMethod.link_list (self)
platon_ppos = Ppos (url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list ()
address2, private_key2 = CommonMethod.read_private_key_list ()
# 给发起锁仓账户转手续费
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address1),
self.base_gas_price, self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账：{}失败".format (self.value)
# 给发起质押账号转手续费
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address2),
self.base_gas_price, self.base_gas, self.value,
self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账：{}失败".format (self.value)
Balance = platon_ppos.eth.getBalance (address1)
log.info ("{}账户余额：{}".format (address1, Balance))
Balance1 = platon_ppos.eth.getBalance (address1)
log.info ("{}账号余额：{}".format (address2, Balance1))
# 创建锁仓计划
lockupamoutn = 900
loukupbalace = Web3.toWei (lockupamoutn, 'ether')
plan = [{'Epoch': 3, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format (result['Status'])
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态：{},用例失败".format (result['Status'])
Balance2 = platon_ppos.eth.getBalance (address1)
log.info ("{}发起锁仓后账户余额：{}".format (address1, Balance2))
# 申请质押节点
version = get_version (platon_ppos)
amount = 900
result = platon_ppos.createStaking (1, address2, nodeId, 'externalId', 'nodeName', 'website', 'details',
amount, version, privatekey=private_key2, from_address=address2,
gasPrice=self.base_gas_price, gas=self.staking_gas)
assert result['Status'] == True, "申请质押返回的状态：{},{},用例失败".format (result['Status'], result['ErrMsg'])
platon_ppos.GetRestrictingInfo(address2)
result = platon_ppos.getCandidateInfo(nodeId)
assert result['Status'] == True, "获取质押节点返回状态为:{} 有误".format (result['Status'])
RestrictingPlan = result['Data']['RestrictingPlanHes']
assert RestrictingPlan == Web3.toWei (amount, 'ether'),'质押金额：{} 有误'.format(RestrictingPlan)
Balance3 = platon_ppos.eth.getBalance (address2)
log.info ("{}质押完锁仓账户余额：{}".format (address2,Balance3))
#等待验证人加入共识出块节点
CommonMethod.get_next_settlement_interval (self,1)
Balance4 = platon_ppos.eth.getBalance (address2)
log.info ("{}加入共识验证人后账户余额：{}".format (address2, Balance4))
# 获取节点内置质押节点信息
con_node, no_node = get_node_list (self.node_yml_path)
nodes = con_node + no_node
for node in nodes:
if nodeId in node.values ():
node_data = node
log.info("{}质押节点信息：{}".format(address2,node_data))
#停止质押节点
self.auto = AutoDeployPlaton ()
self.auto.kill (node_data)
platon_ppos1 = connect_web3 (node_data['url'])
assert not platon_ppos1.isConnected(),"节点：{} 连接异常".format(node_data['host'])
# 到达解锁期后处罚节点后锁仓账户
CommonMethod.get_next_settlement_interval (self,1)
Balance5 = platon_ppos.eth.getBalance (address2)
log.info ("{}到达解锁期后处罚节点后预期账户余额：{}".format (address2,Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether')))
log.info ("{}到达解锁期后处罚节点后实际账户余额：{}".format (address2,Balance5))
result = platon_ppos.getCandidateInfo(nodeId)
assert Balance5 == Balance4 + Web3.toWei (amount-(amount * 0.2), 'ether'), "锁仓账户金额：{} 有误".format (Balance4)
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == 0, "锁仓计划可用金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == True, "欠释放状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == Web3.toWei (amount-(amount * 0.2), 'ether'), "欠释放锁仓金额：{} 有误".format (dict_Info['debt'])
def test_unlock_point_delegtion_notbalance(self):
'''
1、到达解锁时间点用锁仓金额去委托节点，到达解锁期账户锁仓不足
2、到达解锁期账户申请部分赎回委托
3、全部赎回委托
:return:
'''
nodeId = CommonMethod.get_no_candidate_list (self)
url = CommonMethod.link_list (self)
platon_ppos = Ppos (url, self.address, self.chainid)
address1, private_key1 = CommonMethod.read_private_key_list ()
address2, private_key2 = CommonMethod.read_private_key_list ()
# 签名转账
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address1),
self.base_gas_price, self.base_gas, self.value, self.privatekey)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账质押账号手续费：{}失败".format (self.value)
# 给锁仓账号转手续费
result = platon_ppos.send_raw_transaction ('', Web3.toChecksumAddress (self.address),
Web3.toChecksumAddress (address2),
self.base_gas_price, self.base_gas, self.value,
conf.PRIVATE_KEY)
return_info = platon_ppos.eth.waitForTransactionReceipt (result)
assert return_info is not None, "转账锁仓账号手续费：{}失败".format (self.value)
Balance = platon_ppos.eth.getBalance (address1)
log.info ("{}发起锁仓账户余额：{}".format (address1, Balance))
Balance1 = platon_ppos.eth.getBalance (address1)
log.info ("{}发起质押账号余额：{}".format (address2, Balance1))
# 申请质押节点
version = get_version (platon_ppos)
amount = 100
result = platon_ppos.createStaking (0, address1, nodeId, 'externalId', 'nodeName', 'website', 'details',
amount, version, privatekey=private_key1, from_address=address1,
gasPrice=self.base_gas_price, gas=self.staking_gas)
assert result['Status'] == True, "申请质押返回的状态：{},{},用例失败".format (result['Status'], result['ErrMsg'])
Balance2 = platon_ppos.eth.getBalance (address1)
log.info ("{}申请质押节点后账户余额：{}".format (address1, Balance2))
# 创建锁仓计划
lockupamoutn = 100
loukupbalace = Web3.toWei (lockupamoutn, 'ether')
plan = [{'Epoch': 1, 'Amount': loukupbalace}]
result = platon_ppos.CreateRestrictingPlan (address2, plan, privatekey=private_key1,
from_address=address1, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert result['Status'] == True, "创建锁仓计划返回的状态：{},用例失败".format (result['Status'])
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态：{},用例失败".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == loukupbalace, "锁仓计划金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == False, "锁仓的状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == 0, "欠释放锁仓金额：{} 有误".format (dict_Info['debt'])
Balance3 = platon_ppos.eth.getBalance (address1)
log.info ("{}创建锁仓计划后账户余额：{}".format (address1, Balance3))
# 申请委托验证人节点
amount = 100
result = platon_ppos.delegate (1, nodeId, amount, privatekey=private_key2, from_address=address2,
gasPrice=self.base_gas_price, gas=self.staking_gas)
log.info ("申请委托地址：{}".format (address2))
assert result['Status'] == True, "申请委托返回的状态：{},用例失败".format (result['Status'])
balance4 = platon_ppos.eth.getBalance (address2)
log.info ("{}申请委托验证人节点后账户余额：{}".format (address2,balance4))
# 到达解锁期之后锁仓账号余额
CommonMethod.get_next_settlement_interval (self)
balance5 = platon_ppos.eth.getBalance (address2)
log.info ("{}到达解锁期后实际账户余额：{}".format (address2,balance5))
assert balance5 == balance4, "锁仓账户金额：{} 有误".format (balance5)
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == 0, "锁仓金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == True, "锁仓的状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == loukupbalace, "欠释放锁仓金额：{} 有误".format (dict_Info['debt'])
#申请赎回部分委托金
partamount = 50
msg = platon_ppos.getCandidateInfo (nodeId)
stakingBlockNum = msg["Data"]["StakingBlockNum"]
delegate_info = platon_ppos.unDelegate (stakingBlockNum, nodeId, partamount, privatekey=private_key2,
from_address=address2, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert delegate_info['Status'] == True, "申请赎回委托返回的状态：{},用例失败".format (result['Status'])
balance6 = platon_ppos.eth.getBalance (address2)
log.info ("{}到达解锁期发起赎回部分委托后账户余额：{}".format (address2,balance6))
#到达下个解锁期释放部分委托金
CommonMethod.get_next_settlement_interval (self)
balance7 = platon_ppos.eth.getBalance (address2)
log.info ("赎回部分委托金后锁仓账户余额：{}".format (balance7))
assert balance7 == balance6 + Web3.toWei (partamount, 'ether'),"到达解锁期赎回部分委托后账户余额：{}".format (balance7)
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == 0, "锁仓金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == True, "锁仓的状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == loukupbalace - Web3.toWei (partamount, 'ether'), "欠释放锁仓金额：{} 有误".format (dict_Info[ 'debt'])
#申请赎回全部委托金
delegate_info = platon_ppos.unDelegate (stakingBlockNum, nodeId, lockupamoutn - partamount, privatekey=private_key2,
from_address=address2, gasPrice=self.base_gas_price,
gas=self.staking_gas)
assert delegate_info['Status'] == True, "申请赎回委托返回的状态：{},用例失败".format (result['Status'])
balance8 = platon_ppos.eth.getBalance (address2)
log.info ("{}赎回全部委托金后锁仓账户余额：{}".format (address2,balance8))
#到达下个解锁期释放全部委托金
CommonMethod.get_next_settlement_interval (self)
balance9 = platon_ppos.eth.getBalance (address2)
log.info ("{}赎回全部委托金后实际账户余额：{}".format (address2,balance9))
log.info ("{}赎回全部委托金后预期账户余额：{}".format (address2,balance8 + Web3.toWei (lockupamoutn - partamount, 'ether')))
assert balance9 == balance8 + loukupbalace - Web3.toWei (partamount, 'ether'), "到达解锁期赎回委托后账户余额：{}".format (balance9)
RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
dict_Info = json.loads (RestrictingInfo['Data'])
assert dict_Info['balance'] == 0, "锁仓金额：{}有误".format (dict_Info['balance'])
assert dict_Info['symbol'] == False, "锁仓的状态：{} 有误".format (dict_Info['symbol'])
assert dict_Info['debt'] == 0, "欠释放锁仓金额：{} 有误".format (dict_Info['debt'])