def create_user(request): user_id = request.POST.get('user_id') user_password = request.POST.get('user_password') balance = int(request.POST.get('balance')) info = request.POST.get('info') contract_name = "Admin" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt( contract_address, contract_abi, "create_user", [user_id, user_password, balance, info]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 0: 0, # success -1: -1, # user already exists -2: -2, # unknown error } ret_code = code_map[res[0]] if ret_code == 0: # success create user contract_name = "Admin" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt(contract_address, contract_abi, "login", [user_id, user_password]) client.finish() return JsonResponse({"code": ret_code})
def get_arbitration_reason(request): transaction_id = int(request.POST.get('transaction_id')) contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "get_arbitration_reason", [transaction_id]) client.finish() arbitration_reason = res[0] if arbitration_reason == "NULL": ret_code = -1 # no such transaction arbitration_reason = "" else: ret_code = 0 # success return JsonResponse({ "code": ret_code, "arbitration_reason": arbitration_reason, })
def get_user_info(request): user_id = request.POST.get('user_id') contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "get_user_info", [user_id]) client.finish() user_info = { "id": res[0], "info": res[1], "balance": res[2], "state": res[3], } ret_code = 0 if user_info["state"] != -999 else -1 response = { "code": ret_code, } if ret_code == 0: response["user"] = user_info return JsonResponse(response)
def get_commodity_info(request): commodity_id = int(request.POST.get('commodity_id')) contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "get_commodity_info", [commodity_id]) client.finish() commodity_info = { "owner": res[0], "name": res[1], "image": res[2], "desc": res[3], "price": res[4], "state": res[5], "id": res[6], "type": res[7], } ret_code = 0 if commodity_info["state"] != -999 else -1 response = { "code": ret_code, } if ret_code == 0: response["commodity"] = commodity_info return JsonResponse(response)
def initiate_arbitration(request): user_id = request.POST.get('user_id') transaction_id = int(request.POST.get('transaction_id')) arbitration_reason = request.POST.get('arbitration_reason') contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt( contract_address, contract_abi, "initiate_arbitration", [user_id, transaction_id, arbitration_reason]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 0: 0, # success -1: -1, # user state error -2: -2, # no such transaction -3: -3, # unable to change state -4: -4, # arbitration timeout -5: -5, # unknown error } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def deal_arbitration(request): transaction_id = int(request.POST.get('transaction_id')) arbitration_valid = int(request.POST.get('arbitration_valid')) contract_name = "Admin" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt( contract_address, contract_abi, "deal_arbitration", [transaction_id, arbitration_valid]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 0: 0, # success -1: -1, # no such transaction -2: -2, # unable to undo transaction -3: -3, # unable to change transaction state -4: -4, # unable to change commodity state -5: 0, # success } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def start(self): print('client '+str(self.id)+" start") bcos_event = BcosEventCallback() bcos_event.setclient(BcosClient()) cn = ContractNote() address = cn.get_last('gmodel') abifile = "contracts/gmodel.abi" abiparser = DatatypeParser(abifile) eventcallback01 = EventCallbackImpl01(self.model,self.Update,self.Gmodel,self.cur_round,self.fdfs) eventcallback01.abiparser = abiparser print("register events") result = bcos_event.register_eventlog_filter( eventcallback01, abiparser, [address], 'modelupdate', None) print( "after register ,event_name:{},result:{},all:{}".format( 'modelupdate', result['result'], result)) #获取全局模型轮次 cur_round = self.Gmodel.get_round()[1][0] while(cur_round<5): print("the "+str(cur_round)+" th round") print("client "+str(self.id)+" waiting gmodel_update...") cur_round = self.Gmodel.get_round()[1][0] time.sleep(10)
def main(argv): global parser global client if len(argv) < 3: usage() exit(0) contractname = argv[0] address = argv[1] event_name = argv[2] indexed_value = argv[3:] try: print("usage input {},{},{},{}".format(contractname, address, event_name, indexed_value)) if address == "last": cn = ContractNote() address = cn.get_last(contractname) print("hex address :", address) abifile = "contracts/" + contractname + ".abi" parser = DatatypeParser(abifile) client = BcosClient() print(client.getinfo()) register_event_callback([address], event_name, indexed_value) except Exception as e: import traceback traceback.print_exc() client.finish() import time time.sleep(0.5) sys.exit(-1)
def call(self, inputparams): if len(inputparams) == 0: sols = list_files(contracts_dir + "/*.sol") for sol in sols: print(sol + ".sol") return common.check_param_num(inputparams, 3) paramsname = ["contractname", "address", "func"] params = fill_params(inputparams, paramsname) contractname = params["contractname"] address = params["address"] if address == "last" or address == "latest": address = ContractNote.get_last(contractname) if address is None: sys.exit("can not get last address for [{}],break;".format( contractname)) tx_client = transaction_common.TransactionCommon( address, contracts_dir, contractname) fn_name = params["func"] fn_args = inputparams[3:] print("INFO>> client info: {}".format(tx_client.getinfo())) print("INFO >> call {} , address: {}, func: {}, args:{}".format( contractname, address, fn_name, fn_args)) try: result = tx_client.call_and_decode(fn_name, fn_args) common.print_tx_result(result) except Exception as e: common.print_error_msg("call", e)
def buy_commodity(request): user_id = request.POST.get('user_id') commodity_id = int(request.POST.get('commodity_id')) transaction_desc = request.POST.get('transaction_desc', "") contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt( contract_address, contract_abi, "buy_commodity", [user_id, commodity_id, transaction_desc]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 0: 0, # success -1: -1, # user state error -2: -2, # commodity state error -3: -3, # no enough money -4: -4, # unable to change owner of commodity -5: -5, # ubable to generate transaction } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def get_transaction_info(request): transaction_id = int(request.POST.get('transaction_id')) contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "get_transaction_info", [transaction_id]) client.finish() transaction_info = { "user_id_sell": res[1], "user_id_buy": res[2], "desc": res[3], "commodity_id": res[4], "price": res[5], "state": res[6], "id": transaction_id, } ret_code = 0 if transaction_info["state"] != -999 else -1 response = { "code": ret_code, } if ret_code == 0: response["transaction"] = transaction_info return JsonResponse(response)
def user_transaction_sell_list(request): user_id = request.POST.get('user_id') max_item_count = request.POST.get("page_max_items") page_id = request.POST.get("page_id") if max_item_count is None or page_id is None: max_item_count = page_id = None else: max_item_count = int(max_item_count) page_id = int(page_id) if max_item_count < 1 or page_id < 0: max_item_count = page_id = None contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() sell_res = client.call(contract_address, contract_abi, "get_transaction_sell_list", [user_id]) transaction_sell_list = [] transaction_sell_count = 0 for transaction_id in sell_res[0]: res = client.call(contract_address, contract_abi, "get_transaction_info", [transaction_id]) transaction_info = { "user_id_sell": res[1], "user_id_buy": res[2], "desc": res[3], "commodity_id": res[4], "price": res[5], "state": res[6], "id": transaction_id, } ret_code = 0 if transaction_info["state"] != -999 else -1 if ret_code == 0: transaction_sell_list.append(transaction_info) transaction_sell_count += 1 client.finish() if max_item_count is None: page_num = 1 if len(transaction_sell_list) > 0 else 0 else: page_num = (len(transaction_sell_list) + max_item_count - 1) // max_item_count transaction_sell_list = transaction_sell_list[page_id * max_item_count:(page_id + 1) * max_item_count] return JsonResponse({ "transaction_list": transaction_sell_list, "page_num": page_num, })
def down_commodity(request): user_id = request.POST.get('user_id') commodity_id = int(request.POST.get('commodity_id')) contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt(contract_address, contract_abi, "putdown_commodity", [user_id, commodity_id]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 1: 0, # success -1: -1, # user state error -2: -2, # unknown error } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def auth_user(request): user_id = request.POST.get('user_id') user_password = request.POST.get('user_password') contract_name = "Admin" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "valid_psd", [user_id, user_password]) client.finish() code_map = { 1: 0, # success -1: -1, # user don't exists -2: -2, # wrong password } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def checkContractExit(self, contract_name): #address = ContractNote.get_contract_addresses(contract_name) address = ContractNote.get_last(contract_name) if address is None: return False, None else: # 暂时返回低一个就可以了 return True, address
def main(argv): if len(argv) < 2: usage() exit(0) contractname = argv[0] address = argv[1] event_name = None indexed_value = None if len(argv) > 2: event_name = argv[2] indexed_value = argv[3:] try: bcos_event = BcosEventCallback() if client_config.client_protocol is not client_config.PROTOCOL_CHANNEL: print( "** using event callback, client prototol MUST be client_config.PROTOCOL_CHANNEL!!" ) print("** please check the configure file") sys.exit(-1) bcos_event.setclient(BcosClient()) print(bcos_event.client.getinfo()) print("usage input {},{},{},{}".format(contractname, address, event_name, indexed_value)) print(address) if address == "last" or address == "latest": cn = ContractNote() address = cn.get_last(contractname) print("hex address :", address) abifile = "contracts/" + contractname + ".abi" abiparser = DatatypeParser(abifile) eventcallback01 = EventCallbackImpl01() eventcallback02 = EventCallbackImpl02() eventcallback01.abiparser = abiparser eventcallback02.abiparser = abiparser result = bcos_event.register_eventlog_filter(eventcallback01, abiparser, [address], event_name, indexed_value) #result = bcos_event.register_eventlog_filter(eventcallback02,abiparser, [address], "on_number") print("after register ,event_name:{},result:{},all:{}".format( event_name, result['result'], result)) while True: print("waiting event...") time.sleep(10) except Exception as e: print("Exception!") import traceback traceback.print_exc() finally: print("event callback finished!") if bcos_event.client is not None: bcos_event.client.finish() sys.exit(-1)
def user_commodity_list(request): user_id = request.POST.get('user_id') max_item_count = request.POST.get("page_max_items") page_id = request.POST.get("page_id") if max_item_count is None or page_id is None: max_item_count = page_id = None else: max_item_count = int(max_item_count) page_id = int(page_id) if max_item_count < 1 or page_id < 0: max_item_count = page_id = None contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, "get_commodity_list", [user_id]) commodity_id_list, commodity_count = res commodity_list = [] for commodity_id in commodity_id_list: commodity_info = client.call(contract_address, contract_abi, "get_commodity_info", [commodity_id]) commodity_info = { "owner": commodity_info[0], "name": commodity_info[1], "image": commodity_info[2], "desc": commodity_info[3], "price": commodity_info[4], "state": commodity_info[5], "id": commodity_info[6], "type": commodity_info[7], } if commodity_info["state"] != -999: commodity_list.append(commodity_info) client.finish() if max_item_count is None: page_num = 1 if len(commodity_list) > 0 else 0 else: page_num = (len(commodity_list) + max_item_count - 1) // max_item_count commodity_list = commodity_list[page_id * max_item_count:(page_id + 1) * max_item_count] return JsonResponse({ "commodity_list": commodity_list, "page_num": page_num, })
def create_commodity(request): user_id = request.POST.get('user_id') commodity_name = request.POST.get('commodity_name') commodity_desc = request.POST.get('commodity_desc') commodity_image = request.FILES.get('commodity_image') static_dir = settings.STATICFILES_DIRS[0] image_id = get_random_id(length=18) ext = os.path.splitext(commodity_image.name)[-1] image_name = image_id + ext image_save_path = os.path.join(static_dir, image_name) with open(image_save_path, 'wb') as f: for content in commodity_image.chunks(): f.write(content) scale_image_too_big(image_save_path) commodity_image = "/static/" + image_name contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() receipt = client.sendRawTransactionGetReceipt( contract_address, contract_abi, "create_commodity", [user_id, commodity_name, commodity_image, commodity_desc]) txhash = receipt['transactionHash'] txresponse = client.getTransactionByHash(txhash) inputresult = data_parser.parse_transaction_input(txresponse['input']) res = data_parser.parse_receipt_output(inputresult['name'], receipt['output']) client.finish() code_map = { 1: 0, # success -1: -1, # user state error -2: -2, # unknown error } ret_code = code_map[res[0]] return JsonResponse({"code": ret_code})
def sendtx(self, inputparams): if len(inputparams) == 0: sols = list_files(contracts_dir + "/*.sol") for sol in sols: print(sol + ".sol") return common.check_param_num(inputparams, 3) paramsname = ["contractname", "address", "func"] params = fill_params(inputparams, paramsname) contractname = params["contractname"] address = params["address"] if address == "last" or address == "latest": address = ContractNote.get_last(contractname) if address is None: sys.exit("can not get last address for [{}],break;".format( contractname)) tx_client = transaction_common.TransactionCommon( address, contracts_dir, contractname) fn_name = params["func"] fn_args = inputparams[3:] print("INFO>> client info: {}".format(tx_client.getinfo())) print("INFO >> sendtx {} , address: {}, func: {}, args:{}".format( contractname, address, fn_name, fn_args)) try: from_account_signer = None # from_account_signer = Signer_ECDSA.from_key_file( # "bin/accounts/tester.keystore", "123456") # print(keypair.address) # 不指定from账户,如需指定,参考上面的加载,或者创建一个新的account, # 参见国密(client.GM_Account)和非国密的account管理类LocalAccount (receipt, output) = tx_client.send_transaction_getReceipt( fn_name, fn_args, from_account_signer=from_account_signer) data_parser = DatatypeParser(tx_client.contract_abi_path) # 解析receipt里的log 和 相关的tx ,output print_receipt_logs_and_txoutput(tx_client, receipt, "", data_parser) except Exception as e: common.print_error_msg("sendtx", e)
def search_commodity(request): keywords = request.POST.get("keywords") keywords = [keyword for keyword in keywords.split(' ') if len(keyword) > 0] commodity_type = request.POST.get("commodity_type") reverse = bool(int(request.POST.get("reverse", '0'))) max_item_count = request.POST.get("page_max_items") page_id = request.POST.get("page_id") if max_item_count is None or page_id is None: max_item_count = page_id = None else: max_item_count = int(max_item_count) page_id = int(page_id) if max_item_count < 1 or page_id < 0: max_item_count = page_id = None if commodity_type is None: query_method = "get_onsale_list" query_args = [] else: commodity_type = int(commodity_type) query_method = "get_onsale_type_list" query_args = [commodity_type] contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, query_method, query_args) commodity_id_list, commodity_count = res commodity_list = [] for commodity_id in commodity_id_list: commodity_info = client.call(contract_address, contract_abi, "get_commodity_info", [commodity_id]) commodity_info = { "owner": commodity_info[0], "name": commodity_info[1], "image": commodity_info[2], "desc": commodity_info[3], "price": commodity_info[4], "state": commodity_info[5], "id": commodity_info[6], "type": commodity_info[7], } if commodity_info["state"] != -999: commodity_list.append(commodity_info) client.finish() commodity_match_score_list = [] for commodity_info in commodity_list: score = 0 for keyword in keywords: score += int(keyword.lower() in commodity_info["name"].lower()) score += int(keyword.lower() in commodity_info["desc"].lower()) commodity_match_score_list.append(score) commodity_list = [ item[0] for item in sorted(iter( i for i in zip(commodity_list, commodity_match_score_list) if i[1] > 0), key=lambda x: x[1], reverse=True) ] if reverse: commodity_list.reverse() if max_item_count is None: page_num = 1 if len(commodity_list) > 0 else 0 else: page_num = (len(commodity_list) + max_item_count - 1) // max_item_count commodity_list = commodity_list[page_id * max_item_count:(page_id + 1) * max_item_count] return JsonResponse({ "commodity_list": commodity_list, "page_num": page_num, })
def on_push(self, packmsg: ChannelPack): print("EventPushHandler", packmsg.detail()) strmsg = packmsg.data.decode("utf-8") response = json.loads(strmsg) print("response filterID:", response['filterID']) #print("response:", json.dumps(response,indent=4)) loglist = parser.parse_event_logs(response["logs"]) print(json.dumps(loglist, indent=4)) # 从文件加载abi定义 abi_file = "contracts/HelloEvent.abi" parser = data_parser = DatatypeParser(abi_file) contract_abi = data_parser.contract_abi contractnode = ContractNote() address = contractnode.get_last("HelloEvent") print("event contract address is ", address) client = None client = BcosClient() info = client.getinfo() print("client info:", info) params_set = ["aaabbb"] params_setnum_5 = ["setnum_ab", 5] params_setnum_10 = ["setnum_ab", 10] params_settwo_1 = ["settwo_aabb", 10, 'key1'] params_settwo_2 = ["settwo_aabb", 10, 'key2'] ''' CHANNEL_RPC_REQUEST = 0x12, // type for rpc request CLIENT_HEARTBEAT = 0x13, // type for heart beat for sdk
# with open("contracts/v1_2.bin", 'r') as load_f: # contract_bin = load_f.read() # load_f.close() # result = client.deploy(contract_bin) # print("deploy", result) # print("new address : ", result["contractAddress"]) contract_name = os.path.splitext(os.path.basename(abi_file))[0] # memo = "tx:" + result["transactionHash"] # 把部署结果存入文件备查 # ContractNote.save_address(contract_name, # result["contractAddress"], # int(result["blockNumber"], 16), memo) # 发送交易,调用一个改写数据的接口 print("\n>>sendRawTransaction:----------------------------------------------------") # 获取智能合约的地址 to_address = ContractNote.get_last(contract_name) args = None receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi, "Task1", args) print("receipt:", receipt) # 解析receipt里的log print("\n>>parse receipt and transaction:--------------------------------------") txhash = receipt['transactionHash'] print("transaction hash: ", txhash) logresult = data_parser.parse_event_logs(receipt["logs"]) i = 0 for log in logresult: if 'eventname' in log: i = i + 1 print("{}): log name: {} , data: {}".format(i, log['eventname'], log['eventdata']))
def main(argv): try: usagemsg = usage(client_config) cmd, inputparams = parse_commands(argv) precompile = Precompile(cmd, inputparams, contracts_dir + "/precompile") # check cmd valid = check_cmd(cmd, validcmds) if valid is False: printusage(usagemsg, precompile) return # try to callback cns precompile precompile.call_cns() # try to callback consensus precompile precompile.call_consensus() # try to callback config precompile precompile.call_sysconfig_precompile() # try to callback permission precompile precompile.call_permission_precompile() # try to callback crud precompile precompile.call_crud_precompile() # try to callback rpc functions rpcConsole = RPCConsole(cmd, inputparams, contracts_dir) rpcConsole.executeRpcCommand() if cmd == 'showaccount': # must be 2 params common.check_param_num(inputparams, 2, True) name = inputparams[0] password = inputparams[1] keyfile = "{}/{}.keystore".format( client_config.account_keyfile_path, name) # the account doesn't exists if os.path.exists(keyfile) is False: raise BcosException("account {} doesn't exists".format(name)) print("show account : {}, keyfile:{} ,password {} ".format( name, keyfile, password)) try: with open(keyfile, "r") as dump_f: keytext = json.load(dump_f) stat = StatTool.begin() privkey = Account.decrypt(keytext, password) stat.done() print("decrypt use time : %.3f s" % (stat.time_used)) ac2 = Account.from_key(privkey) print("address:\t", ac2.address) print("privkey:\t", encode_hex(ac2.key)) print("pubkey :\t", ac2.publickey) print("\naccount store in file: [{}]".format(keyfile)) print("\n**** please remember your password !!! *****") except Exception as e: raise BcosException(("load account info for [{}] failed," " error info: {}!").format(name, e)) if cmd == 'newaccount': common.check_param_num(inputparams, 2, True) name = inputparams[0] max_account_len = 240 if len(name) > max_account_len: common.print_info( "WARNING", "account name should no more than {}".format( max_account_len)) sys.exit(1) password = inputparams[1] print("starting : {} {} ".format(name, password)) ac = Account.create(password) print("new address :\t", ac.address) print("new privkey :\t", encode_hex(ac.key)) print("new pubkey :\t", ac.publickey) stat = StatTool.begin() kf = Account.encrypt(ac.privateKey, password) stat.done() print("encrypt use time : %.3f s" % (stat.time_used)) keyfile = "{}/{}.keystore".format( client_config.account_keyfile_path, name) print("save to file : [{}]".format(keyfile)) forcewrite = False if not os.access(keyfile, os.F_OK): forcewrite = True else: # old file exist,move to backup file first if (len(inputparams) == 3 and inputparams[2] == "save"): forcewrite = True else: forcewrite = common.backup_file(keyfile) if forcewrite: with open(keyfile, "w") as dump_f: json.dump(kf, dump_f) dump_f.close() print(">>-------------------------------------------------------") print( "INFO >> read [{}] again after new account,address & keys in file:" .format(keyfile)) with open(keyfile, "r") as dump_f: keytext = json.load(dump_f) stat = StatTool.begin() privkey = Account.decrypt(keytext, password) stat.done() print("decrypt use time : %.3f s" % (stat.time_used)) ac2 = Account.from_key(privkey) print("address:\t", ac2.address) print("privkey:\t", encode_hex(ac2.key)) print("pubkey :\t", ac2.publickey) print("\naccount store in file: [{}]".format(keyfile)) print("\n**** please remember your password !!! *****") dump_f.close() # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "deploy": '''deploy abi bin file''' # must be at least 2 params common.check_param_num(inputparams, 1) contractname = inputparams[0].strip() gasPrice = 30000000 # need save address whether or not needSaveAddress = False args_len = len(inputparams) if inputparams[-1] == "save": needSaveAddress = True args_len = len(inputparams) - 1 # get the args fn_args = inputparams[1:args_len] trans_client = transaction_common.TransactionCommon( "", contracts_dir, contractname) result = trans_client.send_transaction_getReceipt( None, fn_args, gasPrice, True)[0] print("deploy result for [{}] is:\n {}".format( contractname, json.dumps(result, indent=4))) name = contractname address = result['contractAddress'] blocknum = int(result["blockNumber"], 16) ContractNote.save_contract_address(name, address) print("on block : {},address: {} ".format(blocknum, address)) if needSaveAddress is True: ContractNote.save_address(name, address, blocknum) print("address save to file: ", client_config.contract_info_file) else: print('''\nNOTE : if want to save new address as last address for (call/sendtx)\nadd 'save' to cmdline and run again''' ) # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "call" or cmd == "sendtx": common.check_param_num(inputparams, 3) paramsname = ["contractname", "address", "func"] params = fill_params(inputparams, paramsname) contractname = params["contractname"] address = params["address"] if address == "last": address = ContractNote.get_last(contractname) if address is None: sys.exit("can not get last address for [{}],break;".format( contractname)) tx_client = transaction_common.TransactionCommon( address, contracts_dir, contractname) fn_name = params["func"] fn_args = inputparams[3:] print("INFO >> {} {} , address: {}, func: {}, args:{}".format( cmd, contractname, address, fn_name, fn_args)) if cmd == "call": result = tx_client.call_and_decode(fn_name, fn_args) print("INFO >> {} result: {}".format(cmd, result)) if cmd == "sendtx": receipt = tx_client.send_transaction_getReceipt( fn_name, fn_args)[0] data_parser = DatatypeParser(default_abi_file(contractname)) # 解析receipt里的log 和 相关的tx ,output print_receipt_logs_and_txoutput(tx_client, receipt, "", data_parser) # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "list": RPCConsole.print_rpc_usage() print( "--------------------------------------------------------------------" ) # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "txinput": contractname = inputparams[0] inputdata = inputparams[1] abi_path = default_abi_file(contractname) if os.path.isfile(abi_path) is False: raise BcosException( "execute {} failed for {} doesn't exist".format( cmd, abi_path)) try: dataParser = DatatypeParser(abi_path) # print(dataParser.func_abi_map_by_selector) result = dataParser.parse_transaction_input(inputdata) print("\nabifile : ", default_abi_file(contractname)) print("parse result: {}".format(result)) except Exception as e: raise BcosException("execute {} failed for reason: {}".format( cmd, e)) # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "checkaddr": address = inputparams[0] result = to_checksum_address(address) print("{} -->\n{}".format(address, result)) # -------------------------------------------------------------------------------------------- # console cmd entity # -------------------------------------------------------------------------------------------- if cmd == "usage": printusage(usagemsg, precompile) except TransactionException as e: common.print_error_msg(cmd, e) except PrecompileError as e: common.print_error_msg(cmd, e) except BcosError as e: common.print_error_msg(cmd, e) except CompileError as e: common.print_error_msg(cmd, e) except ArgumentsError as e: common.print_error_msg(cmd, e) except BcosException as e: common.print_error_msg(cmd, e)
call a constant funciton of contract and get the returns eg: call SimpleInfo 0xF2c07c98a6829aE61F3cB40c69f6b2f035dD63FC getbalance1 11 if address is "last" ,then load last address from :{} eg: call SimpleInfo last getall '''.format(client_config.contract_info_file)) if cmd == "call": paramsname = ["contractname", "address", "func"] params = fill_params(inputparams, paramsname) args = inputparams[len(paramsname):] contractname = params["contractname"] data_parser = DatatypeParser(default_abi_file(contractname)) contract_abi = data_parser.contract_abi address = params["address"] if address == "last": address = ContractNote.get_last(contractname) if address == None: sys.exit("can not get last address for [{}],break;".format( contractname)) funcname = params["func"] inputabi = data_parser.func_abi_map_by_name[funcname]["inputs"] args = format_args_by_abi(args, inputabi) print("call {} , address: {}, func: {}, args:{}".format( contractname, address, funcname, args)) result = client.call(address, contract_abi, funcname, args) print("call result: ", result) #-------------------------------------------------------------------------------------------- # console cmd entity #-------------------------------------------------------------------------------------------- validcmds.append("sendtx")
def market_commodity_list_order_by_price(request): commodity_type = request.POST.get("commodity_type") reverse = bool(int(request.POST.get("reverse", '0'))) max_item_count = request.POST.get("page_max_items") page_id = request.POST.get("page_id") if max_item_count is None or page_id is None: max_item_count = page_id = None else: max_item_count = int(max_item_count) page_id = int(page_id) if max_item_count < 1 or page_id < 0: max_item_count = page_id = None if commodity_type is None: query_method = "get_onsale_list" query_args = [] else: commodity_type = int(commodity_type) query_method = "get_onsale_type_list" query_args = [commodity_type] contract_name = "User" contract_address = ContractNote.get_last(contract_name) abi_file = f"contracts/{contract_name}.abi" data_parser = DatatypeParser() data_parser.load_abi_file(abi_file) contract_abi = data_parser.contract_abi client = BcosClient() res = client.call(contract_address, contract_abi, query_method, query_args) commodity_id_list, commodity_count = res commodity_list = [] for commodity_id in commodity_id_list: commodity_info = client.call(contract_address, contract_abi, "get_commodity_info", [commodity_id]) commodity_info = { "owner": commodity_info[0], "name": commodity_info[1], "image": commodity_info[2], "desc": commodity_info[3], "price": commodity_info[4], "state": commodity_info[5], "id": commodity_info[6], "type": commodity_info[7], } if commodity_info["state"] != -999: commodity_list.append(commodity_info) client.finish() commodity_list.sort(key=lambda commodity_info: commodity_info["price"], reverse=reverse) if max_item_count is None: page_num = 1 if len(commodity_list) > 0 else 0 else: page_num = (len(commodity_list) + max_item_count - 1) // max_item_count commodity_list = commodity_list[page_id * max_item_count:(page_id + 1) * max_item_count] return JsonResponse({ "commodity_list": commodity_list, "page_num": page_num, })