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 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 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 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 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 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 call_contract(contract_addr: str,
contract_name: str,
fn_name: str,
args: List = None,
signer: Signer_Impl = None,
gasPrice=30000000):
client = BcosClient()
data_parser: DatatypeParser = DatatypeParser()
data_parser.load_abi_file(f"Contracts/{contract_name}.abi")
contract_abi = data_parser.contract_abi
receipt = client.sendRawTransactionGetReceipt(to_address=contract_addr,
contract_abi=contract_abi,
fn_name=fn_name,
args=args,
from_account_signer=signer,
gasPrice=gasPrice)
if receipt["status"] != "0x0":
msg = receipt.get("statusMsg", "")
app.logger.warn(
f"call contract {contract_name} at {contract_addr}. {fn_name} ({args}) error:{msg}"
)
app.logger.warn(f"receipt: {receipt}")
print(msg)
raise Exception(f"contract error: {msg}")
txhash = receipt['transactionHash']
txresponse = client.getTransactionByHash(txhash)
inputresult = data_parser.parse_transaction_input(txresponse['input'])
outputresult = data_parser.parse_receipt_output(inputresult['name'],
receipt['output'])
client.finish()
app.logger.info(
f"call contract {contract_name} at {contract_addr}. {fn_name} ({args}) -> {outputresult}"
)
return outputresult
receipt = client.sendRawTransactionGetReceipt(to_address,contract_abi,"set",args)
print("receipt:",receipt)
#解析receipt里的log
print("\n>>parse receipt and transaction:----------------------------------------------------------")
txhash = receipt['transactionHash']
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)
args = [
'simplename', 2024,
to_checksum_address('0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1c')
]
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi, "set",
args)
print(receipt)
#解析receipt里的log
logresult = abi_parser.parse_event_logs(receipt["logs"])
for log in logresult:
if 'eventname' in log:
print("log name: {} , data: {}".format(log['eventname'],
log['eventdata']))
#获取对应的交易数据，解析出调用方法名和参数
txhash = receipt['transactionHash']
txresponse = client.getTransactionByHash(txhash)
inputresult = abi_parser.parse_transaction_input(txresponse['input'])
print("transaction input parse:", txhash)
print(inputresult)
#解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = abi_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)
except BcosError as e:
print("bcos client error,", e.info())
print("\n>>---------------------------------------------------------------------")
print("getPeers", client.getPeers())
print("\n>>---------------------------------------------------------------------")
print("getBlockByNumber", client.getBlockByNumber(1))
print("\n>>---------------------------------------------------------------------")
blockhash = client.getBlockHashByNumber(1)
print("getBlockHashByNumber", blockhash)
print("\n>>---------------------------------------------------------------------")
block = client.getBlockByHash(blockhash)
print("getBlockByHash", block)
if isinstance(block, dict) and "transactions" in block.keys():
txhash = block['transactions'][0]["hash"]
print("\n>>---------------------------------------------------------------------")
print("getTransactionByHash", client.getTransactionByHash(txhash))
print("\n>>---------------------------------------------------------------------")
print("getTransactionByBlockHashAndIndex",
client.getTransactionByBlockHashAndIndex(blockhash, 0))
print("\n>>---------------------------------------------------------------------")
print("getTransactionByBlockNumberAndIndex",
client.getTransactionByBlockNumberAndIndex(1, 0))
print("\n>>---------------------------------------------------------------------")
print("getTransactionReceipt", client.getTransactionReceipt(txhash))
print("\n>>---------------------------------------------------------------------")
print("getPendingTransactions", client.getPendingTransactions())
print("\n>>---------------------------------------------------------------------")
print("getPendingTxSize", client.getPendingTxSize())
print("\n>>---------------------------------------------------------------------")
print("getCode", client.getCode("0x83592a3cf1af302612756b8687c8dc7935c0ad1d"))
print("\n>>---------------------------------------------------------------------")
"\n>>---------------------------------------------------------------------"
)
blockhash = client.getBlockHashByNumber(1)
print("getBlockHashByNumber", blockhash)
print(
"\n>>---------------------------------------------------------------------"
)
block = client.getBlockByHash(blockhash)
print("getBlockByHash", block)
if isinstance(block, dict) and "transactions" in block.keys():
txhash = block["transactions"][0]["hash"]
print(
"\n>>---------------------------------------------------------------------"
)
print("getTransactionByHash",
json.dumps(client.getTransactionByHash(txhash)))
print(
"\n>>---------------------------------------------------------------------"
)
print(
"getTransactionByBlockHashAndIndex",
json.dumps(client.getTransactionByBlockHashAndIndex(blockhash, 0)),
)
print(
"\n>>---------------------------------------------------------------------"
)
print(
"getTransactionByBlockNumberAndIndex",
client.getTransactionByBlockNumberAndIndex(1, 0),
)
print(
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
