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)
