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)
Esempio n. 2
0
    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)
Esempio n. 3
0
 def test_init_loukup(self):
     '''
     查询初始化链后基金会锁仓金额
     以及查询初始锁仓计划信息的有效性
     :return:
     '''
     url = CommonMethod.link_list(self)
     platon_ppos = Ppos(url, self.address, self.chainid)
     lockupbalance = platon_ppos.eth.getBalance(
         conf.FOUNDATIONLOCKUPADDRESS)
     FOUNDATIONLOCKUP = self.initial_amount['FOUNDATIONLOCKUP']
     assert lockupbalance == FOUNDATIONLOCKUP
     result = platon_ppos.GetRestrictingInfo(conf.INCENTIVEPOOLADDRESS)
     assert result['Status'] == True, ",锁仓计划信息查询状态为{}".format(
         result['Status'])
     dict_info = json.loads(result['Data'])
     assert dict_info['balance'] == self.initial_amount[
         'FOUNDATIONLOCKUP'], '锁仓初始金额{}有误'.format(lockupbalance)
    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'])
    def test_unlock_point_pledge_amount(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)

        # 给锁仓账号转手续费
        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': 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'])
        info = json.loads(RestrictingInfo['Data'])
        assert info['balance'] == loukupbalace,"锁仓计划可用余额:{},有误".format(info['balance'])
        balance2 = platon_ppos.eth.getBalance (address1)
        log.info ("{}创建锁仓后余额:{}".format (address1,balance2))

        # 申请质押节点
        version = get_version (platon_ppos)
        amount = 800
        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'])
        balance3 = platon_ppos.eth.getBalance (address2)
        log.info ("{}质押完账户余额:{}".format (address2,balance3))
        RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
        assert RestrictingInfo['Status'] == True, "获取锁仓计划返回状态为:{} 有误".format (result['Status'])
        dict_Info = json.loads (RestrictingInfo['Data'])
        assert dict_Info['balance'] == Web3.toWei(lockupamoutn - amount,'ether'), "锁仓金额:{}有误".format (dict_Info['balance'])

        # 到达解锁期之后锁仓账号余额
        CommonMethod.get_next_settlement_interval (self)
        balance4 = platon_ppos.eth.getBalance (address2)
        log.info("到达解锁期后预期账户余额:{}".format(balance3 + Web3.toWei(lockupamoutn - amount,'ether')))
        log.info("到达解锁期后实际账户余额:{}".format (balance4))
        assert balance4 == balance3 + Web3.toWei(lockupamoutn - amount,'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,'ether'),"欠释放锁仓金额:{} 有误".format(dict_Info['debt'])

        # 申请退回质押金
        result = platon_ppos.unStaking (nodeId, privatekey=private_key2, from_address=address2,
                                        gasPrice=self.base_gas_price, gas=self.staking_gas)
        assert result['Status'] == True, "申请质押退回质押金返回的状态:{},用例失败".format (result['Status'])
        balance5 = platon_ppos.eth.getBalance (address2)
        log.info ("到达解锁期申请退回质押金后账户余额:{}".format (balance5))

        # 等待两个结算周期后查询锁仓账号情况
        CommonMethod.get_next_settlement_interval (self,3)
        RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
        balance6 = platon_ppos.eth.getBalance (address2)
        log.info ("到达解锁期退回质押金后预期账户金额:{}".format (balance5 + loukupbalace))
        log.info ("到达解锁期退回质押金后实际账户余额:{}".format (balance6))
        assert balance6 == balance5 + loukupbalace, "锁仓账户金额:{} 有误".format (balance6)
        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'])
Esempio n. 9
0
    def test_lockup_redemption_of_entrust(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_info2 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info2 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)

        # 申请质押节点
        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'])

        # 创建锁仓计划
        loukupbalace = Web3.toWei(500, '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'])

        balance = platon_ppos.eth.getBalance(address2)
        log.info("发起锁仓账户余额:{}".format(balance))
        lockup_before = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("申请委托之前锁仓账户金额:{}".format(lockup_before))
        Staking_before = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("申请委托之前Staking账户金额:{}".format(Staking_before))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        RestrictingInfo = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(RestrictingInfo['balance']))

        #申请委托验证人节点
        amount = 500
        delegate_info = platon_ppos.delegate(1,
                                             nodeId,
                                             amount,
                                             privatekey=private_key2,
                                             from_address=address2,
                                             gasPrice=self.base_gas_price,
                                             gas=self.staking_gas)
        assert delegate_info['Status'] == True, "申请委托返回的状态:{},用例失败".format(
            result['Status'])

        lockup_back_before = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("申请委托之后锁仓账户金额:{}".format(lockup_back_before))
        Staking_back_before = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("申请委托之后Staking账户金额:{}".format(Staking_back_before))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        RestrictingInfo = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(RestrictingInfo['balance']))

        #申请赎回委托
        msg = platon_ppos.getCandidateInfo(nodeId)
        stakingBlockNum = msg["Data"]["StakingBlockNum"]
        delegate_info = platon_ppos.unDelegate(stakingBlockNum,
                                               nodeId,
                                               amount,
                                               privatekey=private_key2,
                                               from_address=address2,
                                               gasPrice=self.base_gas_price,
                                               gas=self.staking_gas)
        assert delegate_info['Status'] == True, "申请赎回委托返回的状态:{},用例失败".format(
            result['Status'])

        lockup_end = platon_ppos.eth.getBalance(conf.FOUNDATIONLOCKUPADDRESS)
        log.info("赎回委托之后锁仓账户金额:{}".format(lockup_end))
        Staking_end = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("赎回委托之后Staking账户金额:{}".format(Staking_end))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        Info = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划余额:{}".format(Info['balance']))

        assert lockup_end == lockup_before, "质押金退回后锁仓金额:{}有误".format(
            lockup_end)
        assert Staking_end == Staking_before, "质押金退回后Staking金额:{}有误".format(
            Staking_end)
        assert Info['balance'] == loukupbalace, "锁仓计划金额:{}有误".format(
            RestrictingInfo['balance'])
Esempio n. 10
0
    def test_lockup_Withdrawal_of_pledge(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_info2 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info2 is not None, "转账:{}失败".format(self.value)

        # 创建锁仓计划
        balance = platon_ppos.eth.getBalance(address1)
        log.info("发起锁仓账户余额:{}".format(balance))
        loukupbalace = Web3.toWei(800, 'ether')
        plan = [{'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'])
        # RestrictingInfo = platon_ppos.GetRestrictingInfo (address2)
        # assert RestrictingInfo['Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format (result['Status'])

        lockup_before = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("申请质押节点之前锁仓账户金额:{}".format(lockup_before))
        Staking_before = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("申请质押节点之前Staking账户金额:{}".format(Staking_before))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        RestrictingInfo = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(RestrictingInfo['balance']))

        # 签名转账
        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_info2 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info2 is not None, "转账:{}失败".format(self.value)

        # 发起质押
        version = get_version(platon_ppos)
        amount = 800
        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'])

        #查询每个账户余额
        CandidateInfo = platon_ppos.getCandidateInfo(nodeId)
        log.info("质押节点信息:{}".format(CandidateInfo))
        lockup_Back_before = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("退回质押金之前锁仓账户金额:{}".format(lockup_Back_before))
        Staking_Back_before = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("退回质押金之前Staking账户金额:{}".format(Staking_Back_before))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        RestrictingInfo = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(RestrictingInfo['balance']))

        #申请退回质押金
        result = platon_ppos.unStaking(nodeId,
                                       privatekey=private_key2,
                                       from_address=address2,
                                       gasPrice=self.base_gas_price,
                                       gas=self.staking_gas)
        assert result['Status'] == True, "申请质押退回质押金返回的状态:{},用例失败".format(
            result['Status'])
        lockup_end = platon_ppos.eth.getBalance(conf.FOUNDATIONLOCKUPADDRESS)
        log.info("退回质押金之后锁仓账户金额:{}".format(lockup_end))
        Staking_end = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("退回质押金之后Staking账户金额:{}".format(Staking_end))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        RestrictingInfo = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(RestrictingInfo['balance']))
        assert lockup_end == lockup_before, "质押金退回后锁仓金额:{}有误".format(
            lockup_end)
        assert Staking_end == Staking_before, "质押金退回后Staking金额:{}有误".format(
            Staking_end)
        assert RestrictingInfo[
            'balance'] == loukupbalace, "锁仓计划金额:{}有误".format(
                RestrictingInfo['balance'])
Esempio n. 11
0
    def test_morelockup_entrust(self):
        '''
        验证锁仓账户和释放到账账户为不同时锁仓委托扣费情况
        code:1、锁仓账户有余额支付委托手续费。
        :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_info2 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info2 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_info1 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info1 is not None, "转账:{}失败".format(self.value)
        Balance = platon_ppos.eth.getBalance(address1)
        log.info("{}质押和锁仓账户:{}".format(address1, Balance))
        Balance1 = platon_ppos.eth.getBalance(address2)
        log.info("{}委托账号:{}".format(address2, Balance1))

        # 发起质押
        version = get_version(platon_ppos)
        result = platon_ppos.createStaking(0,
                                           address1,
                                           nodeId,
                                           'externalId',
                                           'nodeName',
                                           'website',
                                           'details',
                                           100,
                                           version,
                                           privatekey=private_key1,
                                           from_address=address1,
                                           gasPrice=self.base_gas_price,
                                           gas=self.staking_gas)
        assert result['Status'] == True, "创建锁仓信息返回的状态:{},用例失败".format(
            result['Status'])
        Balance2 = platon_ppos.eth.getBalance(address1)
        log.info("{}质押后账户余额:{}".format(address1, Balance2))

        # 创建锁仓计划
        loukupbalace = Web3.toWei(500, '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'])
        Balance3 = platon_ppos.eth.getBalance(address1)
        log.info("{}创建锁仓后账户余额:{}".format(address1, Balance3))

        # 锁仓账号发起委托
        delegate_info = platon_ppos.delegate(1,
                                             nodeId,
                                             500,
                                             privatekey=private_key2,
                                             from_address=address2,
                                             gasPrice=self.base_gas_price,
                                             gas=self.staking_gas)
        assert delegate_info['Status'] == True, "申请委托返回的状态:{},用例失败".format(
            result['Status'])
        Balance4 = platon_ppos.eth.getBalance(address2)
        log.info("{}委托后账户余额:{}".format(address2, Balance4))
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        info = json.loads(RestrictingInfo['Data'])
        assert info['balance'] == 0, "锁仓可用余额:{},有误".format(info['balance'])
Esempio n. 12
0
    def test_lockup_entrust(self, amount):
        '''
        锁仓账户和释放到账账户为同一个时委托扣费验证
        :param amount:
        :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(address2), self.base_gas_price,
            self.base_gas, self.value, self.privatekey)
        return_info1 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info1 is not None, "转账:{}失败".format(self.value)
        # 签名转账
        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_info2 = platon_ppos.eth.waitForTransactionReceipt(result)
        assert return_info2 is not None, "转账:{}失败".format(self.value)
        balance1 = platon_ppos.eth.getBalance(address1)
        log.info("{}发起锁仓和质押的账户余额:{}".format(address1, balance1))
        balance = platon_ppos.eth.getBalance(address2)
        log.info("{}发起委托账户余额:{}".format(address2, balance))
        loukupbalace = Web3.toWei(300, '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'])
        lockup_after = platon_ppos.eth.getBalance(conf.FOUNDATIONLOCKUPADDRESS)
        RestrictingInfo = platon_ppos.GetRestrictingInfo(address2)
        info = json.loads(RestrictingInfo['Data'])
        log.info("锁仓计划可用余额:{}".format(info['balance']))
        balance2 = platon_ppos.eth.getBalance(address1)
        log.info("{}发起锁仓后账户余额:{}".format(address1, balance2))
        lock_balance1 = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("委托前锁仓合约地址余额:{}".format(lock_balance1))

        # 发起质押
        version = get_version(platon_ppos)
        result = platon_ppos.createStaking(0,
                                           address1,
                                           nodeId,
                                           'externalId',
                                           'nodeName',
                                           'website',
                                           'details',
                                           100,
                                           version,
                                           privatekey=private_key1,
                                           from_address=address1,
                                           gasPrice=self.base_gas_price,
                                           gas=self.staking_gas)
        assert result['Status'] == True, "创建锁仓信息返回的状态:{},用例失败".format(
            result['Status'])
        balance3 = platon_ppos.eth.getBalance(address1)
        log.info("{}发起质押后账户余额:{}".format(address1, balance3))
        staking_befor = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("委托前质押合约地址余额:{}".format(staking_befor))

        #委托金额小于锁仓金额发起委托
        if 0 < Web3.toWei(amount, 'ether') <= loukupbalace:
            log.info("委托金额:{}".format(Web3.toWei(amount, 'ether')))
            delegate_info = platon_ppos.delegate(1,
                                                 nodeId,
                                                 amount,
                                                 privatekey=private_key2,
                                                 from_address=address2,
                                                 gasPrice=self.base_gas_price,
                                                 gas=self.staking_gas)
            assert delegate_info[
                'Status'] == True, "查询锁仓计划返回的状态:{},用例失败".format(
                    result['Status'])
            balance4 = platon_ppos.eth.getBalance(address2)
            log.info("{}发起委托后账户余额:{}".format(address2, balance4))
            #质押账户余额增加
            staking_after = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
            log.info("委托后质押合约地址余额:{}".format(staking_after))
            assert staking_after == staking_befor + Web3.toWei(
                amount, 'ether'), "质押账户余额:{}".format(staking_after)
            #锁仓合约地址余额减少
            lock_balance = platon_ppos.eth.getBalance(
                conf.FOUNDATIONLOCKUPADDRESS)
            log.info("委托后锁仓合约地址余额:{}".format(lock_balance))
            assert lock_balance == lockup_after - Web3.toWei(
                amount, 'ether'), "锁仓合约余额:{}".format(lock_balance)
        #委托金额大于锁仓金额发起委托
        else:
            delegate_info = platon_ppos.delegate(1,
                                                 nodeId,
                                                 amount,
                                                 privatekey=private_key2,
                                                 from_address=address2,
                                                 gasPrice=self.base_gas_price,
                                                 gas=self.staking_gas)
            assert delegate_info[
                'Status'] == False, "申请委托返回的状态:{},用例失败".format(
                    result['Status'])
Esempio n. 13
0
    def test_morelockup_pledge(self):
        '''
        验证锁仓账户和释放到账账户为不同时锁仓质押扣费情况
        amount:质押金额
        :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, 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))
        loukupbalace = Web3.toWei(900, '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'])

        # 锁仓账号发起质押

        version = get_version(platon_ppos)
        result = platon_ppos.createStaking(1,
                                           address1,
                                           nodeId,
                                           'externalId',
                                           'nodeName',
                                           'website',
                                           'details',
                                           900,
                                           version,
                                           privatekey=private_key1,
                                           from_address=address1,
                                           gasPrice=self.base_gas_price,
                                           gas=self.staking_gas)
        assert result['Status'] == False, "创建锁仓信息返回的状态:{},用例失败".format(
            result['Status'])
Esempio n. 14
0
    def test_lockup_pledge(self, amount):
        '''
        验证锁仓账户和释放到账账户为同一个时锁仓质押扣费情况
        amount:质押金额
        :return:
        '''
        nodeId = CommonMethod.read_out_nodeId(self, 'nocollusion')
        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(900, 'ether')
        plan = [{'Epoch': 1, 'Amount': loukupbalace}]
        balance = platon_ppos.eth.getBalance(address1)
        log.info("锁仓账号余额:{}".format(balance))

        lockup_before = platon_ppos.eth.getBalance(
            conf.FOUNDATIONLOCKUPADDRESS)
        log.info("创建锁仓计划之前锁仓合约余额:{}".format(lockup_before))

        #创建锁仓计划
        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)
        log.info("创建锁仓计划之后锁仓合约余额:{}".format(lockup_after))
        assert lockup_after == lockup_before + loukupbalace, "锁仓计划金额{}".format(
            lockup_after)
        staking_befor = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
        log.info("发起验证人质押之前质押合约余额:{}".format(staking_befor))

        if 0 < Web3.toWei(amount, 'ether') <= loukupbalace:
            # 发起质押
            version = get_version(platon_ppos)
            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'])

            #质押账户余额增加
            staking_after = platon_ppos.eth.getBalance(conf.STAKINGADDRESS)
            log.info("发起验证人质押之后质押合约余额:{}".format(staking_after))
            assert staking_after == staking_befor + Web3.toWei(
                amount, 'ether'), "质押账户余额:{}有误".format(staking_after)

            #锁仓合约地址余额减少
            lock_balance = platon_ppos.eth.getBalance(
                conf.FOUNDATIONLOCKUPADDRESS)
            log.info("发起验证人质押之后锁仓合约余额:{}".format(lock_balance))
            assert lock_balance == lockup_after - Web3.toWei(
                amount, 'ether'), "锁仓合约余额:{}有误".format(lock_balance)

            #发起锁仓账户余额减少手续费
            pledge_balance_after = platon_ppos.eth.getBalance(address1)
            log.info("锁仓账号余额:{}".format(pledge_balance_after))
            assert balance > pledge_balance_after, "发起锁仓账户余额减少{}手续费有误".format(
                address1)
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)
            assert result['Status'] == True, "查询锁仓信息返回的状态:{},用例失败".format(
                result['Status'])

            #验证锁仓计划里的锁仓可用余额减少
            Info = json.loads(RestrictingInfo['Data'])
            assert loukupbalace == Info['balance'] + Web3.toWei(
                amount,
                'ether'), "查询{}锁仓余额失败".format(Info['balance'] +
                                              Web3.toWei(amount, 'ether'))

        else:
            # 发起质押
            version = get_version(platon_ppos)
            nodeId = CommonMethod.get_no_candidate_list(self)
            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'])
Esempio n. 15
0
    def test_loukupplan_sameperiod(self, Status):
        '''
        验证一个锁仓计划里有多个相同解锁期
        code =1 :同个account在一个锁仓计划里有相同解锁期
        code =2 :同个account在不同锁仓计划里有相同解锁期
        :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)
        period1 = 1
        period2 = 2
        loukupbalace = Web3.toWei(100, 'ether')

        if Status == 1:
            plan = [{
                'Epoch': period1,
                'Amount': loukupbalace
            }, {
                'Epoch': period1,
                'Amount': loukupbalace
            }]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            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)
            json_data = json.loads(RestrictingInfo['Data'])
            assert json_data['Entry'][0]['amount'] == (
                loukupbalace + loukupbalace), '锁仓金额{}有误'.format(
                    json_data['Entry'][0]['amount'])

        elif Status == 2:
            plan = [{'Epoch': period1, 'Amount': loukupbalace}]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            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'])
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            result1 = platon_ppos.CreateRestrictingPlan(
                address1,
                plan,
                privatekey=private_key1,
                from_address=address1,
                gasPrice=self.base_gas_price,
                gas=self.staking_gas)
            assert result1['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format(
                result['Status'])
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)
            json_data = json.loads(RestrictingInfo['Data'])
            assert json_data['balance'] == (loukupbalace +
                                            loukupbalace), '锁仓金额{}有误'.format(
                                                json_data['balance'])
            assert json_data['Entry'][0]['amount'] == (
                loukupbalace + loukupbalace), '锁仓金额{}有误'.format(
                    json_data['Entry'][0]['amount'])
        elif Status == 3:
            plan = [{'Epoch': period1, 'Amount': loukupbalace}]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            result1 = platon_ppos.CreateRestrictingPlan(
                address1,
                plan,
                privatekey=private_key1,
                from_address=address1,
                gasPrice=self.base_gas_price,
                gas=self.staking_gas)
            assert result1['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format(
                result['Status'])
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)

            plan = [{'Epoch': period2, 'Amount': loukupbalace}]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            result1 = platon_ppos.CreateRestrictingPlan(
                address1,
                plan,
                privatekey=private_key1,
                from_address=address1,
                gasPrice=self.base_gas_price,
                gas=self.staking_gas)
            assert result1['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format(
                result['Status'])
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)
            json_data = json.loads(RestrictingInfo['Data'])
            assert json_data['balance'] == (loukupbalace *
                                            2), '锁仓金额{}有误'.format(
                                                json_data['balance'])
            assert json_data['Entry'][0]['amount'] + json_data['Entry'][1][
                'amount'] == json_data[
                    'balance'], '锁仓金额{}有误                           '.format(
                        json_data['Entry'][0]['amount'] +
                        json_data['Entry'][1]['amount'])

        elif Status == 4:
            plan = [{
                'Epoch': 2,
                'Amount': loukupbalace
            }, {
                'Epoch': 3,
                'Amount': loukupbalace
            }]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            result1 = platon_ppos.CreateRestrictingPlan(
                address1,
                plan,
                privatekey=private_key1,
                from_address=address1,
                gasPrice=self.base_gas_price,
                gas=self.staking_gas)
            assert result1['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format(
                result['Status'])
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)

            plan = [{
                'Epoch': 2,
                'Amount': loukupbalace
            }, {
                'Epoch': 3,
                'Amount': loukupbalace
            }]
            log.info("锁仓参数:{}".format(plan))
            log.info("当前块高:{}".format(platon_ppos.eth.blockNumber))
            result1 = platon_ppos.CreateRestrictingPlan(
                address1,
                plan,
                privatekey=private_key1,
                from_address=address1,
                gasPrice=self.base_gas_price,
                gas=self.staking_gas)
            assert result1['Status'] == True, "创建锁仓计划返回的状态:{},用例失败".format(
                result['Status'])
            RestrictingInfo = platon_ppos.GetRestrictingInfo(address1)
            json_data = json.loads(RestrictingInfo['Data'])
            assert json_data['balance'] == (loukupbalace *
                                            4), '锁仓金额{}有误'.format(
                                                json_data['balance'])
            assert json_data['Entry'][0]['amount'] + json_data['Entry'][1][
                'amount'] == json_data[
                    'balance'], '锁仓金额{}有误                           '.format(
                        json_data['Entry'][0]['amount'] +
                        json_data['Entry'][1]['amount'])

        else:
            Status = 1
            assert Status == 0, '输入的Status:{}有误'.format(Status)