github.com/platonnetwork/platon-go@v0.7.6/cases/environment/account.py (about)

     1  from common.load_file import LoadFile
     2  from common.log import log
     3  from client_sdk_python.eth import Eth
     4  from client_sdk_python.personal import Personal
     5  from hexbytes import HexBytes
     6  import random
     7  from client_sdk_python import (
     8      Web3
     9  )
    10  import rlp
    11  import os
    12  from eth_keys import (
    13      keys,
    14  )
    15  from eth_utils.curried import (
    16      keccak,
    17      text_if_str,
    18      to_bytes,
    19  )
    20  
    21  
    22  class Account:
    23      def __init__(self, accountFile, chainId):
    24          """
    25          accounts 包含的属性: address,prikey,nonce,balance,node_id,passwd
    26          :param accountFile:
    27          :param chainId:
    28          """
    29          self.accounts = {}
    30          self.raw_accounts = LoadFile(accountFile).get_data()
    31          # log.info(self.raw_accounts)
    32          self.chain_id = chainId
    33          self.account_with_money = self.raw_accounts[0]
    34          self.reset()
    35          # for account in self.raw_accounts:
    36          #     self.accounts[account['address']] = account
    37  
    38      def reset(self):
    39          self.accounts = {}
    40          for account in self.raw_accounts:
    41              self.accounts[account['address']] = account
    42  
    43      def get_all_accounts(self):
    44          accounts = []
    45          for account in self.accounts.values():
    46              accounts.append(account)
    47          return accounts
    48  
    49      def get_rand_account(self):
    50          # todo 实现随机
    51          # for account in self.accounts.values():
    52          #     return account
    53          return random.choice(list(self.accounts.values()))
    54  
    55      def sendTransaction(self, connect, data, from_address, to_address, gasPrice, gas, value, check_address=True):
    56          platon = Eth(connect)
    57  
    58          account = self.accounts[from_address]
    59          if check_address:
    60              to_address = Web3.toChecksumAddress(to_address)
    61          tmp_from_address = Web3.toChecksumAddress(from_address)
    62          nonce = platon.getTransactionCount(tmp_from_address)
    63  
    64          # if nonce < account['nonce']:
    65          #     nonce = account['nonce']
    66  
    67          transaction_dict = {
    68              "to": to_address,
    69              "gasPrice": gasPrice,
    70              "gas": gas,
    71              "nonce": nonce,
    72              "data": data,
    73              "chainId": self.chain_id,
    74              "value": value,
    75              'from': tmp_from_address,
    76          }
    77  
    78          # log.debug("account['prikey']:::::::{}".format(account['prikey']))
    79  
    80          signedTransactionDict = platon.account.signTransaction(
    81              transaction_dict, account['prikey']
    82          )
    83  
    84          # log.debug("signedTransactionDict:::::::{},nonce::::::::::{}".format(signedTransactionDict, nonce))
    85  
    86          data = signedTransactionDict.rawTransaction
    87          result = HexBytes(platon.sendRawTransaction(data)).hex()
    88          # log.debug("result:::::::{}".format(result))
    89          res = platon.waitForTransactionReceipt(result)
    90          account['nonce'] = nonce + 1
    91          self.accounts[from_address] = account
    92  
    93          return res
    94  
    95      def generate_account_in_node(self, node, passwd, balance=0):
    96          personal = Personal(node.web3)
    97          address = personal.newAccount(passwd)
    98          # log.debug(address)
    99          if balance > 0:
   100              self.sendTransaction(node.web3, '', self.account_with_money['address'], address, node.eth.gasPrice, 40000, balance)
   101          account = {
   102              "node_id": node.node_id,
   103              "address": address,
   104              "nonce": 0,
   105              "balance": balance,
   106              "prikey": '',
   107              'passwd': passwd
   108          }
   109          self.accounts[address] = account
   110          return address
   111  
   112      def unlock_account(self, node, address):
   113          account = self.accounts[address]
   114          personal = Personal(node.web3)
   115          personal.unlockAccount(account['address'], account['passwd'])
   116  
   117      def get_rand_account_in_node(self, node):
   118          for account in self.accounts.values():
   119              if account['node_id'] == node.id:
   120                  return account
   121          self.generate_account_in_node(node, '123456')
   122  
   123      def create_restricting_plan(self, connect, receive_address, plan, from_address, gasPrice=None, gas=None):
   124          '''
   125          创建锁仓计划
   126          :param account: 20bytes
   127          :param plan: []RestrictingPlan
   128          :param from_address:
   129          :param gasPrice:
   130          :param gas:
   131          :return:
   132          '''
   133          to_address = "0x1000000000000000000000000000000000000001"
   134          if receive_address[:2] == '0x':
   135              receive_address = receive_address[2:]
   136          plan_list = []
   137          for dict_ in plan:
   138              v = [dict_[k] for k in dict_]
   139              plan_list.append(v)
   140          rlp_list = rlp.encode(plan_list)
   141          data = rlp.encode([rlp.encode(int(4000)),
   142                             rlp.encode(bytes.fromhex(receive_address)),
   143                             rlp_list])
   144          # print ("len:", len (data))
   145          # l = [hex (int (i)) for i in data]
   146          # print (" ".join (l))
   147          result = self.sendTransaction(connect, data, from_address, to_address, gasPrice, gas, 0)
   148          return result
   149  
   150      def generate_account(self, web3, balance=0):
   151          extra_entropy = ''
   152          extra_key_bytes = text_if_str(to_bytes, extra_entropy)
   153          key_bytes = keccak(os.urandom(32) + extra_key_bytes)
   154          privatekey = keys.PrivateKey(key_bytes)
   155          address = privatekey.public_key.to_address()
   156          address = Web3.toChecksumAddress(address)
   157          prikey = privatekey.to_hex()[2:]
   158          if balance != 0:
   159              self.sendTransaction(web3, '', self.account_with_money['address'], address, web3.platon.gasPrice, 21000, balance)
   160          account = {
   161              "address": address,
   162              "nonce": 0,
   163              "balance": balance,
   164              "prikey": prikey,
   165          }
   166          self.accounts[address] = account
   167          # todo delete debug
   168  
   169          def debug():
   170              from conf.settings import BASE_DIR
   171              from ruamel import yaml
   172              accounts = list(self.accounts.values())
   173              with open(os.path.join(BASE_DIR, "deploy/tmp/accounts.yml"), mode="w", encoding="UTF-8") as f:
   174                  yaml.dump(accounts, f, Dumper=yaml.RoundTripDumper)
   175          debug()
   176          return address, prikey
   177  
   178      def find_pri_key(self, address):
   179          return self.accounts[address]["prikey"]