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 get_commodity_info(request):
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()
res = client.call(contract_address, contract_abi, "get_commodity_info",
[commodity_id])
client.finish()
commodity_info = {
"owner": res[0],
"name": res[1],
"image": res[2],
"desc": res[3],
"price": res[4],
"state": res[5],
"id": res[6],
"type": res[7],
}
ret_code = 0 if commodity_info["state"] != -999 else -1
response = {
"code": ret_code,
}
if ret_code == 0:
response["commodity"] = commodity_info
return JsonResponse(response)
def user_transaction_sell_list(request):
user_id = request.POST.get('user_id')
max_item_count = request.POST.get("page_max_items")
page_id = request.POST.get("page_id")
if max_item_count is None or page_id is None:
max_item_count = page_id = None
else:
max_item_count = int(max_item_count)
page_id = int(page_id)
if max_item_count < 1 or page_id < 0:
max_item_count = page_id = None
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()
sell_res = client.call(contract_address, contract_abi,
"get_transaction_sell_list", [user_id])
transaction_sell_list = []
transaction_sell_count = 0
for transaction_id in sell_res[0]:
res = client.call(contract_address, contract_abi,
"get_transaction_info", [transaction_id])
transaction_info = {
"user_id_sell": res[1],
"user_id_buy": res[2],
"desc": res[3],
"commodity_id": res[4],
"price": res[5],
"state": res[6],
"id": transaction_id,
}
ret_code = 0 if transaction_info["state"] != -999 else -1
if ret_code == 0:
transaction_sell_list.append(transaction_info)
transaction_sell_count += 1
client.finish()
if max_item_count is None:
page_num = 1 if len(transaction_sell_list) > 0 else 0
else:
page_num = (len(transaction_sell_list) + max_item_count -
1) // max_item_count
transaction_sell_list = transaction_sell_list[page_id *
max_item_count:(page_id +
1) *
max_item_count]
return JsonResponse({
"transaction_list": transaction_sell_list,
"page_num": page_num,
})
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 get_user_info(request):
user_id = request.POST.get('user_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()
res = client.call(contract_address, contract_abi, "get_user_info",
[user_id])
client.finish()
user_info = {
"id": res[0],
"info": res[1],
"balance": res[2],
"state": res[3],
}
ret_code = 0 if user_info["state"] != -999 else -1
response = {
"code": ret_code,
}
if ret_code == 0:
response["user"] = user_info
return JsonResponse(response)
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 get_arbitration_reason(request):
transaction_id = int(request.POST.get('transaction_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()
res = client.call(contract_address, contract_abi, "get_arbitration_reason",
[transaction_id])
client.finish()
arbitration_reason = res[0]
if arbitration_reason == "NULL":
ret_code = -1 # no such transaction
arbitration_reason = ""
else:
ret_code = 0 # success
return JsonResponse({
"code": ret_code,
"arbitration_reason": arbitration_reason,
})
def auth_user(request):
user_id = request.POST.get('user_id')
user_password = request.POST.get('user_password')
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()
res = client.call(contract_address, contract_abi, "valid_psd",
[user_id, user_password])
client.finish()
code_map = {
1: 0, # success
-1: -1, # user don't exists
-2: -2, # wrong password
}
ret_code = code_map[res[0]]
return JsonResponse({"code": ret_code})
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 get_transaction_info(request):
transaction_id = int(request.POST.get('transaction_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()
res = client.call(contract_address, contract_abi, "get_transaction_info",
[transaction_id])
client.finish()
transaction_info = {
"user_id_sell": res[1],
"user_id_buy": res[2],
"desc": res[3],
"commodity_id": res[4],
"price": res[5],
"state": res[6],
"id": transaction_id,
}
ret_code = 0 if transaction_info["state"] != -999 else -1
response = {
"code": ret_code,
}
if ret_code == 0:
response["transaction"] = transaction_info
return JsonResponse(response)
def __init__(self, address: str):
abi_file = "contracts/Con.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
self.contract_abi = data_parser.contract_abi
self.client = BcosClient()
self.to_address = address
def get_data_parser():
if os.path.isfile(client_config.solc_path) or os.path.isfile(
client_config.solcjs_path):
Compiler.compile_file("contracts/SoftwareTransaction.sol")
abi_file = "contracts/SoftwareTransaction.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
return data_parser, abi_file
def user_commodity_list(request):
user_id = request.POST.get('user_id')
max_item_count = request.POST.get("page_max_items")
page_id = request.POST.get("page_id")
if max_item_count is None or page_id is None:
max_item_count = page_id = None
else:
max_item_count = int(max_item_count)
page_id = int(page_id)
if max_item_count < 1 or page_id < 0:
max_item_count = page_id = None
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()
res = client.call(contract_address, contract_abi, "get_commodity_list",
[user_id])
commodity_id_list, commodity_count = res
commodity_list = []
for commodity_id in commodity_id_list:
commodity_info = client.call(contract_address, contract_abi,
"get_commodity_info", [commodity_id])
commodity_info = {
"owner": commodity_info[0],
"name": commodity_info[1],
"image": commodity_info[2],
"desc": commodity_info[3],
"price": commodity_info[4],
"state": commodity_info[5],
"id": commodity_info[6],
"type": commodity_info[7],
}
if commodity_info["state"] != -999:
commodity_list.append(commodity_info)
client.finish()
if max_item_count is None:
page_num = 1 if len(commodity_list) > 0 else 0
else:
page_num = (len(commodity_list) + max_item_count - 1) // max_item_count
commodity_list = commodity_list[page_id *
max_item_count:(page_id + 1) *
max_item_count]
return JsonResponse({
"commodity_list": commodity_list,
"page_num": page_num,
})
def get_data_parser():
if os.path.isfile(client_config.solc_path) or os.path.isfile(
client_config.solcjs_path):
Compiler.compile_file("contracts/HelloWorld.sol")
Compiler.compile_file("contracts/SimpleInfo.sol")
abi_file = "contracts/SimpleInfo.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
return data_parser, abi_file
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 deploy():
client = BcosClient()
#从文件加载abi定义
abi_file ="contracts/SoftwareTransaction.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
#部署合约
with open("contracts/SoftwareTransaction.bin", 'r') as load_f:
contract_bin = load_f.read()
load_f.close()
result = client.deploy(contract_bin)
print("contract address:", result["contractAddress"])
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 __init__(self, address: str):
# 从文件加载abi定义
# Now file has been complied. Use .abi directly.
if os.path.isfile(client_config.solc_path) or os.path.isfile(
client_config.solcjs_path):
Compiler.compile_file("contracts/Loan.sol")
abi_file = "contracts/Loan.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
self.contract_abi = data_parser.contract_abi
self.client = BcosClient()
self.to_address = address
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 Task2(job, stub):
print(job)
data_parser = DatatypeParser()
data_parser.load_abi_file(public.abi_file)
contract_abi = data_parser.contract_abi
client = BcosClient()
address = json.loads(job.variables)["contract"]
receipt = client.sendRawTransactionGetReceipt(address, contract_abi,
"Task2")
stub.SetVariables(
gateway_pb2.SetVariablesRequest(
elementInstanceKey=job.workflowInstanceKey,
variables=json.dumps({"tx": receipt["transactionHash"]})))
if bool(receipt["output"]):
stub.CompleteJob(gateway_pb2.CompleteJobRequest(jobKey=job.key))
else:
stub.FailJob(gateway_pb2.FailJobRequest(jobKey=job.Key))
def deploySmartContract():
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
try:
client = BcosClient()
# 部署合约
with open("contracts/v1_2.bin", 'r') as load_f:
contract_bin = load_f.read()
load_f.close()
result = client.deploy(contract_bin)
# init
client.sendRawTransactionGetReceipt(result["contractAddress"],
contract_abi, "Init")
return result["contractAddress"]
except BcosException as e:
print("execute demo_transaction failed for: {}".format(e))
except BcosError as e:
print("execute demo_transaction failed for: {}".format(e))
def deploy_contract(contract,
is_compile: bool = False,
signer: Signer_Impl = None,
fn_args=None):
"""
Args:
contract: the contract's name, e.g.: "EngineerList"
is_compile (bool): compile or not
Returns:
the contract address
"""
if is_compile and (os.path.isfile(client_config.solc_path)
or os.path.isfile(client_config.solcjs_path)):
Compiler.compile_file(f"Contracts/{contract}.sol",
output_path="Contracts")
data_parser = DatatypeParser()
data_parser.load_abi_file(f"Contracts/{contract}.abi")
client = BcosClient()
try:
with open(f"Contracts/{contract}.bin", 'r') as load_f:
contract_bin = load_f.read()
load_f.close()
result = client.deploy(contract_bin,
contract_abi=data_parser.contract_abi,
fn_args=fn_args,
from_account_signer=signer)
addr = result["contractAddress"]
except BcosError:
traceback.print_exc()
return None
except BcosException:
traceback.print_exc()
return None
except Exception:
traceback.print_exc()
return None
finally:
client.finish()
app.logger.info(f"deploy contract {contract} at {addr}")
return addr
BcosClient,
BcosError
)
import os
from eth_utils import to_checksum_address
from client.datatype_parser import DatatypeParser
client = BcosClient()
#info = client.init()
print(client.getinfo())
#从文件加载abi定义
abi_file ="contracts/SimpleInfo.abi"
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
#部署合约
print("\n>>Deploy:---------------------------------------------------------------------")
with open("contracts/SimpleInfo.bin", 'r') as load_f:
contract_bin = load_f.read()
load_f.close()
result = client.deploy(contract_bin)
print("deploy",result)
print("new address : ",result["contractAddress"])
contract_name = os.path.splitext(os.path.basename(abi_file))[0]
memo = "tx:"+result["transactionHash"]
#把部署结果存入文件备查
from client.contractnote import ContractNote
ContractNote.save_address(contract_name, result["contractAddress"], int(result["blockNumber"], 16), memo)
def search_commodity(request):
keywords = request.POST.get("keywords")
keywords = [keyword for keyword in keywords.split(' ') if len(keyword) > 0]
commodity_type = request.POST.get("commodity_type")
reverse = bool(int(request.POST.get("reverse", '0')))
max_item_count = request.POST.get("page_max_items")
page_id = request.POST.get("page_id")
if max_item_count is None or page_id is None:
max_item_count = page_id = None
else:
max_item_count = int(max_item_count)
page_id = int(page_id)
if max_item_count < 1 or page_id < 0:
max_item_count = page_id = None
if commodity_type is None:
query_method = "get_onsale_list"
query_args = []
else:
commodity_type = int(commodity_type)
query_method = "get_onsale_type_list"
query_args = [commodity_type]
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()
res = client.call(contract_address, contract_abi, query_method, query_args)
commodity_id_list, commodity_count = res
commodity_list = []
for commodity_id in commodity_id_list:
commodity_info = client.call(contract_address, contract_abi,
"get_commodity_info", [commodity_id])
commodity_info = {
"owner": commodity_info[0],
"name": commodity_info[1],
"image": commodity_info[2],
"desc": commodity_info[3],
"price": commodity_info[4],
"state": commodity_info[5],
"id": commodity_info[6],
"type": commodity_info[7],
}
if commodity_info["state"] != -999:
commodity_list.append(commodity_info)
client.finish()
commodity_match_score_list = []
for commodity_info in commodity_list:
score = 0
for keyword in keywords:
score += int(keyword.lower() in commodity_info["name"].lower())
score += int(keyword.lower() in commodity_info["desc"].lower())
commodity_match_score_list.append(score)
commodity_list = [
item[0] for item in sorted(iter(
i for i in zip(commodity_list, commodity_match_score_list)
if i[1] > 0),
key=lambda x: x[1],
reverse=True)
]
if reverse:
commodity_list.reverse()
if max_item_count is None:
page_num = 1 if len(commodity_list) > 0 else 0
else:
page_num = (len(commodity_list) + max_item_count - 1) // max_item_count
commodity_list = commodity_list[page_id *
max_item_count:(page_id + 1) *
max_item_count]
return JsonResponse({
"commodity_list": commodity_list,
"page_num": page_num,
})
@author: kentzhang
@date: 2019-06
'''
from client.bcosclient import (BcosClient, BcosError)
import os
from eth_utils import to_checksum_address
from client.datatype_parser import DatatypeParser
client = BcosClient()
info = client.init()
print(info)
#从文件加载abi定义
contractFile = "sample\SimpleInfo.abi"
abi_parser = DatatypeParser()
abi_parser.load_abi_file(contractFile)
contract_abi = abi_parser.contract_abi
#部署合约
print(
"\n>>Deploy:---------------------------------------------------------------------"
)
with open("sample\SimpleInfo.bin", 'r') as load_f:
contract_bin = load_f.read()
load_f.close()
result = client.deploy(contract_bin)
print("deploy", result)
print("new address : ", result["contractAddress"])
contract_name = contractname = os.path.splitext(
os.path.basename(contractFile))[0]
memo = "tx:" + result["transactionHash"]
'''
@author: kentzhang
@date: 2019-06
'''
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()
'''
import rlp
from client.bcostransactions import serializable_unsigned_transaction_from_dict
from client.datatype_parser import DatatypeParser
import json
from eth_abi import decode_single
from eth_account.account import Account
from eth_utils import decode_hex, encode_hex, to_checksum_address
from utils.abi import get_fn_abi_types_single
from utils.contracts import encode_transaction_data, get_function_info
if (True):
parser = DatatypeParser()
parser.load_abi_file("contracts/HelloWorld.abi")
parser.parse_abi()
fn_name = "set"
contract_abi = parser.contract_abi
args = ["1234"]
set_tx_data = encode_transaction_data(fn_name, contract_abi, None, args)
print("set_tx_data:", set_tx_data)
contractAddress = to_checksum_address(
"0x882be29b2d5ac85d6c476fa3fd5f0cae4b4585cc")
txmap = dict()
txmap["randomid"] = 10003 # 测试用 todo:改为随机数
txmap["gasPrice"] = 30000000
txmap["gasLimit"] = 30000000
txmap["blockLimit"] = 501 # 测试用，todo：从链上查一下
txmap["to"] = contractAddress
txmap["value"] = 0
set_crypto_type("Gm")
data = b'\x87-\x8dP\xab\x0f"N\xf9\x111Dp17\xd0Q\t\xeeDNa\x04Da\xee\x8e\xe9]\x96\xa1<'
print("hexdata", data.hex())
data = b'7551ab5643a1690f7b128d0d1790ca6b02a2b5a34653d4311673588d0fa42789'
keyfile = "bin/account1.json"
account = GM_Account()
account.load_from_file(keyfile)
print(account.getdetail())
signer = SignTx()
signer.KeyPair = account
# 从abi文件获得abi的文本定义
parser = DatatypeParser()
abi_file = "contracts/HelloWorld.abi"
parser.load_abi_file(abi_file)
inputparam = ['test123789111']
# print(parser.contract_abi)
functiondata = encode_transaction_data("set", parser.contract_abi, None,
inputparam)
result = parser.parse_transaction_input(functiondata)
print("parse tx input :", result)
print("functiondata ", functiondata)
sighash = keccak(b"set(string)")
print(sighash)
# 填写一个bcos transaction 的 mapping
contractAddress = to_checksum_address(
"0x565081461f6f0e1c5bf738013f11f1ca8a5b1537")
txmap = dict()
txmap["randomid"] = random.randint(0, 1000000000) # 测试用 todo:改为随机数
def market_commodity_list_order_by_price(request):
commodity_type = request.POST.get("commodity_type")
reverse = bool(int(request.POST.get("reverse", '0')))
max_item_count = request.POST.get("page_max_items")
page_id = request.POST.get("page_id")
if max_item_count is None or page_id is None:
max_item_count = page_id = None
else:
max_item_count = int(max_item_count)
page_id = int(page_id)
if max_item_count < 1 or page_id < 0:
max_item_count = page_id = None
if commodity_type is None:
query_method = "get_onsale_list"
query_args = []
else:
commodity_type = int(commodity_type)
query_method = "get_onsale_type_list"
query_args = [commodity_type]
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()
res = client.call(contract_address, contract_abi, query_method, query_args)
commodity_id_list, commodity_count = res
commodity_list = []
for commodity_id in commodity_id_list:
commodity_info = client.call(contract_address, contract_abi,
"get_commodity_info", [commodity_id])
commodity_info = {
"owner": commodity_info[0],
"name": commodity_info[1],
"image": commodity_info[2],
"desc": commodity_info[3],
"price": commodity_info[4],
"state": commodity_info[5],
"id": commodity_info[6],
"type": commodity_info[7],
}
if commodity_info["state"] != -999:
commodity_list.append(commodity_info)
client.finish()
commodity_list.sort(key=lambda commodity_info: commodity_info["price"],
reverse=reverse)
if max_item_count is None:
page_num = 1 if len(commodity_list) > 0 else 0
else:
page_num = (len(commodity_list) + max_item_count - 1) // max_item_count
commodity_list = commodity_list[page_id *
max_item_count:(page_id + 1) *
max_item_count]
return JsonResponse({
"commodity_list": commodity_list,
"page_num": page_num,
})
