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 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_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 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 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 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 start(self):
print('client '+str(self.id)+" start")
bcos_event = BcosEventCallback()
bcos_event.setclient(BcosClient())
cn = ContractNote()
address = cn.get_last('gmodel')
abifile = "contracts/gmodel.abi"
abiparser = DatatypeParser(abifile)
eventcallback01 = EventCallbackImpl01(self.model,self.Update,self.Gmodel,self.cur_round,self.fdfs)
eventcallback01.abiparser = abiparser
print("register events")
result = bcos_event.register_eventlog_filter(
eventcallback01, abiparser, [address], 'modelupdate', None)
print(
"after register ,event_name:{},result:{},all:{}".format(
'modelupdate',
result['result'], result))
#获取全局模型轮次
cur_round = self.Gmodel.get_round()[1][0]
while(cur_round<5):
print("the "+str(cur_round)+" th round")
print("client "+str(self.id)+" waiting gmodel_update...")
cur_round = self.Gmodel.get_round()[1][0]
time.sleep(10)
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 call(self, inputparams):
if len(inputparams) == 0:
sols = list_files(contracts_dir + "/*.sol")
for sol in sols:
print(sol + ".sol")
return
common.check_param_num(inputparams, 3)
paramsname = ["contractname", "address", "func"]
params = fill_params(inputparams, paramsname)
contractname = params["contractname"]
address = params["address"]
if address == "last" or address == "latest":
address = ContractNote.get_last(contractname)
if address is None:
sys.exit("can not get last address for [{}],break;".format(
contractname))
tx_client = transaction_common.TransactionCommon(
address, contracts_dir, contractname)
fn_name = params["func"]
fn_args = inputparams[3:]
print("INFO>> client info: {}".format(tx_client.getinfo()))
print("INFO >> call {} , address: {}, func: {}, args:{}".format(
contractname, address, fn_name, fn_args))
try:
result = tx_client.call_and_decode(fn_name, fn_args)
common.print_tx_result(result)
except Exception as e:
common.print_error_msg("call", e)
def 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_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 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 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 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 checkContractExit(self, contract_name):
#address = ContractNote.get_contract_addresses(contract_name)
address = ContractNote.get_last(contract_name)
if address is None:
return False, None
else:
# 暂时返回低一个就可以了
return True, address
def main(argv):
if len(argv) < 2:
usage()
exit(0)
contractname = argv[0]
address = argv[1]
event_name = None
indexed_value = None
if len(argv) > 2:
event_name = argv[2]
indexed_value = argv[3:]
try:
bcos_event = BcosEventCallback()
if client_config.client_protocol is not client_config.PROTOCOL_CHANNEL:
print(
"** using event callback, client prototol MUST be client_config.PROTOCOL_CHANNEL!!"
)
print("** please check the configure file")
sys.exit(-1)
bcos_event.setclient(BcosClient())
print(bcos_event.client.getinfo())
print("usage input {},{},{},{}".format(contractname, address,
event_name, indexed_value))
print(address)
if address == "last" or address == "latest":
cn = ContractNote()
address = cn.get_last(contractname)
print("hex address :", address)
abifile = "contracts/" + contractname + ".abi"
abiparser = DatatypeParser(abifile)
eventcallback01 = EventCallbackImpl01()
eventcallback02 = EventCallbackImpl02()
eventcallback01.abiparser = abiparser
eventcallback02.abiparser = abiparser
result = bcos_event.register_eventlog_filter(eventcallback01,
abiparser, [address],
event_name, indexed_value)
#result = bcos_event.register_eventlog_filter(eventcallback02,abiparser, [address], "on_number")
print("after register ,event_name:{},result:{},all:{}".format(
event_name, result['result'], result))
while True:
print("waiting event...")
time.sleep(10)
except Exception as e:
print("Exception!")
import traceback
traceback.print_exc()
finally:
print("event callback finished!")
if bcos_event.client is not None:
bcos_event.client.finish()
sys.exit(-1)
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 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 sendtx(self, inputparams):
if len(inputparams) == 0:
sols = list_files(contracts_dir + "/*.sol")
for sol in sols:
print(sol + ".sol")
return
common.check_param_num(inputparams, 3)
paramsname = ["contractname", "address", "func"]
params = fill_params(inputparams, paramsname)
contractname = params["contractname"]
address = params["address"]
if address == "last" or address == "latest":
address = ContractNote.get_last(contractname)
if address is None:
sys.exit("can not get last address for [{}],break;".format(
contractname))
tx_client = transaction_common.TransactionCommon(
address, contracts_dir, contractname)
fn_name = params["func"]
fn_args = inputparams[3:]
print("INFO>> client info: {}".format(tx_client.getinfo()))
print("INFO >> sendtx {} , address: {}, func: {}, args:{}".format(
contractname, address, fn_name, fn_args))
try:
from_account_signer = None
# from_account_signer = Signer_ECDSA.from_key_file(
# "bin/accounts/tester.keystore", "123456")
# print(keypair.address)
# 不指定from账户，如需指定，参考上面的加载，或者创建一个新的account，
# 参见国密（client.GM_Account）和非国密的account管理类LocalAccount
(receipt, output) = tx_client.send_transaction_getReceipt(
fn_name, fn_args, from_account_signer=from_account_signer)
data_parser = DatatypeParser(tx_client.contract_abi_path)
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
except Exception as e:
common.print_error_msg("sendtx", e)
def 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,
})
def on_push(self, packmsg: ChannelPack):
print("EventPushHandler", packmsg.detail())
strmsg = packmsg.data.decode("utf-8")
response = json.loads(strmsg)
print("response filterID:", response['filterID'])
#print("response:", json.dumps(response,indent=4))
loglist = parser.parse_event_logs(response["logs"])
print(json.dumps(loglist, indent=4))
# 从文件加载abi定义
abi_file = "contracts/HelloEvent.abi"
parser = data_parser = DatatypeParser(abi_file)
contract_abi = data_parser.contract_abi
contractnode = ContractNote()
address = contractnode.get_last("HelloEvent")
print("event contract address is ", address)
client = None
client = BcosClient()
info = client.getinfo()
print("client info:", info)
params_set = ["aaabbb"]
params_setnum_5 = ["setnum_ab", 5]
params_setnum_10 = ["setnum_ab", 10]
params_settwo_1 = ["settwo_aabb", 10, 'key1']
params_settwo_2 = ["settwo_aabb", 10, 'key2']
'''
CHANNEL_RPC_REQUEST = 0x12, // type for rpc request
CLIENT_HEARTBEAT = 0x13, // type for heart beat for sdk
# with open("contracts/v1_2.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"]
# 把部署结果存入文件备查
# ContractNote.save_address(contract_name,
# result["contractAddress"],
# int(result["blockNumber"], 16), memo)
# 发送交易，调用一个改写数据的接口
print("\n>>sendRawTransaction:----------------------------------------------------")
# 获取智能合约的地址
to_address = ContractNote.get_last(contract_name)
args = None
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi, "Task1", 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']))
def main(argv):
try:
usagemsg = usage(client_config)
cmd, inputparams = parse_commands(argv)
precompile = Precompile(cmd, inputparams,
contracts_dir + "/precompile")
# check cmd
valid = check_cmd(cmd, validcmds)
if valid is False:
printusage(usagemsg, precompile)
return
# try to callback cns precompile
precompile.call_cns()
# try to callback consensus precompile
precompile.call_consensus()
# try to callback config precompile
precompile.call_sysconfig_precompile()
# try to callback permission precompile
precompile.call_permission_precompile()
# try to callback crud precompile
precompile.call_crud_precompile()
# try to callback rpc functions
rpcConsole = RPCConsole(cmd, inputparams, contracts_dir)
rpcConsole.executeRpcCommand()
if cmd == 'showaccount':
# must be 2 params
common.check_param_num(inputparams, 2, True)
name = inputparams[0]
password = inputparams[1]
keyfile = "{}/{}.keystore".format(
client_config.account_keyfile_path, name)
# the account doesn't exists
if os.path.exists(keyfile) is False:
raise BcosException("account {} doesn't exists".format(name))
print("show account : {}, keyfile:{} ,password {} ".format(
name, keyfile, password))
try:
with open(keyfile, "r") as dump_f:
keytext = json.load(dump_f)
stat = StatTool.begin()
privkey = Account.decrypt(keytext, password)
stat.done()
print("decrypt use time : %.3f s" % (stat.time_used))
ac2 = Account.from_key(privkey)
print("address:\t", ac2.address)
print("privkey:\t", encode_hex(ac2.key))
print("pubkey :\t", ac2.publickey)
print("\naccount store in file: [{}]".format(keyfile))
print("\n**** please remember your password !!! *****")
except Exception as e:
raise BcosException(("load account info for [{}] failed,"
" error info: {}!").format(name, e))
if cmd == 'newaccount':
common.check_param_num(inputparams, 2, True)
name = inputparams[0]
max_account_len = 240
if len(name) > max_account_len:
common.print_info(
"WARNING", "account name should no more than {}".format(
max_account_len))
sys.exit(1)
password = inputparams[1]
print("starting : {} {} ".format(name, password))
ac = Account.create(password)
print("new address :\t", ac.address)
print("new privkey :\t", encode_hex(ac.key))
print("new pubkey :\t", ac.publickey)
stat = StatTool.begin()
kf = Account.encrypt(ac.privateKey, password)
stat.done()
print("encrypt use time : %.3f s" % (stat.time_used))
keyfile = "{}/{}.keystore".format(
client_config.account_keyfile_path, name)
print("save to file : [{}]".format(keyfile))
forcewrite = False
if not os.access(keyfile, os.F_OK):
forcewrite = True
else:
# old file exist,move to backup file first
if (len(inputparams) == 3 and inputparams[2] == "save"):
forcewrite = True
else:
forcewrite = common.backup_file(keyfile)
if forcewrite:
with open(keyfile, "w") as dump_f:
json.dump(kf, dump_f)
dump_f.close()
print(">>-------------------------------------------------------")
print(
"INFO >> read [{}] again after new account,address & keys in file:"
.format(keyfile))
with open(keyfile, "r") as dump_f:
keytext = json.load(dump_f)
stat = StatTool.begin()
privkey = Account.decrypt(keytext, password)
stat.done()
print("decrypt use time : %.3f s" % (stat.time_used))
ac2 = Account.from_key(privkey)
print("address:\t", ac2.address)
print("privkey:\t", encode_hex(ac2.key))
print("pubkey :\t", ac2.publickey)
print("\naccount store in file: [{}]".format(keyfile))
print("\n**** please remember your password !!! *****")
dump_f.close()
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "deploy":
'''deploy abi bin file'''
# must be at least 2 params
common.check_param_num(inputparams, 1)
contractname = inputparams[0].strip()
gasPrice = 30000000
# need save address whether or not
needSaveAddress = False
args_len = len(inputparams)
if inputparams[-1] == "save":
needSaveAddress = True
args_len = len(inputparams) - 1
# get the args
fn_args = inputparams[1:args_len]
trans_client = transaction_common.TransactionCommon(
"", contracts_dir, contractname)
result = trans_client.send_transaction_getReceipt(
None, fn_args, gasPrice, True)[0]
print("deploy result for [{}] is:\n {}".format(
contractname, json.dumps(result, indent=4)))
name = contractname
address = result['contractAddress']
blocknum = int(result["blockNumber"], 16)
ContractNote.save_contract_address(name, address)
print("on block : {},address: {} ".format(blocknum, address))
if needSaveAddress is True:
ContractNote.save_address(name, address, blocknum)
print("address save to file: ",
client_config.contract_info_file)
else:
print('''\nNOTE : if want to save new address as last
address for (call/sendtx)\nadd 'save' to cmdline and run again'''
)
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "call" or cmd == "sendtx":
common.check_param_num(inputparams, 3)
paramsname = ["contractname", "address", "func"]
params = fill_params(inputparams, paramsname)
contractname = params["contractname"]
address = params["address"]
if address == "last":
address = ContractNote.get_last(contractname)
if address is None:
sys.exit("can not get last address for [{}],break;".format(
contractname))
tx_client = transaction_common.TransactionCommon(
address, contracts_dir, contractname)
fn_name = params["func"]
fn_args = inputparams[3:]
print("INFO >> {} {} , address: {}, func: {}, args:{}".format(
cmd, contractname, address, fn_name, fn_args))
if cmd == "call":
result = tx_client.call_and_decode(fn_name, fn_args)
print("INFO >> {} result: {}".format(cmd, result))
if cmd == "sendtx":
receipt = tx_client.send_transaction_getReceipt(
fn_name, fn_args)[0]
data_parser = DatatypeParser(default_abi_file(contractname))
# 解析receipt里的log 和 相关的tx ,output
print_receipt_logs_and_txoutput(tx_client, receipt, "",
data_parser)
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "list":
RPCConsole.print_rpc_usage()
print(
"--------------------------------------------------------------------"
)
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "txinput":
contractname = inputparams[0]
inputdata = inputparams[1]
abi_path = default_abi_file(contractname)
if os.path.isfile(abi_path) is False:
raise BcosException(
"execute {} failed for {} doesn't exist".format(
cmd, abi_path))
try:
dataParser = DatatypeParser(abi_path)
# print(dataParser.func_abi_map_by_selector)
result = dataParser.parse_transaction_input(inputdata)
print("\nabifile : ", default_abi_file(contractname))
print("parse result: {}".format(result))
except Exception as e:
raise BcosException("execute {} failed for reason: {}".format(
cmd, e))
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "checkaddr":
address = inputparams[0]
result = to_checksum_address(address)
print("{} -->\n{}".format(address, result))
# --------------------------------------------------------------------------------------------
# console cmd entity
# --------------------------------------------------------------------------------------------
if cmd == "usage":
printusage(usagemsg, precompile)
except TransactionException as e:
common.print_error_msg(cmd, e)
except PrecompileError as e:
common.print_error_msg(cmd, e)
except BcosError as e:
common.print_error_msg(cmd, e)
except CompileError as e:
common.print_error_msg(cmd, e)
except ArgumentsError as e:
common.print_error_msg(cmd, e)
except BcosException as e:
common.print_error_msg(cmd, e)
call a constant funciton of contract and get the returns
eg: call SimpleInfo 0xF2c07c98a6829aE61F3cB40c69f6b2f035dD63FC getbalance1 11
if address is "last" ,then load last address from :{}
eg: call SimpleInfo last getall
'''.format(client_config.contract_info_file))
if cmd == "call":
paramsname = ["contractname", "address", "func"]
params = fill_params(inputparams, paramsname)
args = inputparams[len(paramsname):]
contractname = params["contractname"]
data_parser = DatatypeParser(default_abi_file(contractname))
contract_abi = data_parser.contract_abi
address = params["address"]
if address == "last":
address = ContractNote.get_last(contractname)
if address == None:
sys.exit("can not get last address for [{}],break;".format(
contractname))
funcname = params["func"]
inputabi = data_parser.func_abi_map_by_name[funcname]["inputs"]
args = format_args_by_abi(args, inputabi)
print("call {} , address: {}, func: {}, args:{}".format(
contractname, address, funcname, args))
result = client.call(address, contract_abi, funcname, args)
print("call result: ", result)
#--------------------------------------------------------------------------------------------
# console cmd entity
#--------------------------------------------------------------------------------------------
validcmds.append("sendtx")
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,
})
