def EventEmitter(stub, initHeight):
data_parser = DatatypeParser()
try:
client = BcosClient()
lastHeight = initHeight
while 1:
currHeight = client.getBlockNumber()
if currHeight > lastHeight:
for height in range(lastHeight + 1, currHeight + 1):
result = client.getBlockByNumber(
height, _includeTransactions=False)
for hash in result["transactions"]:
receipt = client.getTransactionReceipt(hash)
logs = data_parser.parse_event_logs(receipt["logs"])
for log in logs:
print(log)
if log["eventname"] == "Task1Finished":
stub.PublishMessage(
gateway_pb2.PublishMessageRequest(
name="task1",
correlationKey="task1",
variables=json.dumps(
{"contract": receipt["to"]})))
elif log["eventname"] == "Task2Finished":
stub.PublishMessage(
gateway_pb2.PublishMessageRequest(
name="task2",
correlationKey=receipt["to"]))
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 print_output_and_input(logs, output, txinput, contract_name, contract_path):
"""
parse_output_from_abi
"""
abi_path = os.path.join(contract_path, contract_name + ".abi")
if os.path.isfile(abi_path) is False:
raise BcosException("parse outpt failed for {} doesn't exist"
.format(abi_path))
try:
dataParser = DatatypeParser(abi_path)
# parse txinput
input_result = dataParser.parse_transaction_input(txinput)
if input_result is not None:
print_info("txinput result", input_result)
# get function name
fn_name = input_result["name"]
output_result = dataParser.parse_receipt_output(fn_name, output)
if output_result is None:
print_info("INFO", "empty return, output: {}".format(output))
return
print_info("output result", output_result)
log_result = dataParser.parse_event_logs(logs)
print_receipt_logs(log_result)
# print_info("log result", log_result)
except Exception as e:
raise BcosException("parse output failed for reason: {}".format(e))
def 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 print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
print("\nINFO >> receipt logs : ")
# 解析receipt里的log
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
# modified by Bodhi Wang
# 2019.11.26
"""
i = 0
for log in logresult:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(i, log['eventname'], log['eventdata']))
"""
for i, log in enumerate(
[result for result in logresult if 'eventname' in result]):
print("{}): log name: {} , data: {}".format(i, log['eventname'],
log['eventdata']))
txhash = receipt["transactionHash"]
txresponse = client.getTransactionByHash(txhash)
inputdetail = print_parse_transaction(txresponse, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = parser.parse_receipt_output(inputdetail['name'],
receipt['output'])
print("receipt output :", outputresult)
class Client:
def __init__(self,contract_name, contract_address):
abi_file = os.path.join(settings.SITE_ROOT, "contracts", contract_name + ".abi")
self.data_parser = DatatypeParser()
self.data_parser.load_abi_file(abi_file)
self.contract_abi = self.data_parser.contract_abi
self.contract_address = contract_address
def fisco_add_data(self, func_name, args):
client = BcosClient()
try:
print('start')
# 发送交易
receipt = client.sendRawTransactionGetReceipt(self.contract_address, self.contract_abi, func_name, args)
print("receipt:", receipt)
# 解析receipt里的log
print("parse receipt and transaction:--------------------------------------")
tx_hash = receipt['transactionHash']
print("transaction hash: ", tx_hash)
log_result = self.data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in log_result:
if func_name in log:
i = i + 1
print("{}): log name: {} , data: {}".format(i, log[func_name], log['eventdata']))
# 获取对应的交易数据，解析出调用方法名和参数
tx_response = client.getTransactionByHash(tx_hash)
input_result = self.data_parser.parse_transaction_input(tx_response['input'])
print("transaction input parse:", tx_hash)
print(input_result)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
output_result = self.data_parser.parse_receipt_output(input_result['name'], receipt['output'])
print("receipt output :", output_result)
return output_result,tx_hash
except:
pass
finally:
# 关闭连接
client.finish()
def fisco_select_data(self, func_name, args):
client = BcosClient()
try:
print('start')
res = client.call(self.contract_address, self.contract_abi, func_name, args)
print("call get result:", res)
# 关闭连接
client.finish()
return res
except:
return None
def print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
txhash = receipt["transactionHash"]
txresponse = client.getTransactionByHash(txhash)
inputdetail = print_parse_transaction(txresponse, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = parser.parse_receipt_output(inputdetail['name'],
receipt['output'])
return outputresult
def print_receipt_logs_and_txoutput(client,
receipt,
contractname,
parser=None):
print("INFO >> receipt logs : ")
# 解析receipt里的log
if parser is None and len(contractname) > 0:
parser = DatatypeParser(default_abi_file(contractname))
logresult = parser.parse_event_logs(receipt["logs"])
i = 0
# print(json.dumps(logresult,indent=4))
for log in logresult:
if "eventname" in log:
i = i + 1
print("{}): log name: {} , data: {} , topic: {}".format(
i, log["eventname"], log["eventdata"], log["topic"]))
inputdetail = print_parse_transaction(receipt, "", parser)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresults = parser.parse_receipt_output(inputdetail["name"],
receipt["output"])
common.print_tx_result(outputresults)
ContractNote.save_address(contract_name, result["contractAddress"], int(result["blockNumber"], 16), memo)
#发送交易，调用一个改写数据的接口
print("\n>>sendRawTransaction:----------------------------------------------------------")
to_address = result['contractAddress'] #use new deploy address
args = ['simplename', 2024, to_checksum_address('0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1c')]
receipt = client.sendRawTransactionGetReceipt(to_address,contract_abi,"set",args)
print("receipt:",receipt)
#解析receipt里的log
print("\n>>parse receipt and transaction:----------------------------------------------------------")
txhash = receipt['transactionHash']
print("transaction hash: " ,txhash)
logresult = data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in logresult:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(i,log['eventname'],log['eventdata']))
#获取对应的交易数据，解析出调用方法名和参数
txresponse = client.getTransactionByHash(txhash)
inputresult = data_parser.parse_transaction_input(txresponse['input'])
print("transaction input parse:",txhash)
print(inputresult)
#解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = data_parser.parse_receipt_output(inputresult['name'], receipt['output'])
print("receipt output :",outputresult)
int(result["blockNumber"], 16), memo)
#发送交易，调用一个改写数据的接口
print(
"\n>>sendRawTransaction:----------------------------------------------------------"
)
to_address = result['contractAddress'] #use new deploy address
args = [
'simplename', 2024,
to_checksum_address('0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1c')
]
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi, "set",
args)
print(receipt)
#解析receipt里的log
logresult = abi_parser.parse_event_logs(receipt["logs"])
for log in logresult:
if 'eventname' in log:
print("log name: {} , data: {}".format(log['eventname'],
log['eventdata']))
#获取对应的交易数据，解析出调用方法名和参数
txhash = receipt['transactionHash']
txresponse = client.getTransactionByHash(txhash)
inputresult = abi_parser.parse_transaction_input(txresponse['input'])
print("transaction input parse:", txhash)
print(inputresult)
#解析该交易在receipt里输出的output,即交易调用的方法的return值
outputresult = abi_parser.parse_receipt_output(inputresult['name'],
receipt['output'])
print("receipt output :", outputresult)
@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()
result = parser.parse_transaction_input(tx["input"])
print(result)
def fisco_add_data_demo1():
try:
client = BcosClient()
print(client.getinfo())
print(client.client_account)
abi_file = os.path.join(settings.SITE_ROOT, "contracts",
"UserTempInfo.abi")
data_parser = DatatypeParser()
data_parser.load_abi_file(abi_file)
contract_abi = data_parser.contract_abi
# 发送交易，调用一个改写数据的接口
# print("\n>>sendRawTransaction:----------------------------------------------------")
to_address = '0x2b042831e72894e292507629bec3ae4886f6fe06' # use new deploy address
args = ['99999', '武汉', '38.9度', 20000]
receipt = client.sendRawTransactionGetReceipt(to_address, contract_abi,
"insert", args)
print("receipt:", receipt)
# # 调用一下call，获取数据
# args = ['99']
# print("\n>>Call:------------------------------------------------------------------------")
# res = client.call(to_address, contract_abi, "select", args)
# print("call get result:", res)
# 解析receipt里的log
print(
"\n>>parse receipt and transaction:--------------------------------------"
)
tx_hash = receipt['transactionHash']
print("transaction hash: ", tx_hash)
log_result = data_parser.parse_event_logs(receipt["logs"])
i = 0
for log in log_result:
if 'eventname' in log:
i = i + 1
print("{}): log name: {} , data: {}".format(
i, log['eventname'], log['eventdata']))
# 获取对应的交易数据，解析出调用方法名和参数
tx_response = client.getTransactionByHash(tx_hash)
input_result = data_parser.parse_transaction_input(
tx_response['input'])
print("transaction input parse:", tx_hash)
print(input_result)
# 解析该交易在receipt里输出的output,即交易调用的方法的return值
output_result = data_parser.parse_receipt_output(
input_result['name'], receipt['output'])
print("receipt output :", output_result)
# 调用一下call，获取数据
args = ['99999']
print(
"\n>>Call:------------------------------------------------------------------------"
)
res = client.call(to_address, contract_abi, "select", args)
print("call get result:", res)
print(
"\n>>Call:------------------------------------------------------------------------"
)
res = client.call(to_address, contract_abi, "selectLatest", args)
print("call get result:", res)
# 关闭连接
client.finish()
except:
pass
