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

     1  from tests.lib.utils import *
     2  import rlp
     3  import pytest
     4  
     5  
     6  @pytest.mark.P3
     7  def test_staking_gas(client_new_node):
     8      external_id = "external_id"
     9      node_name = "node_name"
    10      website = "website"
    11      details = "details"
    12      node = client_new_node.node
    13      economic = client_new_node.economic
    14      benifit_address, pri_key = client_new_node.economic.account.generate_account(node.web3,
    15                                                                                   economic.create_staking_limit * 2)
    16      benifit_address = node.web3.toChecksumAddress(benifit_address)
    17      balance1 = node.eth.getBalance(benifit_address)
    18      log.info(balance1)
    19      benifit_address_ = benifit_address[2:]
    20      program_version_sign_ = node.program_version_sign[2:]
    21      result = client_new_node.ppos.createStaking(0, benifit_address, node.node_id, external_id,
    22                                                  node_name, website,
    23                                                  details, economic.create_staking_limit,
    24                                                  node.program_version, node.program_version_sign, node.blspubkey,
    25                                                  node.schnorr_NIZK_prove,
    26                                                  pri_key)
    27  
    28      assert_code(result, 0)
    29      data = rlp.encode([rlp.encode(int(1000)), rlp.encode(0), rlp.encode(bytes.fromhex(benifit_address_)),
    30                         rlp.encode(bytes.fromhex(node.node_id)), rlp.encode(external_id),
    31                         rlp.encode(node_name),
    32                         rlp.encode(website), rlp.encode(details),
    33                         rlp.encode(economic.create_staking_limit),
    34                         rlp.encode(node.program_version),
    35                         rlp.encode(bytes.fromhex(program_version_sign_)),
    36                         rlp.encode(bytes.fromhex(node.blspubkey)),
    37                         rlp.encode(bytes.fromhex(node.schnorr_NIZK_prove))])
    38      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 32000
    39      log.info(gas)
    40      gasPrice = node.web3.platon.gasPrice
    41      log.info(gasPrice)
    42      balance2 = node.eth.getBalance(benifit_address)
    43      log.info(balance2)
    44      assert balance1 - economic.create_staking_limit - gas * gasPrice == balance2
    45  
    46  
    47  @pytest.mark.P3
    48  def test_delegate_gas(client_new_node):
    49      client = client_new_node
    50      node = client.node
    51      economic = client.economic
    52      staking_address, _ = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
    53      address, pri_key = economic.account.generate_account(node.web3, economic.delegate_limit * 10)
    54  
    55      result = client.staking.create_staking(0, staking_address, staking_address)
    56      assert_code(result, 0)
    57      balance1 = node.eth.getBalance(address)
    58      log.info(balance1)
    59      result = client.delegate.delegate(0, address)
    60      assert_code(result, 0)
    61      balance2 = node.eth.getBalance(address)
    62      log.info(balance2)
    63      data = rlp.encode([rlp.encode(int(1004)), rlp.encode(0), rlp.encode(bytes.fromhex(node.node_id)),
    64                         rlp.encode(economic.delegate_limit)])
    65      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 16000
    66      log.info(gas)
    67      gasPrice = node.web3.platon.gasPrice
    68      log.info(gasPrice)
    69      assert balance1 - economic.delegate_limit - gas * gasPrice == balance2
    70  
    71  
    72  @pytest.mark.P3
    73  def test_withdrewDelegate_gas(client_new_node):
    74      client = client_new_node
    75      node = client.node
    76      economic = client.economic
    77      staking_address, _ = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
    78      address, pri_key = economic.account.generate_account(node.web3, economic.delegate_limit * 10)
    79  
    80      result = client.staking.create_staking(0, staking_address, staking_address)
    81      assert_code(result, 0)
    82      result = client.delegate.delegate(0, address)
    83      assert_code(result, 0)
    84      msg = client.ppos.getCandidateInfo(client_new_node.node.node_id)
    85      staking_blocknum = msg["Ret"]["StakingBlockNum"]
    86      balance1 = node.eth.getBalance(address)
    87      log.info(balance1)
    88      result = client.delegate.withdrew_delegate(staking_blocknum, address)
    89      assert_code(result, 0)
    90      balance2 = node.eth.getBalance(address)
    91      log.info(balance2)
    92  
    93      data = rlp.encode(
    94          [rlp.encode(int(1005)), rlp.encode(staking_blocknum), rlp.encode(bytes.fromhex(node.node_id)),
    95           rlp.encode(economic.delegate_limit)])
    96      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 8000
    97      log.info(gas)
    98      gasPrice = node.web3.platon.gasPrice
    99      log.info(gasPrice)
   100      assert balance1 - gas * gasPrice == balance2 - economic.delegate_limit
   101  
   102  
   103  @pytest.mark.P3
   104  def test_increase_staking_gas(client_new_node):
   105      client = client_new_node
   106      node = client.node
   107      economic = client.economic
   108      staking_address, _ = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
   109  
   110      result = client.staking.create_staking(0, staking_address, staking_address)
   111      assert_code(result, 0)
   112      balance1 = node.eth.getBalance(staking_address)
   113      log.info(balance1)
   114      result = client.staking.increase_staking(0, staking_address)
   115      assert_code(result, 0)
   116      balance2 = node.eth.getBalance(staking_address)
   117      log.info(balance2)
   118      data = rlp.encode(
   119          [rlp.encode(int(1002)), rlp.encode(bytes.fromhex(node.node_id)), rlp.encode(0),
   120           rlp.encode(economic.add_staking_limit)])
   121      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 20000
   122      log.info(gas)
   123      gasPrice = node.web3.platon.gasPrice
   124      log.info(gasPrice)
   125      assert balance1 - economic.delegate_limit - gas * gasPrice == balance2
   126  
   127  
   128  @pytest.mark.P3
   129  def test_edit_candidate_gas(client_new_node):
   130      external_id = "external_id"
   131      node_name = "node_name"
   132      website = "website"
   133      details = "details"
   134      client = client_new_node
   135      node = client.node
   136      economic = client.economic
   137      benifit_address, pri_key = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
   138      result = client.staking.create_staking(0, benifit_address, benifit_address)
   139      assert_code(result, 0)
   140      balance1 = node.eth.getBalance(benifit_address)
   141      log.info(balance1)
   142      result = client.ppos.editCandidate(benifit_address, node.node_id, external_id, node_name, website, details,
   143                                         pri_key)
   144      assert_code(result, 0)
   145      balance2 = node.eth.getBalance(benifit_address)
   146      log.info(balance2)
   147      benifit_address_ = benifit_address[2:]
   148      data = rlp.encode(
   149          [rlp.encode(int(1001)), rlp.encode(bytes.fromhex(benifit_address_)), rlp.encode(bytes.fromhex(node.node_id)),
   150           rlp.encode("external_id"), rlp.encode("node_name"), rlp.encode("website"), rlp.encode("details")])
   151      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 12000
   152      log.info(gas)
   153  
   154      gasPrice = node.web3.platon.gasPrice
   155      log.info(gasPrice)
   156      assert balance1 - gas * gasPrice == balance2
   157  
   158  
   159  @pytest.mark.P3
   160  def test_withdrew_staking_gas(client_new_node):
   161      client = client_new_node
   162      node = client.node
   163      economic = client.economic
   164      staking_address, _ = economic.account.generate_account(node.web3, economic.create_staking_limit * 2)
   165  
   166      result = client.staking.create_staking(0, staking_address, staking_address)
   167      assert_code(result, 0)
   168      balance1 = node.eth.getBalance(staking_address)
   169      log.info(balance1)
   170      result = client.staking.withdrew_staking(staking_address)
   171      assert_code(result, 0)
   172      balance2 = node.eth.getBalance(staking_address)
   173      log.info(balance2)
   174      data = rlp.encode([rlp.encode(int(1003)), rlp.encode(bytes.fromhex(node.node_id))])
   175      gas = get_the_dynamic_parameter_gas_fee(data) + 21000 + 6000 + 20000
   176      log.info(gas)
   177      gasPrice = node.web3.platon.gasPrice
   178      log.info(gasPrice)
   179      assert balance1 - gas * gasPrice == balance2 - economic.create_staking_limit