def __init__(self, contract_path):
"""
init precompile address for TableFactory precompile and CRUDPrecompile
"""
self.tableFactory_address = "0x0000000000000000000000000000000000001001"
self.crud_address = "0x0000000000000000000000000000000000001002"
self.contract_path = contract_path
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self.crud_address, contract_path, "CRUD")
self.tableFactory_client = transaction_common.TransactionCommon(
self.tableFactory_address, contract_path, "TableFactory")
self.define_const()
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 issue_post(issueBill=None): # noqa: E501
"""Issue a transaction
# noqa: E501
:param issueBill:
:type issueBill: dict | bytes
:rtype: State
"""
if connexion.request.is_json:
try:
issueBill = IssueBill.from_dict(
connexion.request.get_json()) # noqa: E501
tx_client = transaction_common.TransactionCommon(
contract_address, contract_dir, contract_name)
fn_args = []
fn_args.append(issueBill.lender_key)
fn_args.append(issueBill.money)
fn_args.append(issueBill.info)
receipt = tx_client.send_transaction_getReceipt(
"buyAndCheck", fn_args)[0]
data_parser = DatatypeParser(default_abi_file(contract_name))
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
except:
return False
else:
return True
def finace_post(finaceBill=None): # noqa: E501
"""Finace a bill
# noqa: E501
:param finaceBill:
:type finaceBill: dict | bytes
:rtype: State
"""
print('helloWorld')
if connexion.request.is_json:
try:
finaceBill = FinaceBill.from_dict(
connexion.request.get_json()) # noqa: E501
tx_client = transaction_common.TransactionCommon(
contract_address, contract_dir, contract_name)
fn_args = []
fn_args.append(int(finaceBill.money))
fn_args.append(finaceBill.bill_index)
receipt = tx_client.send_transaction_getReceipt(
"borrowMoney", fn_args)[0]
data_parser = DatatypeParser(default_abi_file(contract_name))
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
except:
return False
else:
return True
def __init__(self, contract_path):
"""
init the address for SystemConfig contract
"""
self._config_address = "0x0000000000000000000000000000000000001000"
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self._config_address, contract_path, "SystemConfig")
def __init__(self, contract_path):
"""
init the address and contract path for PermissionService
"""
self.permission_address = "0x0000000000000000000000000000000000001005"
self.contract_path = contract_path
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self.permission_address, contract_path, "Permission")
def __init__(self, contract_path):
"""
init the address for Consensus contract
"""
self._consensus_address = "0x0000000000000000000000000000000000001003"
self.contract_name = "Consensus"
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self._consensus_address, contract_path, self.contract_name)
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 sendTx(contractname, contractAddr, funcName, params):
try:
tx_client = transaction_common.TransactionCommon(
contractAddr, contracts_dir, contractname)
receipt = tx_client.send_transaction_getReceipt(funcName, params)[0]
data_parser = DatatypeParser(default_abi_file(contractname))
# 解析receipt里的log 和 相关的tx ,output
return print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
# return result
except Exception as e:
return "error"
def __init__(self, contract_path):
"""
init the address for CNS contract
"""
self.logger = clientlogger.logger
self._cns_address = "0x0000000000000000000000000000000000001004"
self._max_version_len = 40
self.define_error_code()
# define bcosclient
self.contract_name = "CNS"
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self._cns_address, contract_path, self.contract_name)
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 settle_post(settleBill=None): # noqa: E501
"""settle a bill
# noqa: E501
:param settleBill:
:type settleBill: dict | bytes
:rtype: State
"""
print('helloWorld')
if connexion.request.is_json:
try:
settleBill = SettleBill.from_dict(
connexion.request.get_json()) # noqa: E501
tx_client = transaction_common.TransactionCommon(
contract_address, contract_dir, contract_name)
fn_args = []
fn_args.append(settleBill.bill_index)
receipt = tx_client.send_transaction_getReceipt(
"settleCheck", fn_args)[0]
data_parser = DatatypeParser(default_abi_file(contract_name))
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
except:
# res = flask.make_response("false",404)
# res.headers['Access-Control-Allow-Origin'] = '*'
# res.headers['Access-Control-Allow-Methods'] = 'POST，GET,OPTIONS'
# res.headers['Access-Control-Allow-Headers'] = 'x-requested-with,content-type'
return False
else:
# res = flask.make_response("")
# res = flask.make_response(data)
# res.headers['Access-Control-Allow-Origin'] = '*'
# res.headers['Access-Control-Allow-Methods'] = 'POST，GET,OPTIONS'
# res.headers['Access-Control-Allow-Headers'] = 'x-requested-with,content-type'
return True
def bills_get(accountAddress): # noqa: E501
"""Get the list of Bills of the current account
# noqa: E501
:param accountAddress: the corresponding account's address
:type accountAddress: str
:rtype: BillList
"""
print('helloWorld')
contract_address = "0xc0dcd5c4efe2c832781c9c0f8cb073cada16ef72" #合约地址
contract_dir = "contracts" #合约目录
contract_name = "Supply" #合约名字
accountAddress = "a599d3672309bd85c66aaa67a0ab5dfff4ba4d88"
tx_client = transaction_common.TransactionCommon(contract_address,
contract_dir,
contract_name)
res_length = tx_client.call_and_decode("getReceiptLength",
[accountAddress])
length = res_length[0]
receipt = []
for i in range(length):
receipt.append(
tx_client.call_and_decode("getReceipt",
[accountAddress, str(i)]))
return receipt
# myClient = bcos.BcosClient()
# contract_abi_path = contract_dir + "/" + contract_name + ".abi"
# load_f = open(contract_abi_path, 'r')
# contract_abi = json.load(load_f)
# load_f.close()
# res = myClient.call(contract_address, contract_abi, "getReceipt", ["a599d3672309bd85c66aaa67a0ab5dfff4ba4d88","0"])
return res
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)
from swagger_server.models.finace_bill import FinaceBill # noqa: E501
from swagger_server.models.issue_bill import IssueBill # noqa: E501
from swagger_server.models.settle_bill import SettleBill # noqa: E501
from swagger_server.models.state import State # noqa: E501
from swagger_server.models.transfer_bill import TransferBill # noqa: E501
from swagger_server import util
from client.common import transaction_common
from client.datatype_parser import DatatypeParser
contract_address = "0xc0dcd5c4efe2c832781c9c0f8cb073cada16ef72" #合约地址
contract_dir = "contracts" #合约目录
contract_name = "Supply" #合约名字
accountAddress = "a599d3672309bd85c66aaa67a0ab5dfff4ba4d88"
tx_client = transaction_common.TransactionCommon(contract_address,
contract_dir, contract_name)
def print_parse_transaction(tx, contractname, parser=None):
if parser is None:
parser = DatatypeParser(default_abi_file(contractname))
inputdata = tx["input"]
inputdetail = parser.parse_transaction_input(inputdata)
print("INFO >> transaction hash : ", tx["hash"])
print("tx input data detail:\n {}".format(inputdetail))
return (inputdetail)
def default_abi_file(contractname):
abi_file = contractname
if not abi_file.endswith(
from client.common import transaction_common
from flask import Flask, request, render_template
app = Flask(__name__)
tx_client = transaction_common.TransactionCommon(
"0x2d1c577e41809453c50e7e5c3f57d06f3cdd90ce", "contracts", "HelloWorld")
@app.route('/index/', methods=['GET', 'POST'])
def index():
if request.method == 'POST':
new_str = request.form['new_str']
tx_client.send_transaction_getReceipt("set", (new_str, ))
get_str = tx_client.call_and_decode("get")
return render_template("index.html", get_str=get_str)
if __name__ == '__main__':
app.debug = True
app.run()
