def call_crud_precompile(self): """ createTable """ try: if self._cmd not in self.functions["crud"]: return self.crud_serivce = CRUDService(self._contract_path) # create table if self._cmd == self.functions["crud"][0]: self.check_param_num(3) table = Table(self._args[0], self._args[1], ','.join(self._args[2:])) result = self.crud_serivce.create_table(table) self.print_succ_msg(result) # desc table if self._cmd == self.functions["crud"][1]: self.check_param_num(1) result = self.crud_serivce.desc(self._args[0]) if result is None: common.print_info( "WARN", "non-exist table {}".format(self._args[0])) except ArgumentsError as e: common.print_error_msg(self._cmd, e) self.print_crud_usage()
def print_permission_info(result): """ print permission info """ i = 0 if result is None: return if common.check_result(result) is False: return result_list = list(result) if result_list is None or len(result_list) < 1: return for permission_info in result_list: permission_item = json.loads(permission_info) for permission_obj in permission_item: print("----->> ITEM {}".format(i)) i = i + 1 if "address" in permission_obj.keys(): print(" = address: {}".format( permission_obj["address"])) print(" = enable_num: {}".format( permission_obj["enable_num"])) if i == 0: common.print_info(" ", "Empty Set, permission info: {}".format(result))
def query_cns_by_nameAndVersion(self, name, version): """ query contract address according to the contract name and version precompile api: selectByNameAndVersion(string, string) """ version = re.sub(r"\s+", "", version) common.print_info("INFO", "CNS version (strip space): {}".format(version)) fn_name = "selectByNameAndVersion" fn_args = [name, version] return self.client.call_and_decode(fn_name, fn_args)
def exec_command(self, cmd, params): """ exec_command """ self.client = BcosClient() function_name = self.get_func_name(cmd) # execute function ret_json = eval(function_name)(*params) common.print_info("INFO", self.cmd) common.print_result(ret_json) return ret_json
def parse_output(self, cmd, contract_name, result): """ parse the result """ if cmd in self.functions["parse_in"]: decode_result = common.parse_input(result["input"], contract_name, self.contract_path) common.print_info("input of transaction: {}", decode_result) if cmd in self.functions["parse_out"]: common.print_output_and_input(result["logs"], result["output"], result["input"], contract_name, self.contract_path)
def exec_command(self, cmd, params): """ exec_command """ self.client = BcosClient() function_name = self.get_func_name(cmd) # execute function ret_json = eval(function_name)(*params) common.print_info("INFO", self.cmd) if cmd in RPCConsole.functions["human_friendly_output"]: ret_json = self.convertHexToDec(cmd, ret_json) common.print_result(ret_json) return ret_json
def print_cns_info(cns_info): """ print cns information """ # common.print_result(cns_info) for cns_item in cns_info: cns_obj = json.loads(cns_item) i = 0 for cns in cns_obj: print("CNS ITEM {} >>".format(i)) print("\tContractName: {}".format(cns["name"])) print("\tContractVersion: {}".format(cns["version"])) print("\tContractAddress: {}".format(cns["address"])) i = i + 1 if i == 0: common.print_info(" ", "Empty Set, result: {}".format(cns_info))
def parse_output(self, cmd, contract_name, result): """ parse the result """ if "blockNumber" in result: blocknum = result["blockNumber"] if blocknum.startswith("0x"): blocknum = int(blocknum, 16) print("transaction in block number :", blocknum) if cmd in self.functions["parse_in"]: decode_result = common.parse_input(result["input"], contract_name, self.contract_path) common.print_info("transaction input", decode_result) if cmd in self.functions["parse_out"]: common.print_output_and_input(result["logs"], result["output"], result["input"], contract_name, self.contract_path)
def register_cns(self, name, version, address, abi): """ register cns contract: (name, version)->address precompile api: insert(string,string,string,string) """ common.check_and_format_address(address) version = re.sub(r"\s+", "", version) common.print_info("INFO", "CNS version (strip space): {}".format(version)) # invalid version if len(version) > self._max_version_len: error_info = self.get_error_msg(self._version_exceeds) self.logger.error("register cns failed, error info: {}".format(error_info)) raise BcosException(error_info) # call insert function of CNS # function definition: insert(string,string,string,string) fn_name = "insert" fn_args = [name, version, address, json.dumps(abi)] return self.client.send_transaction_getReceipt(fn_name, fn_args, self.gasPrice)
def newaccount(self, inputparams): 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] forcewrite = False if len(inputparams) == 3 and inputparams[2] == "save": forcewrite = True print("starting : {} {} , if save:{}".format(name, password, forcewrite)) if client_config.crypto_type == CRYPTO_TYPE_GM: self.create_gm_account(name, password) else: self.create_ecdsa_account(name, password)
def print_succ_msg(self, result): """ print succ msg """ if isinstance(result, tuple): receipt = result[0] output = result[1][0] if isinstance(receipt, dict) and "status" in receipt.keys(): common.print_info("INFO", self._cmd) print(" >> status: {}".format(receipt["status"])) print(" >> transactionHash: {}".format(receipt["transactionHash"])) print(" >> gasUsed: {}".format(receipt["gasUsed"])) if str(output) not in PrecompileCommon.error_code.keys(): print(" >> {} succ, output: {}".format(self._cmd, output)) else: print(" >> {}: {}" .format(output, PrecompileCommon.error_code[str(output)])) elif result is None: print("INFO >> {}: \n\tEmpty Set".format(self._cmd)) else: print("INFO >> {}: \n{}".format(self._cmd, result))
def print_rpc_usage(): """ print rpc usage information """ common.print_info("", "RPC commands") for command in RPCConsole.functions["zero"]: print(" ", "[{}]".format(command)) for command in RPCConsole.functions["one_int"]: print(" ", "[{}] [number]".format(command)) for command in RPCConsole.functions["one_hash"]: if command == "getCode": continue print(" ", "[{}] [hash] [contract_name]".format(command)) print(" ", ("[getCode] [contract_address]")) print(" ", ("[getTransactionByBlockHashAndIndex] " "[blockHash] [transactionIndex] [contract_name]")) print(" ", ("[getTransactionByBlockNumberAndIndex] " "[blockNumber] [transactionIndex] [contract_name]")) print( " ", "[{}] [tx_count_limit/tx_gas_limit]".format( "getSystemConfigByKey")) print(" ", "[{}] [blockNumber] True/False".format("getBlockByNumber")) print(" ", "[{}] [blockHash] True/False".format("getBlockByHash"))
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)