def get_relationships(self, include_list, item):
relationships = {}
if 'extrinsics' in include_list:
relationships['extrinsics'] = Extrinsic.query(
self.session).filter_by(
block_id=item.bid,
shard_num=item.shard_num).order_by('extrinsic_idx')
if 'transactions' in include_list:
relationships['transactions'] = Extrinsic.query(
self.session).filter_by(
block_id=item.bid, signed=1,
shard_num=item.shard_num).order_by('extrinsic_idx')
if 'inherents' in include_list:
relationships['inherents'] = Extrinsic.query(self.session).filter(
Extrinsic.block_id == item.bid, Extrinsic.signed == 0,
Extrinsic.shard_num == item.shard_num,
Extrinsic.module_id != 'relay').order_by('extrinsic_idx')
if 'relay' in include_list:
relationships['relay'] = Extrinsic.query(self.session).filter(
Extrinsic.block_id == item.bid, Extrinsic.signed == 0,
Extrinsic.shard_num == item.shard_num,
Extrinsic.module_id == 'relay').order_by('extrinsic_idx')
if 'events' in include_list:
relationships['events'] = Event.query(self.session).filter_by(
block_id=item.bid, system=0,
shard_num=item.shard_num).order_by('event_idx')
if 'logs' in include_list:
relationships['logs'] = Log.query(self.session).filter_by(
block_id=item.bid,
shard_num=item.shard_num).order_by('log_idx')
return relationships
def remove_block(self, block_hash):
# Retrieve block
block = Block.query(self.db_session).filter_by(hash=block_hash).first()
# Revert event processors
for event in Event.query(self.db_session).filter_by(block_id=block.id):
for processor_class in ProcessorRegistry().get_event_processors(event.module_id, event.event_id):
event_processor = processor_class(block, event, None)
event_processor.accumulation_revert(self.db_session)
# Revert extrinsic processors
for extrinsic in Extrinsic.query(self.db_session).filter_by(block_id=block.id):
for processor_class in ProcessorRegistry().get_extrinsic_processors(extrinsic.module_id, extrinsic.call_id):
extrinsic_processor = processor_class(block, extrinsic)
extrinsic_processor.accumulation_revert(self.db_session)
# Revert block processors
for processor_class in ProcessorRegistry().get_block_processors():
block_processor = processor_class(block)
block_processor.accumulation_revert(self.db_session)
# Delete events
for item in Event.query(self.db_session).filter_by(block_id=block.id):
self.db_session.delete(item)
# Delete extrinsics
for item in Extrinsic.query(self.db_session).filter_by(block_id=block.id):
self.db_session.delete(item)
# Delete block
self.db_session.delete(block)
def on_get(self, req, resp):
page = int(req.params.get('page') if req.params.get('page') else 1)
pageSize = int(
req.params.get('page_size') if req.params.get('page_size') else 20)
moduleId = req.params.get('module_id') if req.params.get(
'module_id') else None
callId = req.params.get('call_id') if req.params.get(
'call_id') else None
if moduleId == 'All':
moduleId = None
if callId == 'All':
callId = None
resp.status = falcon.HTTP_200
extrinsics = Extrinsic.all_extrinsics(self.session, page, pageSize,
moduleId, callId)
result = [{
"extrinsic_id":
'{}-{}'.format(extrinsic.block_id, extrinsic.extrinsic_idx),
"block_id":
extrinsic.block_id,
"hash":
"0x{}".format(extrinsic.extrinsic_hash)
if extrinsic.extrinsic_hash else None,
"age":
extrinsic.datetime.strftime("%Y-%m-%d %H:%M:%S"),
"result":
extrinsic.success,
"operation":
'{}({})'.format(extrinsic.module_id, extrinsic.call_id),
"params":
extrinsic.params,
"address":
extrinsic.address if extrinsic.address else None,
"nonce":
extrinsic.nonce if extrinsic.nonce else None,
"signature":
extrinsic.signature if extrinsic.signature else None
} for extrinsic in extrinsics]
if moduleId and callId:
count = Extrinsic.query(self.session).filter(
and_(Extrinsic.module_id == moduleId,
Extrinsic.call_id == callId)).count()
elif moduleId:
count = Extrinsic.query(
self.session).filter(Extrinsic.module_id == moduleId).count()
else:
count = Extrinsic.query(self.session).count()
resp.media = {
'status': 'success',
'data': {
'result': result,
'count': count
}
}
def get_item(self, item_id):
if item_id[0:2] == '0x':
extrinsic = Extrinsic.query(
self.session).filter_by(extrinsic_hash=item_id[2:]).first()
else:
extrinsic = Extrinsic.query(self.session).get(item_id.split('-'))
return extrinsic
def getEventHash(self, blockId, extrinsicIdx):
extrinsic = Extrinsic.query(self.session).filter(
and_(Extrinsic.block_id == blockId,
Extrinsic.extrinsic_idx == extrinsicIdx)).first()
if extrinsic:
return extrinsic.extrinsic_hash
return None
def on_get(self, req, resp):
substrate = SubstrateInterface(url=SUBSTRATE_RPC_URL,
address_type=SUBSTRATE_ADDRESS_TYPE,
type_registry_preset=TYPE_REGISTRY)
resp.status = falcon.HTTP_200
# head = Block.get_head(self.session);
head_hash = substrate.get_chain_head()
head_number = substrate.get_block_number(head_hash)
finalised_head_hash = substrate.get_chain_finalised_head()
finalised_head_number = substrate.get_block_number(finalised_head_hash)
extrinsicCount = Extrinsic.query(self.session).count()
try:
validators = substrate.get_runtime_state(
module="Session",
storage_function="Validators",
params=[],
block_hash=head_hash).get('result', [])
except StorageFunctionNotFound:
validators = []
try:
validator_count = substrate.get_runtime_state(
module="Staking",
storage_function="ValidatorCount",
params=[],
block_hash=head_hash).get('result', 0)
except StorageFunctionNotFound:
validator_count = 0
transfers_count = Extrinsic.query(self.session).filter(
and_(Extrinsic.module_id == 'balances',
Extrinsic.call_id == 'transfer')).count()
resp.media = {
'status': 'success',
'data': {
'blockNumber': head_number,
'finalizedBlockNumber': finalised_head_number,
'extrinsics': extrinsicCount,
'currValidators': len(validators),
'validators': validator_count,
'transfersCount': transfers_count
}
}
def get_relationships(self, include_list, item):
relationships = {}
if 'recent_extrinsics' in include_list:
relationships['recent_extrinsics'] = Extrinsic.query(self.session).filter_by(
address=item.account_id).order_by(Extrinsic.block_id.desc())[:10]
return relationships
def rebuild_search_index(self):
self.db_session.execute('truncate table {}'.format(
SearchIndex.__tablename__))
for block in Block.query(
self.db_session).order_by('id').yield_per(1000):
extrinsic_lookup = {}
block._accounts_new = []
block._accounts_reaped = []
for extrinsic in Extrinsic.query(self.db_session).filter_by(
block_id=block.id).order_by('extrinsic_idx'):
extrinsic_lookup[extrinsic.extrinsic_idx] = extrinsic
# Add search index for signed extrinsics
if extrinsic.address:
search_index = SearchIndex(
index_type_id=settings.SEARCH_INDEX_SIGNED_EXTRINSIC,
block_id=block.id,
extrinsic_idx=extrinsic.extrinsic_idx,
account_id=extrinsic.address)
search_index.save(self.db_session)
# Process extrinsic processors
for processor_class in ProcessorRegistry(
).get_extrinsic_processors(extrinsic.module_id,
extrinsic.call_id):
extrinsic_processor = processor_class(
block=block,
extrinsic=extrinsic,
substrate=self.substrate)
extrinsic_processor.process_search_index(self.db_session)
for event in Event.query(self.db_session).filter_by(
block_id=block.id).order_by('event_idx'):
extrinsic = None
if event.extrinsic_idx is not None:
try:
extrinsic = extrinsic_lookup[event.extrinsic_idx]
except (IndexError, KeyError):
extrinsic = None
for processor_class in ProcessorRegistry(
).get_event_processors(event.module_id, event.event_id):
event_processor = processor_class(
block,
event,
extrinsic,
metadata=self.metadata_store.get(
block.spec_version_id),
substrate=self.substrate)
event_processor.process_search_index(self.db_session)
self.db_session.commit()
def get_relationships(self, include_list, item):
relationships = {}
if 'extrinsics' in include_list:
relationships['extrinsics'] = Extrinsic.query(self.session).filter_by(block_id=item.id).order_by(
'extrinsic_idx')
if 'transactions' in include_list:
relationships['transactions'] = Extrinsic.query(self.session).filter_by(block_id=item.id, signed=1).order_by(
'extrinsic_idx')
if 'inherents' in include_list:
relationships['inherents'] = Extrinsic.query(self.session).filter_by(block_id=item.id, signed=0).order_by(
'extrinsic_idx')
if 'events' in include_list:
relationships['events'] = Event.query(self.session).filter_by(block_id=item.id, system=0).order_by(
'event_idx')
if 'logs' in include_list:
relationships['logs'] = Log.query(self.session).filter_by(block_id=item.id).order_by(
'log_idx')
return relationships
def sequence_block(self,
block,
parent_block_data=None,
parent_sequenced_block_data=None):
sequenced_block = BlockTotal(id=block.id)
# Process block processors
for processor_class in ProcessorRegistry().get_block_processors():
block_processor = processor_class(block,
sequenced_block,
substrate=self.substrate)
block_processor.sequencing_hook(self.db_session, parent_block_data,
parent_sequenced_block_data)
extrinsics = Extrinsic.query(self.db_session).filter_by(
block_id=block.id).order_by('extrinsic_idx')
for extrinsic in extrinsics:
# Process extrinsic processors
for processor_class in ProcessorRegistry(
).get_extrinsic_processors(extrinsic.module_id, extrinsic.call_id):
extrinsic_processor = processor_class(block,
extrinsic,
substrate=self.substrate)
extrinsic_processor.sequencing_hook(
self.db_session, parent_block_data,
parent_sequenced_block_data)
events = Event.query(
self.db_session).filter_by(block_id=block.id).order_by('event_idx')
# Process event processors
for event in events:
extrinsic = None
if event.extrinsic_idx is not None:
try:
extrinsic = extrinsics[event.extrinsic_idx]
except IndexError:
extrinsic = None
for processor_class in ProcessorRegistry().get_event_processors(
event.module_id, event.event_id):
event_processor = processor_class(block,
event,
extrinsic,
substrate=self.substrate)
event_processor.sequencing_hook(self.db_session,
parent_block_data,
parent_sequenced_block_data)
sequenced_block.save(self.db_session)
return sequenced_block
def get_relationships(self, include_list, item):
relationships = {}
if 'params' in include_list:
relationships['params'] = RuntimeCallParam.query(self.session).filter_by(
runtime_call_id=item.id).order_by('id')
if 'recent_extrinsics' in include_list:
relationships['recent_extrinsics'] = Extrinsic.query(self.session).filter_by(
call_id=item.call_id, module_id=item.module_id).order_by(Extrinsic.block_id.desc())[:10]
return relationships
def get_relationships(self, include_list, item):
relationships = {}
if 'recent_extrinsics' in include_list:
relationships['recent_extrinsics'] = Extrinsic.query(self.session).filter_by(
address=item.id).order_by(Extrinsic.block_id.desc())[:10]
if 'indices' in include_list:
relationships['indices'] = AccountIndex.query(self.session).filter_by(
account_id=item.id).order_by(AccountIndex.updated_at_block.desc())
return relationships
def get_item(self, item_id):
if 'origin-' not in item_id and '-' in item_id:
st = item_id.split("-")
return Extrinsic.query(self.session).filter_by(
extrinsic_idx=int(st[2]),
block_id=int(st[1]),
shard_num=int(st[0])).first()
if len(item_id) < 10:
return Extrinsic.query(self.session).filter_by(id=item_id).first()
if 'origin-' in item_id:
if '0x' in item_id:
return Extrinsic.query(
self.session).filter_by(origin_hash=item_id[9:]).first()
else:
return Extrinsic.query(
self.session).filter_by(origin_hash=item_id[7:]).first()
if item_id[0:2] == '0x':
return Extrinsic.query(
self.session).filter_by(extrinsic_hash=item_id[2:]).first()
else:
return Extrinsic.query(
self.session).filter_by(extrinsic_hash=item_id).first()
def on_get(self, req, resp):
resp.status = falcon.HTTP_200
page = int(req.params.get('page') if req.params.get('page') else 1)
pageSize = int(
req.params.get('page_size') if req.params.get('page_size') else 10)
extrinsics = Extrinsic.latest_extrinsics(self.session, page, pageSize)
result = []
for extrinsic in extrinsics:
extrinsicId = '{}-{}'.format(extrinsic.block_id,
extrinsic.extrinsic_idx)
fromAddr = ss58_encode(extrinsic.address.replace('0x', ''))
hash = "0x{}".format(extrinsic.extrinsic_hash)
timestamp = extrinsic.datetime.strftime(
"%Y-%m-%d %H:%M:%S"
) if extrinsic.datetime is not None else None
blockId = extrinsic.block_id
success = extrinsic.success
# print(extrinsic);
# timestamp = time.mktime(extrinsic.datetime.timetuple())
params = json.loads(extrinsic.params)
for param in params:
name = param.get('name')
if name == 'dest':
toAddr = ss58_encode(param.get('value').replace('0x', ''))
elif name == 'value':
coin = param.get('value') / 1000000000000000 # 转换为单位 Unit
result.append({
"extrinsic_id": extrinsicId,
"block_id": blockId,
"from": fromAddr,
"to": toAddr,
"hash": hash,
"timestamp": timestamp,
"coin": coin,
"result": success
})
count = Extrinsic.query(self.session).filter(
and_(Extrinsic.module_id == "balances",
Extrinsic.call_id == "transfer")).count()
resp.media = {
'status': 'success',
'data': {
"result": result,
"count": count
}
}
def check(self):
# Extrinsic.query(self.session).filter(Extrinsic.module_id == 'balances', Extrinsic.call_id == 'transfer',
# Block.shard_num == Extrinsic.shard_num,
# Extrinsic.block_id > 37926).order_by(
# Extrinsic.block_id.desc())
items = Extrinsic.query(self.session).join(
Block, Extrinsic.block_id == Block.bid).filter(
Extrinsic.module_id == 'balances',
Extrinsic.call_id == 'transfer',
Block.shard_num == Extrinsic.shard_num,
Extrinsic.block_id > 38375).order_by(Extrinsic.block_id.desc())
# self.session.query(Extrinsic).join(Block, Extrinsic.block_id == Block.bid)
print(items)
data = [self.serialize_item(item) for item in items],
def accumulation_hook(self, db_session):
extrinsic = Extrinsic.query(db_session).filter_by(extrinsic_idx=self.event.extrinsic_idx, block_id=self.event.block_id).first()
if extrinsic.module_id == 'Utility' and extrinsic.call_id == 'batch':
#XYK pool creation (aka LP token)
#don't process it for now
pass
else:
data_asset = DataAsset(
asset_id=self.event.attributes[0]['value'],
symbol=extrinsic.params[0]['value'],
precision=18, #TODO may be changed
name=extrinsic.params[1]['value'],
is_mintable=True if extrinsic.params[3]['value'] == 'true' else False
)
data_asset.save(db_session)
def process_reorg_block(self, block):
model = ReorgBlock(**block.asdict())
model.save(self.db_session)
for extrinsic in Extrinsic.query(
self.db_session).filter_by(block_id=block.id):
model = ReorgExtrinsic(block_hash=block.hash, **extrinsic.asdict())
model.save(self.db_session)
for event in Event.query(self.db_session).filter_by(block_id=block.id):
model = ReorgEvent(block_hash=block.hash, **event.asdict())
model.save(self.db_session)
for log in Log.query(self.db_session).filter_by(block_id=block.id):
model = ReorgLog(block_hash=block.hash, **log.asdict())
model.save(self.db_session)
def accumulation_hook(self, db_session):
extrinsic = Extrinsic.query(db_session).filter_by(extrinsic_idx=self.event.extrinsic_idx, block_id=self.event.block_id).first()
if extrinsic.module_id == 'Assets' and extrinsic.call_id == 'register':
data_asset = Asset(
asset_id=self.event.attributes[0]['value'],
symbol=extrinsic.params[0]['value'],
precision=0 if extrinsic.params[4]['value'] else 18, #TODO may be changed
name=extrinsic.params[1]['value'],
is_mintable=True if extrinsic.params[3]['value'] else False
)
existing_assset = Asset.query(db_session).filter(Asset.asset_id == data_asset.asset_id).first()
if not existing_assset:
data_asset.save(db_session)
else:
#XYK pool creation (aka LP token) or Ethereum bridge
#don't process it for now
pass
def get_relationships(self, include_list, item):
relationships = {}
if 'recent_extrinsics' in include_list:
relationships['recent_extrinsics'] = Extrinsic.query(
self.session).filter_by(address=item.id).order_by(
Extrinsic.block_id.desc())[:10]
if 'indices' in include_list:
relationships['indices'] = AccountIndex.query(
self.session).filter_by(account_id=item.id).order_by(
AccountIndex.updated_at_block.desc())
if 'rewards' in include_list:
relationships['rewards'] = Block.query(self.session).filter_by(
coinbase=bech32.encode(HRP,
bytes().fromhex(item.id))).order_by(
Block.id.desc())
# Block.query(self.session).order_by(Block.id.desc()
# count = self.session.query(func.count(Block.id)).filter(Block.coinbase == item_id).scalar()
return relationships
def on_get(self, req, resp, network_id=None):
resp.status = falcon.HTTP_200
# TODO make caching more generic for custom resources
cache_key = '{}-{}'.format(req.method, req.url)
console_handler = logging.StreamHandler()
console_handler.setLevel('INFO')
logger = logging.getLogger('yee')
logger.setLevel('DEBUG')
logger.addHandler(console_handler)
# logger.info(cache_key)
response = self.cache_region.get(cache_key, self.cache_expiration_time)
if response is NO_VALUE:
best_block = Block.query(self.session).filter_by(
id=self.session.query(func.max(Block.id)).one()[0]).first()
total_signed_extrinsics = Extrinsic.query(
self.session).filter_by(signed=1).count()
total_accounts = Account.query(self.session).filter_by().count()
# total_events = Event.query(self.session).count()
event = Event.query(self.session).filter_by(
id=self.session.query(func.max(Event.id)).one()[0]).first()
if event is None:
eventid = 0
else:
eventid = event.id
if best_block:
substrate = SubstrateInterface(
SUBSTRATE_RPC_URL,
metadata_version=SUBSTRATE_METADATA_VERSION)
print(substrate.get_ShardCount())
response = self.get_jsonapi_response(data={
'type': 'networkstats',
'id': network_id,
'attributes': {
'best_block': best_block.id,
'total_signed_extrinsics': total_signed_extrinsics,
'total_events': eventid,
'total_events_module': int(best_block.id),
'total_blocks': 'N/A',
'total_accounts': total_accounts,
'total_runtimes': Runtime.query(self.session).count(),
'shard_count': int(substrate.get_ShardCount(), 16)
}
}, )
else:
response = self.get_jsonapi_response(data={
'type': 'networkstats',
'id': network_id,
'attributes': {
'best_block': 0,
'total_signed_extrinsics': 0,
'total_events': 0,
'total_events_module': 0,
'total_blocks': 'N/A',
'total_accounts': 0,
'total_runtimes': 0
}
}, )
self.cache_region.set(cache_key, response)
resp.set_header('X-Cache', 'MISS')
else:
resp.set_header('X-Cache', 'HIT')
resp.media = response
def get_query(self):
return Extrinsic.query(self.session).options(defer('params')).order_by(
Extrinsic.block_id.desc())
def get_query(self):
return Extrinsic.query(self.session).filter_by(
module_id='balances',
call_id='transfer').order_by(Extrinsic.datetime.desc())
def get_query(self):
return Extrinsic.query(self.session).order_by(
Extrinsic.block_id.desc())
def get_item(self, item_id):
if item_id[0:2] == '0x':
return Extrinsic.query(
self.session).filter_by(extrinsic_hash=item_id[2:]).first()
def get_query(self):
return Extrinsic.query(
self.session).filter(Extrinsic.module_id == 'balances'
and Extrinsic.call_id == 'transfer').order_by(
Extrinsic.block_id.desc())
def on_post(self, req, resp):
blockHash = None
if req.media.get('block_id'):
substrate = SubstrateInterface(url=SUBSTRATE_RPC_URL,
address_type=SUBSTRATE_ADDRESS_TYPE,
type_registry_preset=TYPE_REGISTRY)
blockHash = substrate.get_block_hash(req.media.get('block_id'))
elif req.media.get('block_hash'):
blockHash = req.media.get('block_hash')
else:
resp.status = falcon.HTTP_BAD_REQUEST
resp.media = {
'errors': ['Either blockHash or block_id should be supplied']
}
if blockHash:
resp.status = falcon.HTTP_200
block = Block.query(
self.session).filter(Block.hash == blockHash).first()
blockTotal = BlockTotal.query(
self.session).filter(BlockTotal.id == block.id).first()
author = ss58_encode(
blockTotal.author.replace('0x', '')
) if blockTotal is not None and blockTotal.author is not None else None
if block:
blockInfo = {}
blockInfo["timestamp"] = block.datetime.strftime(
"%Y-%m-%d %H:%M:%S")
blockInfo["block_hash"] = block.hash
blockInfo["block_id"] = block.id
blockInfo["parent_id"] = block.id - 1 if block.id > 0 else 0
blockInfo["child_id"] = block.id + 1
blockInfo["parent_hash"] = block.parent_hash
blockInfo["state_root"] = block.state_root
blockInfo["extrinsic_root"] = block.extrinsics_root
blockInfo["validator"] = author
blockInfo["count_extrinsic"] = block.count_extrinsics
blockInfo["count_event"] = block.count_events
blockInfo["count_log"] = block.count_log
# blockInfo["age"] = time.mktime(block.datetime.timetuple())
blockInfo["age"] = block.datetime.strftime("%Y-%m-%d %H:%M:%S")
# 获取和区块相关的交易信息
extrinsics = Extrinsic.query(
self.session).filter(Extrinsic.block_id == block.id).all()
extrinsicsObj = [
{
"extrinsic_id":
'{}-{}'.format(block.id, extrinsic.extrinsic_idx),
"hash":
extrinsic.extrinsic_hash
if extrinsic.extrinsic_hash else None,
# "age": time.mktime(block.datetime.timetuple()),
"age":
block.datetime.strftime("%Y-%m-%d %H:%M:%S"),
"result":
extrinsic.success,
# "address": extrinsic.address if extrinsic.address else None,
# "module": extrinsic.module_id,
# "fee": None,
# "nonce": extrinsic.nonce if extrinsic.nonce else None,
# "call": extrinsic.call_id,
"operation":
'{}({})'.format(extrinsic.module_id,
extrinsic.call_id),
"params":
extrinsic.params
# "signature": extrinsic.signature if extrinsic.signature else None
} for extrinsic in extrinsics
]
# 获取和区块相关的日志信息
logs = Log.query(
self.session).filter(Log.block_id == block.id).all()
logsObj = [{
"log_id": '{}-{}'.format(block.id, log.log_idx),
"block_id": block.id,
"type": log.type,
"data": log.data['value']
} for log in logs]
# 获取和区块相关的事件信息
events = Event.query(
self.session).filter(Event.block_id == block.id).all()
eventObj = [{
"id":
'{}-{}'.format(block.id, event.event_idx),
"block_id":
block.id,
"block_hash":
block.hash,
"module_id":
event.module_id,
"event_id":
event.event_id,
"attributes":
event.attributes,
"operation":
'{}({})'.format(event.module_id, event.event_id),
"desc":
self.getEventDesc(event.module_id, event.event_id),
"hash":
self.getEventHash(block.id, event.extrinsic_idx)
} for event in events]
resp.media = {
'status': 'success',
'data': {
"block_info": blockInfo,
"extrinsics": extrinsicsObj,
"logs": logsObj,
"events": eventObj
}
}
else:
resp.status = falcon.HTTP_404
resp.media = {'result': 'Block not found'}
def get_query(self):
return Extrinsic.query(self.session).order_by(
Extrinsic.datetime.desc())