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 print_output_and_input(logs, output, txinput, contract_name, contract_path):
"""
parse_output_from_abi
"""
abi_path = os.path.join(contract_path, contract_name + ".abi")
if os.path.isfile(abi_path) is False:
raise BcosException("parse outpt failed for {} doesn't exist"
.format(abi_path))
try:
dataParser = DatatypeParser(abi_path)
# parse txinput
input_result = dataParser.parse_transaction_input(txinput)
if input_result is not None:
print_info("txinput result", input_result)
# get function name
fn_name = input_result["name"]
output_result = dataParser.parse_receipt_output(fn_name, output)
if output_result is None:
print_info("INFO", "empty return, output: {}".format(output))
return
print_info("output result", output_result)
log_result = dataParser.parse_event_logs(logs)
print_receipt_logs(log_result)
# print_info("log result", log_result)
except Exception as e:
raise BcosException("parse output failed for reason: {}".format(e))
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 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 fisco_add_data_demo():
try:
client = BcosClient()
print(client.getinfo())
abi_file = os.path.join(settings.SITE_ROOT, "contracts",
"HelloWorld.abi")
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
# 发送交易，调用一个改写数据的接口
print(
"\n>>sendRawTransaction:----------------------------------------------------"
)
to_address = '0x548fd1e8af9ca9131c04ab7e1031579f6498ddaf' # use new deploy address
args = ["xy1211ddd"]
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi,
"set", args)
print("receipt:", receipt)
# 解析receipt里的log
print(
"\n>>parse receipt and transaction:--------------------------------------"
)
tx_hash = receipt['transactionHash']
print("transaction hash: ", tx_hash)
log_result = data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in log_result:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(
i, log['eventname'], log['eventdata']))
# 获取对应的交易数据，解析出调用方法名和参数
tx_response = client.getTransactionByHash(tx_hash)
input_result = data_parser.parse_transaction_input(
tx_response['input'])
print("transaction input parse:", tx_hash)
print(input_result)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
output_result = data_parser.parse_receipt_output(
input_result['name'], receipt['output'])
print("receipt output :", output_result)
# 调用一下call，获取数据
print(
"\n>>Call:------------------------------------------------------------------------"
)
res = client.call(to_address, contract_abi, "get")
print("call get result:", res)
# 关闭连接
client.finish()
except:
pass
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 print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
print("\nINFO >> receipt logs : ")
# 解析receipt里的log
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
# modified by Bodhi Wang
# 2019.11.26
"""
i = 0
for log in logresult:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(i, log['eventname'], log['eventdata']))
"""
for i, log in enumerate(
[result for result in logresult if 'eventname' in result]):
print("{}): log name: {} , data: {}".format(i, log['eventname'],
log['eventdata']))
txhash = receipt["transactionHash"]
txresponse = client.getTransactionByHash(txhash)
inputdetail = print_parse_transaction(txresponse, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = parser.parse_receipt_output(inputdetail['name'],
receipt['output'])
print("receipt output :", outputresult)
class Client:
def __init__(self,contract_name, contract_address):
abi_file = os.path.join(settings.SITE_ROOT, "contracts", contract_name + ".abi")
self.data_parser = DatatypeParser()
self.data_parser.load_abi_file(abi_file)
self.contract_abi = self.data_parser.contract_abi
self.contract_address = contract_address
def fisco_add_data(self, func_name, args):
client = BcosClient()
try:
print('start')
# 发送交易
receipt = client.sendRawTransactionGetReceipt(self.contract_address, self.contract_abi, func_name, args)
print("receipt:", receipt)
# 解析receipt里的log
print("parse receipt and transaction:--------------------------------------")
tx_hash = receipt['transactionHash']
print("transaction hash: ", tx_hash)
log_result = self.data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in log_result:
if func_name in log:
i = i + 1
print("{}): log name: {} , data: {}".format(i, log[func_name], log['eventdata']))
# 获取对应的交易数据，解析出调用方法名和参数
tx_response = client.getTransactionByHash(tx_hash)
input_result = self.data_parser.parse_transaction_input(tx_response['input'])
print("transaction input parse:", tx_hash)
print(input_result)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
output_result = self.data_parser.parse_receipt_output(input_result['name'], receipt['output'])
print("receipt output :", output_result)
return output_result,tx_hash
except:
pass
finally:
# 关闭连接
client.finish()
def fisco_select_data(self, func_name, args):
client = BcosClient()
try:
print('start')
res = client.call(self.contract_address, self.contract_abi, func_name, args)
print("call get result:", res)
# 关闭连接
client.finish()
return res
except:
return None
def print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
txhash = receipt["transactionHash"]
txresponse = client.getTransactionByHash(txhash)
inputdetail = print_parse_transaction(txresponse, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = parser.parse_receipt_output(inputdetail['name'],
receipt['output'])
return outputresult
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 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 print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
print("INFO >> receipt logs : ")
# 解析receipt里的log
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
i = 0
# print(json.dumps(logresult,indent=4))
for log in logresult:
if "eventname" in log:
i = i + 1
print("{}): log name: {} , data: {} , topic: {}".format(
i, log["eventname"], log["eventdata"], log["topic"]))
inputdetail = print_parse_transaction(receipt, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresults = parser.parse_receipt_output(inputdetail["name"],
receipt["output"])
common.print_tx_result(outputresults)
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']))
#获取对应的交易数据，解析出调用方法名和参数
txresponse = client.getTransactionByHash(txhash)
inputresult = data_parser.parse_transaction_input(txresponse['input'])
print("transaction input parse:",txhash)
print(inputresult)
#解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = data_parser.parse_receipt_output(inputresult['name'], receipt['output'])
print("receipt output :",outputresult)
#调用一下call，获取数据
print("\n>>Call:------------------------------------------------------------------------")
res = client.call(to_address,contract_abi,"getbalance")
print("call getbalance result:",res)
res = client.call(to_address,contract_abi,"getbalance1",[100])
print("call getbalance1 result:",res)
res = client.call(to_address,contract_abi,"getname")
print("call getname:",res)
res = client.call(to_address,contract_abi,"getall")
print("call getall result:",res)
print("demo_tx,total req {}".format(client.request_counter))
client.finish()
'''
from client.datatype_parser import DatatypeParser
import json
if (True):
parser = DatatypeParser()
parser.load_abi_file("sample/SimpleInfo.abi")
parser.parse_abi()
with open("sample/receipt.json", "r") as f:
receipt = json.load(f)
f.close()
logs = receipt["logs"]
parser.parse_event_logs(logs)
print("parse result")
for log in logs:
print(log)
result = parser.parse_receipt_output("set", receipt['output'])
print("output :", result)
if True:
parser = DatatypeParser()
parser.load_abi_file("sample/SimpleInfo.abi")
parser.parse_abi()
with open("sample/tx_simpleinfo_set.json", "r") as f:
tx = json.load(f)
f.close()
result = parser.parse_transaction_input(tx["input"])
print(result)
class TransactionCommon(bcosclient.BcosClient):
"""
define common functions
"""
def __init__(self, contract_addr, contract_path, contract_name):
"""
init client to send transactions
"""
bcosclient.BcosClient.__init__(self)
self.contract_addr = contract_addr
self.contract_path = contract_path
(fname, extname) = os.path.splitext(contract_name)
if extname.endswith("wasm"):
# deal with wasm , not compile in this version, todo list
self.contract_abi_path = contract_path + "/" + fname + ".abi"
self.contract_bin_path = contract_path + "/" + contract_name
self.sol_path = contract_path + "/" + contract_name
else:
# deal with sol files ,may be force re compile sol file ,so set the sol filename
self.contract_abi_path = contract_path + "/" + contract_name + ".abi"
self.contract_bin_path = contract_path + "/" + contract_name + ".bin"
self.sol_path = contract_path + "/" + contract_name + ".sol"
if os.path.exists(self.sol_path) is False:
raise BcosException(("contract {} not exists,"
" please put {}.sol into {}").format(
contract_name, contract_name,
contract_path))
print("contract_abi_path {}, contract_bin_path {}".format(
self.contract_abi_path, self.contract_bin_path))
self.dataparser = None
if os.path.exists(self.contract_bin_path):
self.dataparser = DatatypeParser(self.contract_abi_path)
def __del__(self):
super().finish()
def set_contract_addr(self, contractAddress):
self.contract_addr = contractAddress
def gen_contract_abi(self, needCover=False):
"""
get contract abi according to contract_abi_path
"""
if needCover is False and os.path.exists(
self.contract_abi_path) is True:
return
# backup the abi and bin
else:
force_write = common.backup_file(self.contract_abi_path)
if force_write is False:
return
force_write = common.backup_file(self.contract_bin_path)
if force_write is False:
return
Compiler.compile_file(self.sol_path, self.contract_path)
def send_transaction_getReceipt(self,
fn_name,
fn_args,
gasPrice=30000000,
isdeploy=False,
from_account_signer=None):
"""
send transactions to CNS contract with the givn function name and args
"""
try:
contract_abi, args = self.format_abi_args(fn_name, fn_args,
isdeploy)
contract_bin = None
if isdeploy is True and os.path.exists(
self.contract_bin_path) is True:
with open(self.contract_bin_path, "rb") as f:
contract_bin = f.read()
f.close()
# print(contract_bin)
if self.contract_bin_path.endswith("wasm"):
contract_bin = encode_hex(contract_bin)
else:
contract_bin = bytes.decode(contract_bin, "utf-8")
if contract_bin is not None and len(contract_bin) > 0x40000:
raise BcosException(
("contract bin size overflow,"
" limit: 0x40000(256K), size: {})").format(
len(contract_bin), 16))
receipt = super().sendRawTransactionGetReceipt(
self.contract_addr,
contract_abi,
fn_name,
args,
contract_bin,
gasPrice,
from_account_signer=from_account_signer)
# check status
if "status" not in receipt.keys() or \
"output" not in receipt.keys():
raise BcosError(-1, None,
("send transaction failed"
"for empty status and output,"
"transaction receipt:{}").format(receipt))
status = receipt["status"]
status_code = int(status, 16)
error_message = transaction_status_code.TransactionStatusCode.get_error_message(
status_code)
if error_message is not None:
raise BcosException(
"call error, error message: {}".format(error_message))
if receipt["output"] is None:
raise TransactionException(receipt,
("send transaction failed,"
"status: {}, gasUsed: {}").format(
status, receipt["gasUsed"]))
if fn_name is not None and fn_args is not None and self.dataparser is not None:
output = self.dataparser.parse_receipt_output(
fn_name, receipt["output"])
else:
output = None
return (receipt, output)
except BcosError as e:
self.logger.error(
"send transaction failed, fn_name: {}, fn_args:{}, error_info:{}"
.format(fn_name, fn_args, e))
raise e
except CompileError as e:
self.logger.error(
("send transaction failed for compile soldity failed,"
"contract_path {}, error_info:{}").format(self.sol_path, e))
raise e
def format_abi_args(self, fn_name: str, fn_args, needCover=False):
"""
format args
"""
if not self.contract_bin_path.endswith(".wasm"):
self.gen_contract_abi(needCover)
data_parser = DatatypeParser(self.contract_abi_path)
contract_abi = data_parser.contract_abi
self.dataparser = data_parser
args = None
if fn_args is None:
return (contract_abi, fn_args)
if fn_name in data_parser.func_abi_map_by_name.keys() is None:
raise BcosException(
"invalid function: {}, the right function list:".format(
fn_name, ''.join(data_parser.func_abi_map_by_name.keys())))
if fn_name is not None:
fn_abi = data_parser.func_abi_map_by_name[fn_name]
inputabi = data_parser.get_function_inputs_abi(fn_name)
#inputabi = data_parser.get_function_abi(fn_name)
args = format_args_by_function_abi(fn_args, inputabi)
#print("args after format:",args)
# the constructor with params
elif fn_args is not None and contract_abi is not None:
abidata = get_constructor_abi(contract_abi)
if abidata is not None:
inputabi = abidata["inputs"]
args = format_args_by_function_abi(fn_args, inputabi)
return (contract_abi, args)
def call_and_decode(self, fn_name, fn_args=None):
"""
call and get the output
"""
contract_abi, args = self.format_abi_args(fn_name, fn_args, False)
result = super().call(self.contract_addr, contract_abi, fn_name, args)
return result
def fisco_add_data_demo1():
try:
client = BcosClient()
print(client.getinfo())
print(client.client_account)
abi_file = os.path.join(settings.SITE_ROOT, "contracts",
"UserTempInfo.abi")
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
# 发送交易，调用一个改写数据的接口
# print("\n>>sendRawTransaction:----------------------------------------------------")
to_address = '0x2b042831e72894e292507629bec3ae4886f6fe06' # use new deploy address
args = ['99999', '武汉', '38.9度', 20000]
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi,
"insert", args)
print("receipt:", receipt)
# # 调用一下call，获取数据
# args = ['99']
# print("\n>>Call:------------------------------------------------------------------------")
# res = client.call(to_address, contract_abi, "select", args)
# print("call get result:", res)
# 解析receipt里的log
print(
"\n>>parse receipt and transaction:--------------------------------------"
)
tx_hash = receipt['transactionHash']
print("transaction hash: ", tx_hash)
log_result = data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in log_result:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(
i, log['eventname'], log['eventdata']))
# 获取对应的交易数据，解析出调用方法名和参数
tx_response = client.getTransactionByHash(tx_hash)
input_result = data_parser.parse_transaction_input(
tx_response['input'])
print("transaction input parse:", tx_hash)
print(input_result)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
output_result = data_parser.parse_receipt_output(
input_result['name'], receipt['output'])
print("receipt output :", output_result)
# 调用一下call，获取数据
args = ['99999']
print(
"\n>>Call:------------------------------------------------------------------------"
)
res = client.call(to_address, contract_abi, "select", args)
print("call get result:", res)
print(
"\n>>Call:------------------------------------------------------------------------"
)
res = client.call(to_address, contract_abi, "selectLatest", args)
print("call get result:", res)
# 关闭连接
client.finish()
except:
pass
