github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_withdrewDelegate.py (about)

     1  # -*- coding: utf-8 -*-
     2  from tests.lib.utils import *
     3  import pytest
     4  from tests.lib.config import EconomicConfig
     5  
     6  
     7  @pytest.mark.P0
     8  @pytest.mark.compatibility
     9  def test_ROE_001_007_015(client_new_node):
    10      """
    11      :param client_new_node_obj:
    12      :param get_generate_account:
    13      :return:
    14      """
    15      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    16                                                                     10 ** 18 * 10000000)
    17      client_new_node.staking.create_staking(0, address, address)
    18      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    19                                                                      10 ** 18 * 10000000)
    20      result = client_new_node.delegate.delegate(0, address1)
    21      log.info(result)
    22      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    23      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    24      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1)
    25      assert_code(result, 0)
    26  
    27  
    28  @pytest.mark.P1
    29  def test_ROE_002(client_new_node):
    30      """
    31      :param client_new_node_obj:
    32      :param get_generate_account:
    33      :return:
    34      """
    35      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    36                                                                     10 ** 18 * 10000000)
    37      client_new_node.staking.create_staking(0, address, address)
    38      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    39                                                                      10 ** 18 * 10000000)
    40      result = client_new_node.delegate.delegate(0, address1)
    41      log.info(result)
    42      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    43      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    44      cfg = {"gas": 1}
    45      status = 0
    46      try:
    47          client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, transaction_cfg=cfg)
    48      except BaseException:
    49          status = 1
    50      assert status == 1
    51  
    52  
    53  @pytest.mark.P3
    54  def test_ROE_003(client_new_node):
    55      """
    56      :param client_new_node_obj:
    57      :param get_generate_account:
    58      :return:
    59      """
    60      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    61                                                                     10 ** 18 * 10000000)
    62      client_new_node.staking.create_staking(0, address, address)
    63      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    64                                                                      10 ** 18 * 10000000)
    65      result = client_new_node.delegate.delegate(0, address1)
    66      log.info(result)
    67      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    68      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    69      illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \
    70                       "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990"
    71      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, node_id=illegal_nodeID)
    72      log.info(result)
    73      assert_code(result, 301109)
    74  
    75  
    76  @pytest.mark.P1
    77  def test_ROE_004(client_new_node):
    78      """
    79      :param client_new_node_obj:
    80      :return:
    81      """
    82      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    83                                                                     10 ** 18 * 10000000)
    84      client_new_node.staking.create_staking(0, address, address)
    85      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
    86                                                                      10 ** 18 * 10000000)
    87      result = client_new_node.delegate.delegate(0, address1)
    88      log.info(result)
    89      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
    90      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    91  
    92      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1,
    93                                                          amount=client_new_node.economic.delegate_limit + 1)
    94      assert_code(result, 301113)
    95  
    96  
    97  @pytest.mark.P1
    98  def test_ROE_005_018(client_new_node):
    99      """
   100      :param client_new_node_obj:
   101      :return:
   102      """
   103      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   104                                                                     10 ** 18 * 10000000)
   105      client_new_node.staking.create_staking(0, address, address)
   106      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   107                                                                      10 ** 18 * 10000000)
   108      result = client_new_node.delegate.delegate(0, address1)
   109      log.info(result)
   110  
   111      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   112      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   113      # Return a pledge
   114      client_new_node.staking.withdrew_staking(address)
   115  
   116      # The next two cycle
   117      client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2)
   118      amount1 = client_new_node.node.eth.getBalance(address1)
   119      log.info("The wallet balance:{}".format(amount1))
   120  
   121      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1)
   122      assert_code(result, 0)
   123      amount2 = client_new_node.node.eth.getBalance(address1)
   124      log.info("The wallet balance:{}".format(amount2))
   125      delegate_limit = client_new_node.economic.delegate_limit
   126      assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   127  
   128  
   129  @pytest.mark.P1
   130  def test_ROE_006_008(client_new_node):
   131      """
   132  
   133      :param client_new_node_obj:
   134      :return:
   135      """
   136      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   137                                                                     10 ** 18 * 10000000)
   138      client_new_node.staking.create_staking(0, address, address)
   139      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   140                                                                      10 ** 18 * 10000000)
   141      value = client_new_node.economic.delegate_limit * 3
   142      result = client_new_node.delegate.delegate(0, address1, amount=value)
   143      log.info(result)
   144      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   145      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   146      value = client_new_node.economic.delegate_limit * 2
   147      amount1 = client_new_node.node.eth.getBalance(address1)
   148      log.info("The wallet balance:{}".format(amount1))
   149      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, amount=value)
   150      assert_code(result, 0)
   151      amount2 = client_new_node.node.eth.getBalance(address1)
   152      log.info("The wallet balance:{}".format(amount2))
   153  
   154  
   155  @pytest.mark.P1
   156  def test_ROE_010(client_new_node):
   157      """
   158      :param client_new_node_obj:
   159      :return:
   160      """
   161      client_new_node.economic.env.deploy_all()
   162      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   163                                                                     10 ** 18 * 10000000)
   164      lockup_amount = client_new_node.node.web3.toWei(1000, "ether")
   165      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   166      # Create a lock plan
   167      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   168      log.info(result)
   169      assert_code(result, 0)
   170      msg = client_new_node.ppos.getRestrictingInfo(address)
   171      log.info(msg)
   172      # create staking
   173      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   174                                                                             10 ** 18 * 10000000)
   175      client_new_node.staking.create_staking(0, address_staking, address_staking)
   176  
   177      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   178      # Lock account authorization
   179      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   180      log.info(result)
   181      # Own capital account entrustment
   182      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   183      log.info(result)
   184  
   185      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   186      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   187  
   188      undelegate_amount = client_new_node.node.web3.toWei(300, "ether")
   189      log.info("The amount of redemption is greater than the entrustment of the free account")
   190      amount1 = client_new_node.node.eth.getBalance(address)
   191      log.info("The wallet balance:{}".format(amount1))
   192  
   193      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   194      assert_code(result, 0)
   195  
   196      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   197      log.info(msg)
   198      amount2 = client_new_node.node.eth.getBalance(address)
   199      log.info("The wallet balance:{}".format(amount2))
   200      assert undelegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   201  
   202  
   203  @pytest.mark.P1
   204  def test_ROE_011(client_new_node):
   205      """
   206  
   207      :param client_new_node_obj:
   208      :return:
   209      """
   210      client_new_node.economic.env.deploy_all()
   211      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   212                                                                     10 ** 18 * 10000000)
   213      lockup_amount = client_new_node.node.web3.toWei(1000, "ether")
   214      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   215      # Create a lock plan
   216      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   217      log.info(result)
   218      assert_code(result, 0)
   219      msg = client_new_node.ppos.getRestrictingInfo(address)
   220      log.info(msg)
   221      # create staking
   222      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   223                                                                             10 ** 18 * 10000000)
   224      client_new_node.staking.create_staking(0, address_staking, address_staking)
   225  
   226      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   227      # Lock account authorization
   228      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   229      log.info(result)
   230      # Own capital account entrustment
   231      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   232      log.info(result)
   233  
   234      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   235      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   236  
   237      undelegate_amount = client_new_node.node.web3.toWei(700, "ether")
   238      log.info("The amount of redemption is greater than the entrustment of the free account")
   239      amount1 = client_new_node.node.eth.getBalance(address)
   240      log.info("The wallet balance:{}".format(amount1))
   241  
   242      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   243      assert_code(result, 0)
   244  
   245      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   246      log.info(msg)
   247      amount2 = client_new_node.node.eth.getBalance(address)
   248      log.info("The wallet balance:{}".format(amount2))
   249      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   250      # The next cycle
   251      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   252      locked_delegate = delegate_amount - (undelegate_amount - delegate_amount)
   253      msg = client_new_node.ppos.getRestrictingInfo(address)
   254      log.info(msg)
   255      # The remaining entrusted amount
   256      assert msg["Ret"]["Pledge"] == locked_delegate
   257      amount3 = client_new_node.node.eth.getBalance(address)
   258      log.info("The wallet balance:{}".format(amount3))
   259      assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"]
   260  
   261  
   262  @pytest.mark.P1
   263  def test_ROE_012(client_new_node):
   264      """
   265      :param client_new_node_obj:
   266      :return:
   267      """
   268      # create staking
   269      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   270                                                                             10 ** 18 * 10000000)
   271      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   272                                                                     10 ** 18 * 10000000)
   273      client_new_node.staking.create_staking(0, address_staking, address_staking)
   274      delegate_amount = client_new_node.node.web3.toWei(50, "ether")
   275      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   276      log.info(result)
   277      amount1 = client_new_node.node.eth.getBalance(address)
   278      log.info("The wallet balance:{}".format(amount1))
   279      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   280      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   281      # After redemptive balance is less than the threshold that entrusts gold, redeem completely
   282      undelegate_amount = client_new_node.node.web3.toWei(41, "ether")
   283      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   284      assert_code(result, 0)
   285      amount2 = client_new_node.node.eth.getBalance(address)
   286      log.info("The wallet balance:{}".format(amount2))
   287      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   288  
   289  
   290  @pytest.mark.P1
   291  def test_ROE_014(client_new_node):
   292      """
   293      :param client_new_node_obj:
   294      :return:
   295      """
   296      client_new_node.economic.env.deploy_all()
   297      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   298                                                                     10 ** 18 * 10000000)
   299      lockup_amount = client_new_node.node.web3.toWei(1000, "ether")
   300      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   301      # Create a lock plan
   302      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   303      log.info(result)
   304      assert_code(result, 0)
   305      msg = client_new_node.ppos.getRestrictingInfo(address)
   306      log.info(msg)
   307      # create staking
   308      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   309                                                                             10 ** 18 * 10000000)
   310      client_new_node.staking.create_staking(0, address_staking, address_staking)
   311  
   312      delegate_amount = client_new_node.node.web3.toWei(1000, "ether")
   313      # Lock account authorization
   314      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   315      log.info(result)
   316      # Own capital account entrustment
   317      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   318      log.info(result)
   319  
   320      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   321      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   322      value = 1000 * 2 - 9
   323      undelegate_amount = client_new_node.node.web3.toWei(value, "ether")
   324      amount1 = client_new_node.node.eth.getBalance(address)
   325      log.info("The wallet balance:{}".format(amount1))
   326  
   327      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   328      assert_code(result, 0)
   329  
   330      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   331      log.info(msg)
   332      amount2 = client_new_node.node.eth.getBalance(address)
   333      log.info("The wallet balance:{}".format(amount2))
   334      account_dill = amount2 - amount1
   335      assert delegate_amount - account_dill < client_new_node.node.web3.toWei(1, "ether")
   336  
   337      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   338      amount3 = client_new_node.node.eth.getBalance(address)
   339      log.info("The wallet balance:{}".format(amount3))
   340      assert amount3 - amount2 == delegate_amount
   341  
   342  
   343  @pytest.mark.P1
   344  def test_ROE_017(client_new_node):
   345      """
   346  
   347      :param client_new_node_obj:
   348      :return:
   349      """
   350      client_new_node.economic.env.deploy_all()
   351      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   352                                                                     10 ** 18 * 10000000)
   353      lockup_amount = client_new_node.node.web3.toWei(500, "ether")
   354      plan = [{'Epoch': 1, 'Amount': lockup_amount}]
   355      # Create a lock plan
   356      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   357      log.info(result)
   358      assert_code(result, 0)
   359      msg = client_new_node.ppos.getRestrictingInfo(address)
   360      log.info(msg)
   361      # create staking
   362      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   363                                                                             10 ** 18 * 10000000)
   364      client_new_node.staking.create_staking(0, address_staking, address_staking)
   365  
   366      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   367      # Lock account authorization
   368      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   369      log.info(result)
   370      # Own capital account entrustment
   371      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   372      log.info(result)
   373  
   374      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   375      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   376      # Redemptive amount is equal to free account + the entrustment gold of lock storehouse
   377  
   378      undelegate_amount = client_new_node.node.web3.toWei(1000, "ether")
   379      amount1 = client_new_node.node.eth.getBalance(address)
   380      log.info("The wallet balance:{}".format(amount1))
   381  
   382      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   383      assert_code(result, 0)
   384  
   385      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   386      log.info(msg)
   387      amount2 = client_new_node.node.eth.getBalance(address)
   388      log.info("The wallet balance:{}".format(amount2))
   389      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   390  
   391      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   392  
   393      msg = client_new_node.ppos.getRestrictingInfo(address)
   394      log.info(msg)
   395      amount3 = client_new_node.node.eth.getBalance(address)
   396      log.info("The wallet balance:{}".format(amount3))
   397      assert amount3 - amount2 == delegate_amount
   398  
   399  
   400  @pytest.mark.P1
   401  def test_ROE_019_021(client_new_node):
   402      """
   403  
   404      :param client_new_node_obj:
   405      :return:
   406      """
   407      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   408                                                                     10 ** 18 * 10000000)
   409      client_new_node.staking.create_staking(0, address, address)
   410      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   411                                                                      10 ** 18 * 10000000)
   412      value = client_new_node.economic.delegate_limit * 3
   413      result = client_new_node.delegate.delegate(0, address1, amount=value)
   414      log.info(result)
   415      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   416      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   417      value = client_new_node.economic.delegate_limit * 2
   418      amount1 = client_new_node.node.eth.getBalance(address1)
   419      log.info("The wallet balance:{}".format(amount1))
   420  
   421      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   422      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1, amount=value)
   423      assert_code(result, 0)
   424      amount2 = client_new_node.node.eth.getBalance(address1)
   425      log.info("The wallet balance:{}".format(amount2))
   426      assert value - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   427  
   428  
   429  @pytest.mark.P0
   430  def test_ROE_020(client_new_node):
   431      """
   432      :param client_new_node_obj:
   433      :return:
   434      """
   435      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   436                                                                     10 ** 18 * 10000000)
   437      client_new_node.staking.create_staking(0, address, address)
   438      address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   439                                                                      10 ** 18 * 10000000)
   440  
   441      result = client_new_node.delegate.delegate(0, address1)
   442      log.info(result)
   443      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   444      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   445      amount1 = client_new_node.node.eth.getBalance(address1)
   446      log.info("The wallet balance:{}".format(amount1))
   447  
   448      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   449      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address1)
   450      assert_code(result, 0)
   451      amount2 = client_new_node.node.eth.getBalance(address1)
   452      log.info("The wallet balance:{}".format(amount2))
   453      delegate_limit = client_new_node.economic.delegate_limit
   454      assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   455  
   456  
   457  @pytest.mark.P1
   458  def test_ROE_024(client_new_node):
   459      """
   460  
   461      :param client_new_node_obj:
   462      :return:
   463      """
   464      client_new_node.economic.env.deploy_all()
   465      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   466                                                                     10 ** 18 * 10000000)
   467      lockup_amount = client_new_node.node.web3.toWei(1000, "ether")
   468      plan = [{'Epoch': 2, 'Amount': lockup_amount}]
   469      # Create a lock plan
   470      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   471      log.info(result)
   472      assert_code(result, 0)
   473      msg = client_new_node.ppos.getRestrictingInfo(address)
   474      log.info(msg)
   475      # create staking
   476      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   477                                                                             10 ** 18 * 10000000)
   478      client_new_node.staking.create_staking(0, address_staking, address_staking)
   479  
   480      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   481      # Lock account authorization
   482      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   483      log.info(result)
   484      # Own capital account entrustment
   485      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   486      log.info(result)
   487      # The next cycle
   488      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   489      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   490      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   491  
   492      undelegate_amount = client_new_node.node.web3.toWei(700, "ether")
   493      log.info("The amount of redemption is greater than the entrustment of the free account")
   494      amount1 = client_new_node.node.eth.getBalance(address)
   495      log.info("The wallet balance:{}".format(amount1))
   496  
   497      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   498      assert_code(result, 0)
   499  
   500      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   501      log.info(msg)
   502      amount2 = client_new_node.node.eth.getBalance(address)
   503      log.info("The wallet balance:{}".format(amount2))
   504      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   505  
   506      # The next cycle
   507      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   508      locked_delegate = delegate_amount - (undelegate_amount - delegate_amount)
   509      msg = client_new_node.ppos.getRestrictingInfo(address)
   510      log.info(msg)
   511      assert msg["Ret"]["Pledge"] == locked_delegate
   512      amount3 = client_new_node.node.eth.getBalance(address)
   513      log.info("The wallet balance:{}".format(amount3))
   514      assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"]
   515  
   516  
   517  @pytest.mark.P1
   518  def test_ROE_028(client_new_node):
   519      """
   520      :param client_new_node_bgj:
   521      :return:
   522      """
   523      # create staking
   524      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   525                                                                             10 ** 18 * 10000000)
   526      client_new_node.staking.create_staking(0, address_staking, address_staking)
   527      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   528  
   529      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   530                                                                     10 ** 18 * 10000000)
   531      # create delegate
   532      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   533      log.info(result)
   534  
   535      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   536      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   537  
   538      amount1 = client_new_node.node.eth.getBalance(address)
   539      log.info("The wallet balance:{}".format(amount1))
   540      # The next cycle
   541      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   542      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=delegate_amount)
   543      assert_code(result, 0)
   544  
   545      amount2 = client_new_node.node.eth.getBalance(address)
   546      log.info("The wallet balance:{}".format(amount2))
   547      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   548  
   549  
   550  @pytest.mark.P1
   551  def test_ROE_030(client_new_node):
   552      """
   553  
   554      :param client_new_node_obj:
   555      :return:
   556      """
   557      client_new_node.economic.env.deploy_all()
   558      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   559                                                                     10 ** 18 * 10000000)
   560      lockup_amount = client_new_node.node.web3.toWei(500, "ether")
   561      plan = [{'Epoch': 2, 'Amount': lockup_amount}]
   562      # Create a lock plan
   563      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   564      log.info(result)
   565      assert_code(result, 0)
   566      msg = client_new_node.ppos.getRestrictingInfo(address)
   567      log.info(msg)
   568      # create staking
   569      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   570                                                                             10 ** 18 * 10000000)
   571      client_new_node.staking.create_staking(0, address_staking, address_staking)
   572  
   573      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   574      # Lock account authorization
   575      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   576      log.info(result)
   577      # Own capital account entrustment
   578      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   579      log.info(result)
   580      # The next cycle
   581      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   582  
   583      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   584      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   585      # Redemptive amount is equal to free account + the entrustment gold of lock storehouse
   586  
   587      undelegate_amount = client_new_node.node.web3.toWei(1000, "ether")
   588      amount1 = client_new_node.node.eth.getBalance(address)
   589      log.info("The wallet balance:{}".format(amount1))
   590  
   591      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   592      assert_code(result, 0)
   593  
   594      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   595      log.info(msg)
   596      amount2 = client_new_node.node.eth.getBalance(address)
   597      log.info("The wallet balance:{}".format(amount2))
   598      assert delegate_amount - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   599  
   600      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   601  
   602      msg = client_new_node.ppos.getRestrictingInfo(address)
   603      log.info(msg)
   604      amount3 = client_new_node.node.eth.getBalance(address)
   605      log.info("The wallet balance:{}".format(amount3))
   606      assert amount3 - amount2 == delegate_amount
   607  
   608  
   609  @pytest.mark.P1
   610  def test_ROE_042(client_new_node):
   611      """
   612  
   613      :param client_new_node_obj:
   614      :return:
   615      """
   616      client_new_node.economic.env.deploy_all()
   617  
   618      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   619                                                                     10 ** 18 * 10000000)
   620      lockup_amount = client_new_node.node.web3.toWei(1000, "ether")
   621      plan = [{'Epoch': 2, 'Amount': lockup_amount}]
   622      # Create a lock plan
   623      result = client_new_node.restricting.createRestrictingPlan(address, plan, address)
   624      log.info(result)
   625      assert_code(result, 0)
   626      msg = client_new_node.ppos.getRestrictingInfo(address)
   627      log.info(msg)
   628      # create staking
   629      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   630                                                                             10 ** 18 * 10000000)
   631      client_new_node.staking.create_staking(0, address_staking, address_staking)
   632  
   633      delegate_amount = client_new_node.node.web3.toWei(200, "ether")
   634      # Lock account authorization
   635      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount)
   636      log.info(result)
   637      # Own capital account entrustment
   638      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   639      log.info(result)
   640  
   641      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   642      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   643  
   644      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   645      log.info(msg)
   646      # The next cycle
   647      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   648  
   649      delegate_amount_2 = client_new_node.node.web3.toWei(300, "ether")
   650      result = client_new_node.delegate.delegate(1, address, amount=delegate_amount_2)
   651      log.info(result)
   652      # Own capital account entrustment
   653      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount_2)
   654      log.info(result)
   655  
   656      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   657      log.info(msg)
   658  
   659      undelegate_amount = client_new_node.node.web3.toWei(700, "ether")
   660      amount1 = client_new_node.node.eth.getBalance(address)
   661      log.info("The wallet balance:{}".format(amount1))
   662      log.info("Redemption is more than the hesitation period of the own amount + lock amount")
   663      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=undelegate_amount)
   664      assert_code(result, 0)
   665  
   666      msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address, client_new_node.node.node_id)
   667      log.info(msg)
   668      amount2 = client_new_node.node.eth.getBalance(address)
   669      log.info("The wallet balance:{}".format(amount2))
   670      """赎回金额700,先赎回自由金额300,锁仓金额300,再赎回自由金额的100;目前锁定期的自由资金立马退,所以退400"""
   671      account_dill = undelegate_amount - delegate_amount_2 * 2
   672      account_sum = account_dill + delegate_amount_2
   673      assert amount2 - amount1 > account_sum - client_new_node.node.web3.toWei(1, "ether")
   674  
   675      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   676  
   677      msg = client_new_node.ppos.getRestrictingInfo(address)
   678      log.info(msg)
   679      amount3 = client_new_node.node.eth.getBalance(address)
   680      log.info("The wallet balance:{}".format(amount3))
   681      assert amount3 - amount2 == lockup_amount - msg["Ret"]["debt"]
   682  
   683  
   684  @pytest.mark.P1
   685  def test_ROE_055(client_new_node):
   686      """
   687      :param client_new_node_obj:
   688      :return:
   689      """
   690      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   691                                                                             10 ** 18 * 10000000)
   692      client_new_node.staking.create_staking(0, address_staking, address_staking)
   693      delegate_amount = client_new_node.node.web3.toWei(500, "ether")
   694  
   695      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   696                                                                     10 ** 18 * 10000000)
   697      # create delegate
   698      result = client_new_node.delegate.delegate(0, address, amount=delegate_amount)
   699      log.info(result)
   700  
   701      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   702      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   703      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, amount=delegate_amount + 1)
   704      assert_code(result, 301113)
   705  
   706  
   707  @pytest.mark.P1
   708  def test_ROE_056_057(client_new_node, client_consensus):
   709      """
   710  
   711      :param client_new_node_obj:
   712      :param client_consensus_obj:
   713      :return:
   714      """
   715      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   716                                                                             10 ** 18 * 10000000)
   717      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   718                                                                     10 ** 18 * 10000000)
   719      value = client_new_node.economic.create_staking_limit * 2
   720      result = client_new_node.staking.create_staking(0, address_staking, address_staking,
   721                                                      amount=value)
   722      assert_code(result, 0)
   723  
   724      # create delegate
   725      result = client_new_node.delegate.delegate(0, address)
   726      log.info(result)
   727  
   728      log.info("Close one node")
   729      client_new_node.node.stop()
   730      node = client_consensus.node
   731  
   732      msg = client_consensus.ppos.getCandidateInfo(client_new_node.node.node_id)
   733      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   734      log.info("The next two periods")
   735      client_consensus.economic.wait_settlement_blocknum(node, number=2)
   736  
   737      log.info("Restart the node")
   738      client_new_node.node.start()
   739      amount1 = client_new_node.node.eth.getBalance(address)
   740      log.info("The wallet balance:{}".format(amount1))
   741  
   742      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address)
   743      log.info(result)
   744  
   745      amount2 = client_new_node.node.eth.getBalance(address)
   746      log.info("The wallet balance:{}".format(amount2))
   747      delegate_limit = client_new_node.economic.delegate_limit
   748      assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")
   749  
   750  
   751  @pytest.mark.P3
   752  def test_ROE_058(client_new_node):
   753      """
   754      :param client_new_node_obj:
   755      :return:
   756      """
   757      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   758                                                                             10 ** 18 * 10000000)
   759      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   760                                                                     10 ** 18 * 10000000)
   761      result = client_new_node.staking.create_staking(0, address_staking, address_staking)
   762      assert_code(result, 0)
   763  
   764      result = client_new_node.delegate.delegate(0, address)
   765      log.info(result)
   766  
   767      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   768      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   769  
   770      amount = client_new_node.node.eth.getBalance(address)
   771      log.info("The wallet balance:{}".format(amount))
   772      cfg = {"gasPrice": amount}
   773      status = 0
   774      try:
   775          result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, transaction_cfg=cfg)
   776          log.info(result)
   777      except BaseException:
   778          status = 1
   779      assert status == 1
   780  
   781  
   782  @pytest.mark.P3
   783  def test_ROE_059(client_new_node):
   784      """
   785      :param client_new_node_obj:
   786      :return:
   787      """
   788      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   789                                                                             10 ** 18 * 10000000)
   790      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   791                                                                     10 ** 18 * 10000000)
   792      result = client_new_node.staking.create_staking(0, address_staking, address_staking)
   793      assert_code(result, 0)
   794  
   795      result = client_new_node.delegate.delegate(0, address)
   796      log.info(result)
   797  
   798      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   799      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   800  
   801      cfg = {"gas": 10}
   802      status = 0
   803      try:
   804          result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address, transaction_cfg=cfg)
   805          log.info(result)
   806      except BaseException:
   807          status = 1
   808      assert status == 1
   809  
   810  
   811  @pytest.mark.P1
   812  def test_ROE_060(client_new_node):
   813      """
   814  
   815      :param client_new_node_obj:
   816      :return:
   817      """
   818      address_staking, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   819                                                                             10 ** 18 * 10000000)
   820      address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3,
   821                                                                     10 ** 18 * 10000000)
   822      # The next cycle
   823      client_new_node.economic.wait_settlement_blocknum(client_new_node.node)
   824  
   825      result = client_new_node.staking.create_staking(0, address_staking, address_staking)
   826      assert_code(result, 0)
   827  
   828      result = client_new_node.staking.withdrew_staking(address_staking)
   829      assert_code(result, 0)
   830      # The next two cycle
   831      client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2)
   832      # Pledge again after quitting pledge
   833      result = client_new_node.staking.create_staking(0, address_staking, address_staking)
   834      assert_code(result, 0)
   835      result = client_new_node.delegate.delegate(0, address)
   836      assert_code(result, 0)
   837      msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id)
   838      staking_blocknum = msg["Ret"]["StakingBlockNum"]
   839      amount1 = client_new_node.node.eth.getBalance(address)
   840      log.info("The wallet balance:{}".format(amount1))
   841      result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address)
   842      log.info(result)
   843      assert_code(result, 0)
   844      amount2 = client_new_node.node.eth.getBalance(address)
   845      log.info("The wallet balance:{}".format(amount2))
   846      delegate_limit = client_new_node.economic.delegate_limit
   847      assert delegate_limit - (amount2 - amount1) < client_new_node.node.web3.toWei(1, "ether")