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 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 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 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 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 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 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 main(argv):
global parser
global client
if len(argv) < 3:
usage()
exit(0)
contractname = argv[0]
address = argv[1]
event_name = argv[2]
indexed_value = argv[3:]
try:
print("usage input {},{},{},{}".format(contractname, address,
event_name, indexed_value))
if address == "last":
cn = ContractNote()
address = cn.get_last(contractname)
print("hex address :", address)
abifile = "contracts/" + contractname + ".abi"
parser = DatatypeParser(abifile)
client = BcosClient()
print(client.getinfo())
register_event_callback([address], event_name, indexed_value)
except Exception as e:
import traceback
traceback.print_exc()
client.finish()
import time
time.sleep(0.5)
sys.exit(-1)
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 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 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 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 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 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 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_contract2(contract_addr: str,
contract_name: str,
fn_name: str,
args: List = None,
signer: Signer_Impl = None):
client = BcosClient()
if signer is not None:
client.default_from_account_signer = signer
data_parser: DatatypeParser = DatatypeParser()
data_parser.load_abi_file(f"Contracts/{contract_name}.abi")
contract_abi = data_parser.contract_abi
ret = client.call(contract_addr, contract_abi, fn_name, args)
app.logger.info(
f"call contract {contract_name} at {contract_addr}. {fn_name} ({args}) -> {ret}"
)
client.finish()
return ret
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
def test():
# 初始化bcos客户端
try:
client = BcosClient()
while True:
model, epoch = client.call(to_address, contract_abi,
"QueryGlobalModel")
model = deserialize(model)
ser_W, ser_b = model['ser_W'], model['ser_b']
nonlocal test_epoch
if epoch > test_epoch:
test_acc = global_testing(ser_W, ser_b)
print("Epoch: {:03}, test_acc: {:.4f}"\
.format(test_epoch, test_acc))
test_epoch = epoch
wait()
except Exception as e:
client.finish()
traceback.print_exc()
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
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,
})
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()
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
class Loan_Contract:
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 get_bank_info_by_index(self, index: int):
bank_inf = self.client.call(self.to_address, self.contract_abi,
"banks", [index])
return {"bankName": bank_inf[0]}
def get_company_info_by_index(self, index: int):
cp_inf = self.client.call(self.to_address, self.contract_abi,
"companies", [index])
return {
"companyName": cp_inf[0],
"companyType": cp_inf[1],
"isTrusted": cp_inf[2],
"creditAsset": cp_inf[3],
"realMoney": cp_inf[4]
}
def get_receipt_info_by_index(self, index: int):
receipt_inf = self.client.call(self.to_address, self.contract_abi,
"receipts", [index])
return {
"Name_A": receipt_inf[0],
"Name_B": receipt_inf[1],
"bankParticipation": receipt_inf[2],
"isRealMoney": receipt_inf[3],
"amount": receipt_inf[4]
}
def get_bank_inf_by_name(self, bName: str):
bank_inf = self.client.call(self.to_address, self.contract_abi,
"getBankInfoByName", [bName])
return {"bankName": bank_inf[0]}
def get_company_inf_by_name(self, cpName: str):
cp_inf = self.client.call(self.to_address, self.contract_abi,
"getCompanyInfoByName", [cpName])
return {
"companyName": cp_inf[0],
"companyType": cp_inf[1],
"isTrusted": cp_inf[2],
"creditAsset": cp_inf[3],
"realMoney": cp_inf[4]
}
def get_AmountOfCreditAsset_bank_GiveTo_TrustedCompany(
self, bName: str, cpName: str):
result = self.client.call(
self.to_address, self.contract_abi,
"getAmountOfCreditAsset_bankGiveToTrustedCompany", [bName, cpName])
return {"amount": result[0]}
def get_company_num(self):
result = self.client.call(self.to_address, self.contract_abi,
"getCompanyNum")
return {"companyNum": result[0]}
def get_bank_num(self):
result = self.client.call(self.to_address, self.contract_abi,
"getBankNum")
return {"bankNum": result[0]}
def get_receipt_num(self):
result = self.client.call(self.to_address, self.contract_abi,
"getReceiptNum")
return {"receiptNum": result[0]}
def exit(self):
self.client.finish()
def run_one_node(node_id):
"""指定一个node id，并启动一个进程"""
batch_size = 100
learning_rate = 0.001
trained_epoch = -1
node_index = int(node_id.split('_')[-1])
# 初始化bcos客户端
try:
client = BcosClient()
# 为了更好模拟真实多个客户端场景，给不同的客户端分配不同的地址
client.set_from_account_signer(node_id)
print("{} initializing....".format(node_id))
except Exception as e:
client.finish()
traceback.print_exc()
def local_training():
print("{} begin training..".format(node_id))
try:
model, epoch = client.call(to_address, contract_abi,
"QueryGlobalModel")
model = deserialize(model)
tf.reset_default_graph()
n_samples = X_train[node_index].shape[0]
x = tf.placeholder(tf.float32, [None, n_features])
y = tf.placeholder(tf.float32, [None, n_class])
ser_W, ser_b = model['ser_W'], model['ser_b']
W = tf.Variable(ser_W)
b = tf.Variable(ser_b)
pred = tf.matmul(x, W) + b
# 定义损失函数
cost = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
# 梯度下降
# optimizer = tf.train.AdamOptimizer(learning_rate)
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
gradient = optimizer.compute_gradients(cost)
train_op = optimizer.apply_gradients(gradient)
# 初始化所有变量
init = tf.global_variables_initializer()
# 训练模型
with tf.Session(config=tf.ConfigProto(
device_count={'cpu': 0})) as sess:
sess.run(init)
avg_cost = 0
total_batch = int(n_samples / batch_size)
for i in range(total_batch):
_, c = sess.run(
[train_op, cost],
feed_dict={
x:
X_train[node_index][i * batch_size:(i + 1) *
batch_size],
y:
y_train[node_index][i * batch_size:(i + 1) *
batch_size, :]
})
avg_cost += c / total_batch
# 获取更新量
val_W, val_b = sess.run([W, b])
delta_W = (ser_W - val_W) / learning_rate
delta_b = (ser_b - val_b) / learning_rate
delta_model = {
'ser_W': delta_W.tolist(),
'ser_b': delta_b.tolist()
}
meta = {'n_samples': n_samples, 'avg_cost': avg_cost}
update_model = {'delta_model': delta_model, 'meta': meta}
update_model = serialize(update_model)
receipt = client.sendRawTransactionGetReceipt(
to_address, contract_abi, "UploadLocalUpdate",
[update_model, epoch])
nonlocal trained_epoch
trained_epoch = epoch
except Exception as e:
client.finish()
traceback.print_exc()
return
def local_testing(ser_W, ser_b):
tf.reset_default_graph()
x = tf.placeholder(tf.float32, [None, n_features])
y = tf.placeholder(tf.float32, [None, n_class])
W = tf.Variable(ser_W)
b = tf.Variable(ser_b)
pred = tf.matmul(x, W) + b
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 初始化所有变量
init = tf.global_variables_initializer()
# 训练模型
with tf.Session(config=tf.ConfigProto(
device_count={'cpu': 0})) as sess:
sess.run(init)
acc = accuracy.eval({
x: X_train[node_index],
y: y_train[node_index]
})
return acc
def local_scoring():
try:
res = client.call(to_address, contract_abi, "QueryAllUpdates")
updates = res[0]
# 如果获取不了任何更新信息，则认为还不能开始评分
if len(updates) == 0:
return
updates = deserialize(updates)
model, epoch = client.call(to_address, contract_abi,
"QueryGlobalModel")
model = deserialize(model)
print("{} begin scoring..".format(node_id))
scores = {}
for trainer_id, update in updates.items():
update = deserialize(update)
delta_model, meta = update['delta_model'], update['meta']
ser_W = [
a - learning_rate * b
for a, b in zip(np.array(model['ser_W']),
np.array(delta_model['ser_W']))
]
ser_b = [
a - learning_rate * b
for a, b in zip(np.array(model['ser_b']),
np.array(delta_model['ser_b']))
]
scores[trainer_id] = np.asscalar(
local_testing(
np.array(ser_W).astype(np.float32),
np.array(ser_b).astype(np.float32)))
receipt = client.sendRawTransactionGetReceipt(
to_address, contract_abi, "UploadScores",
[epoch, serialize(scores)])
nonlocal trained_epoch
trained_epoch = epoch
except Exception as e:
client.finish()
traceback.print_exc()
return
def wait():
time.sleep(random.uniform(QUERY_INTERVAL, QUERY_INTERVAL * 3))
return
def main_loop():
# 注册节点
try:
receipt = client.sendRawTransactionGetReceipt(
to_address, contract_abi, "RegisterNode", [])
print("{} registered successfully".format(node_id))
while True:
(role, global_epoch) = client.call(to_address, contract_abi,
"QueryState")
# print("{} role: {}, local e: {}, up_c: {}, sc_c: {}"\
# .format(node_id, role, trained_epoch,
# update_count, score_count))
if global_epoch > MAX_EPOCH:
break
if global_epoch <= trained_epoch:
# print("{} skip.".format(node_id))
wait()
continue
if role == ROLE_TRAINER:
local_training()
if role == ROLE_COMM:
local_scoring()
wait()
except Exception as e:
client.finish()
traceback.print_exc()
return
main_loop()
# 关闭客户端
client.finish()
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,
})
class ChainManager:
def __init__(self):
self.client = BcosClient()
self.dataparser = DatatypeParser()
self.dataparser.load_abi_file("./pythonsdk/contracts/Receipt2.abi")
self.RECEIPT_ABI = self.dataparser.contract_abi
self.dataparser.load_abi_file("./pythonsdk/contracts/Company.abi")
self.COMPANY_ABI = self.dataparser.contract_abi
self.COMPANY_ADDRESS = "0x2d1c577e41809453c50e7e5c3f57d06f3cdd90ce"
self.RECEIPT_ADDRESS = "0x98bc6df6b170d66fb5de93cf69b1f8746908f6d5"
# res = self.client.load_default_account()
self.BANK_ADDRESS = "0x3e4bf936a2ede27947a2c161abbdfc39df4619ab"
def __del__(self):
self.client.finish()
def hexstr2int(self, hexstr):
bit = (len(hexstr) - 2) * 4
num = int(hexstr, 16)
# hex str to int
if num > 2 ** (bit - 1) - 1:
num = 2 ** bit - num
num = 0 - num
return num
def login(self, username, password):
keystore_file = "{}/{}".format(client_config.account_keyfile_path,
username + ".keystore")
if os.path.exists(keystore_file) is False:
return -1
try:
with open(keystore_file, "r") as dump_f:
keytext = json.load(dump_f)
privkey = Account.decrypt(keytext, password)
self.client.client_account = Account.from_key(privkey)
except Exception as e:
return -1
return 0
def register(self, username, password):
ac = Account.create(password)
kf = Account.encrypt(ac.privateKey, password)
keyfile = "{}/{}.keystore".format(client_config.account_keyfile_path, username)
# file is exist, account is registed
if os.access(keyfile, os.F_OK):
return -1
try:
with open(keyfile, "w") as dump_f:
json.dump(kf, dump_f)
dump_f.close()
with open(keyfile, "r") as dump_f:
keytext = json.load(dump_f)
privkey = Account.decrypt(keytext, password)
client_account = Account.from_key(privkey)
ps = PermissionService("./pythonsdk/contracts/precompile")
ps.grant("t_rep1", client_account.address)
ps.grant("t_company", client_account.address)
del ps
# write file failed
except Exception as e:
return -2
return 0
def sign(self, username, password, info):
keystore_file = "{}/{}".format(client_config.account_keyfile_path,
username + ".keystore")
if os.path.exists(keystore_file) is False:
return -1
try:
with open(keystore_file, "r") as dump_f:
keytext = json.load(dump_f)
privkey = Account.decrypt(keytext, password)
msg = encode_defunct(text=info)
signed_msg = Account.sign_message(msg, privkey)
v = signed_msg['v']
r = signed_msg['r']
s = signed_msg['s']
return v, r, s
except Exception as e:
print(e)
return -1
def registerCom(self, username, name, addr, credit, comtype, vrs):
''' authority '''
info = username + name + addr + credit + comtype
msg = encode_defunct(text=info)
bank_addr = Account.recover_message(msg, vrs=vrs)
# 没有授权
if not bank_addr.lower() == self.BANK_ADDRESS:
return -4
''' register company '''
log = self.client.sendRawTransactionGetReceipt(self.COMPANY_ADDRESS, self.COMPANY_ABI, "register", [name,addr,credit,comtype])
output = log['output']
ret = self.hexstr2int(output)
return ret
def queryCom(self, name):
info = self.client.call(self.COMPANY_ADDRESS, self.COMPANY_ABI, "queryCompanyByName", [name])
if info[0] == "此公司不存在":
return -1
return info
def eraseCom(self, name):
log = self.client.sendRawTransactionGetReceipt(self.COMPANY_ADDRESS, self.COMPANY_ABI, "erase", [name])
ret = log['output']
ret = self.hexstr2int(ret)
return ret
def createReceipt(self, title, fromc, toc, amount, lastTime, comment, vrs=None):
bankConfirm = 0
if vrs:
info = title+fromc+toc+str(amount)+str(lastTime)
msg = encode_defunct(text=info)
bank_addr = Account.recover_message(msg, vrs=vrs)
if bank_addr.lower() == self.BANK_ADDRESS:
bankConfirm = 1
info = self.client.call(self.COMPANY_ADDRESS, self.COMPANY_ABI, "queryCompanyByName", [fromc])
owner = info[1]
# 账款必须由欠款方创建
if self.client.client_account.address.lower() != owner.lower():
return -5
log = self.client.sendRawTransactionGetReceipt(self.RECEIPT_ADDRESS, self.RECEIPT_ABI, "insert", [title, fromc, toc, amount, lastTime, bankConfirm, comment])
output = log['output']
ret = self.hexstr2int(output)
return ret
def queryReceipt(self, title):
info = self.client.call(self.RECEIPT_ADDRESS, self.RECEIPT_ABI, "queryReceiptByTitle", [title])
if info[0] == "此账款不存在":
return -1
return info
def queryReceiptOfCom(self, company, isfrom):
receipts = self.client.call(self.RECEIPT_ADDRESS, self.RECEIPT_ABI, "queryReceiptByCompany", [company, isfrom])
receipts = receipts[0]
res = []
for receipt in receipts:
tmp = str(receipt, encoding='utf8').strip('\x00')
res.append(tmp)
return res
def transferReceipt(self, title, fromc, middle, to, amount, newtitle):
ret = self.client.sendRawTransactionGetReceipt(self.RECEIPT_ADDRESS, self.RECEIPT_ABI, "transferReceipt", [title, fromc, middle, to, amount, newtitle])
ret = ret['output']
ret = self.hexstr2int(ret)
return ret
def deleteReceipt(self, title):
ret = self.client.sendRawTransactionGetReceipt(self.RECEIPT_ADDRESS, self.RECEIPT_ABI, "removeReceipt", [title])
ret = ret['output']
ret = self.hexstr2int(ret)
return ret
