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'])