def exec_cmd_with_hash_param(self, cmd, params):
"""
execute cmd with one hash param
"""
if cmd not in RPCConsole.functions["one_hash"]:
return
# check_param
common.check_param_num(params, 1, False)
# check contract address
if cmd == "getCode":
try:
if len(params) > 1:
raise ArgumentsError(
"{} must provide one param".format(cmd))
address = to_checksum_address(params[0])
self.exec_command(cmd, [address])
except Exception as e:
raise ArgumentsError("invalid address: {}, info: {}".format(
params[0], e))
else:
if len(params) > 2:
raise ArgumentsError(
"{} must provide no more than one param".format(cmd))
# check hash
common.check_hash(params[0])
result = self.exec_command(cmd, [params[0]])
if len(params) < 2 or result is None:
return
self.parse_output(cmd, params[1], result)
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 exec_cmd_with_str_param(self, cmd, params):
"""
execute cmd with one star params
"""
if cmd not in RPCConsole.functions["one_str"]:
return
common.check_param_num(params, 1, True)
self.exec_command(cmd, params)
def exec_cmd_with_zero_param(self, cmd, params):
"""
execute cmd with zero param
"""
if cmd not in RPCConsole.functions["zero"]:
return
# check param
common.check_param_num(params, 0, True)
self.exec_command(cmd, params)
def deploy(self, inputparams):
print(inputparams)
if len(inputparams) == 0:
sols = list_files(contracts_dir + "/*.sol")
for sol in sols:
print(sol + ".sol")
return
"""deploy abi bin file"""
# must be at least 2 params
common.check_param_num(inputparams, 1)
contractname = inputparams[0].strip()
# need save address whether or not
needSaveAddress = True
args_len = len(inputparams)
# 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]
tx_client = transaction_common.TransactionCommon(
"", contracts_dir, contractname)
try:
receipt = tx_client.send_transaction_getReceipt(None,
fn_args,
deploy=True)[0]
print("INFO >> client info: {}".format(tx_client.getinfo()))
print("deploy result for [{}] is:\n {}".format(
contractname, json.dumps(receipt, indent=4)))
name = contractname
address = receipt["contractAddress"]
blocknum = int(receipt["blockNumber"], 16)
txhash = receipt["transactionHash"]
ContractNote.save_contract_address(name, address)
print("on block : {},address: {} ".format(blocknum, address))
if needSaveAddress is True:
ContractNote.save_address_to_contract_note(name, address)
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"""
)
ContractNote.save_history(name, address, blocknum, txhash)
data_parser = DatatypeParser(default_abi_file(contractname))
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
except Exception as e:
print("deploy exception! ", e)
traceback.print_exc()
tx_client.finish()
def exec_cmd_with_int_param(self, cmd, params):
"""
execute cmd with one param, and the param is a int
"""
if cmd not in RPCConsole.functions["one_int"]:
return
# check param
common.check_param_num(params, 1, True)
# check int range
number = common.check_int_range(params[0])
self.exec_command(cmd, [number])
def exec_cmd_with_two_bool_param(self, cmd, params):
"""
execute cmd with two params
"""
if cmd not in RPCConsole.functions["two_bool"]:
return
# check param
common.check_param_num(params, 1, False)
if len(params) > 2:
raise ArgumentsError("params must be no more than 2")
self.exec_command(cmd, params)
def exec_cmd_with_two_param(self, cmd, params):
"""
execute command with two params:
"""
if cmd not in RPCConsole.functions["two"]:
return
# check param
common.check_param_num(params, 2, False)
if len(params) > 3:
raise ArgumentsError("{} : params must be no more than 3")
index = common.check_int_range(params[1])
result = None
# check param type
if cmd == "getTransactionByBlockHashAndIndex":
common.check_hash(params[0])
result = self.exec_command(cmd, [params[0], index])
if cmd == "getTransactionByBlockNumberAndIndex":
number = common.check_int_range(params[0])
result = self.exec_command(cmd, [number, index])
self.parse_tx_and_receipt(result, cmd, params)
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 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)
def check_param_num(self, expected, needEqual=False):
"""
check param num
"""
common.check_param_num(self._args, expected, needEqual)
