def analysis_block():
gph = Graphene(node=nodeaddress)
from PythonMiddleware.instance import set_shared_graphene_instance
set_shared_graphene_instance(gph)
while 1:
if pending_block_num_q:
try:
pending_block_num_deque_lock.acquire()
block_num = pending_block_num_q.popleft()
pending_block_num_deque_lock.release()
logger.debug('pop block number: {}'.format(block_num))
try:
block_info = gph.rpc.get_block(block_num)
time = block_info["timestamp"]
transactions = block_info["transactions"]
operations_list = parse_operations(gph, block_num, time,
transactions)
#logger.debug('block: {}, trx_list: {}'.format(block_num, operations_list))
except Exception as e:
logger.error(
'parse block exception. block {}, error {}'.format(
block_num, repr(e)))
if operations_list:
op_deque_lock.acquire()
operations_q.append(operations_list)
op_deque_lock.release()
except Exception as e:
logger.error("pending_block_num_q: {}, except: '{}'".format(
pending_block_num_q, repr(e)))
sleep(0.7)
def listen_block():
def on_block_callback(recv_block_id):
global global_last_block_num
info = gph.info()
# logger.debug('info: {}'.format(info))
head_block_id = info['head_block_id']
head_block_number = info['head_block_number']
# logger.debug('head_block_num {}, recv_block_id: {}, head_block_id {}'.format(head_block_number, recv_block_id, head_block_id))
if recv_block_id == head_block_id:
if head_block_number != global_last_block_num+1:
if global_last_block_num > 0:
logger.info('head_block_num {}, recv_block_id: {}, head_block_id {}'.format(head_block_number, recv_block_id, head_block_id))
logger.warn('current block num: {}, last block num: {}'.format(head_block_number, global_last_block_num))
#send message
global_last_block_num = head_block_number
else:
try:
logger.info('head_block_num {}, recv_block_id: {}, head_block_id {}'.format(head_block_number, recv_block_id, head_block_id))
block = gph.rpc.get_block(global_last_block_num+1)
global_last_block_num = global_last_block_num+1
logger.warn('>> get_block {}, recv_block_id: {}, head_block_id: {}, get block response： {}'.format(
global_last_block_num, recv_block_id, head_block_id, block['block_id']))
except Exception as e:
logger.error('get_block exception. block {}, error {}'.format(global_last_block_num+1, repr(e)))
gph = Graphene(node=nodeaddress)
from PythonMiddleware.instance import set_shared_graphene_instance
set_shared_graphene_instance(gph)
notify = Notify(
on_block = on_block_callback,
graphene_instance = gph
)
notify.listen()
def listen_block():
def on_block_callback(recv_block_id):
info = gph.info()
#logger.debug('info: {}'.format(info))
head_block_id = info['head_block_id']
block_num = info['head_block_number']
logger.info(
'recv_block_id: {}, head_block_id {}, head_block_num {}'.format(
recv_block_id, head_block_id, block_num))
if recv_block_id == head_block_id:
pending_block_num_deque_lock.acquire()
pending_block_num_q.append(block_num)
pending_block_num_deque_lock.release()
logger.info("pending deque >>>: {}".format(pending_block_num_q))
try:
block = gph.rpc.get_block(block_num)
#witness_id = block['witness']
# block_witness = gph.rpc.get_object(gph.rpc.get_object(block['witness'])['witness_account'])['name']
witness_obj = gph.rpc.get_object(block['witness'])
witness_account_obj = gph.rpc.get_object(
witness_obj['witness_account'])
except Exception as e:
logger.error('get_object exception. block {}, error {}'.format(
block_num, repr(e)))
block_time = block['timestamp']
transactions = block["transactions"]
witness_sign = block['witness_signature']
trx_total = 0
ops_total = 0
transactions_id = []
if transactions:
trx_total = len(transactions)
for trx in transactions:
transactions_id.append(trx[0])
ops_total += len(trx[1]["operations"])
block_data = {
"block_num": block_num,
"time": block_time,
"witness_id": witness_obj["id"],
"witness_account_id": witness_account_obj['id'],
"witness_account_name": witness_account_obj["name"],
"witness_sign": witness_sign,
"transactions_total": trx_total,
"transactions_id": transactions_id,
"operations_total": ops_total
}
block_info_deque_lock.acquire()
block_info_q.append(block_data)
block_info_deque_lock.release()
gph = Graphene(node=nodeaddress)
from PythonMiddleware.instance import set_shared_graphene_instance
set_shared_graphene_instance(gph)
notify = Notify(on_block=on_block_callback, graphene_instance=gph)
notify.listen() # 启动监听服务
def __init__(self, **kwargs):
print("kwargs:", kwargs)
self.gph = Graphene(node=self.node_address,
blocking=self.blocking,
**kwargs)
set_shared_graphene_instance(self.gph)
if self.gph.wallet.created() is False:
self.gph.wallet.newWallet(self.wallet_pwd)
self.gph.wallet.unlock(self.wallet_pwd)
try:
self.gph.wallet.addPrivateKey(self.wifkey)
except:
pass
"id": "1.2.16",
"private_key": "5J2SChqa9QxrCkdMor9VC2k9NT4R4ctRrJA6odQCPkb3yL89vxo",
"public_key": "COCOS56a5dTnfGpuPoWACnYj65dahcXMpTrNQkV3hHWCFkLxMF5mXpx",
}
## wallet_password
wallet_password = "******"
## chain-node ws config
# nodeAddress = "wss://api.cocosbcx.net"
nodeAddress = "wss://test.cocosbcx.net"
# nodeAddress = "ws://127.0.0.1:8049"
################################ config END ################################
gph = Graphene(node=nodeAddress, blocking=True)
set_shared_graphene_instance(gph)
def get_account(name):
try:
account = Account(name)
return account
except Exception as e:
error_msg = repr(e)
print('[WARN]name {}, error: {}'.format(name, repr(e)))
return None
def create_account(name, owner_key, active_key, memo_key, registrar):
try:
response = gph.create_account(account_name=name, registrar=registrar,
owner_key=owner_key, active_key=active_key, memo_key=memo_key)
print(response)