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"]