def clientConnectionFailed(self, connector, reason):
logger.debug('connection failed: %s', reason)
def startedConnecting(self, connector):
logger.debug('Started connecting: %s', connector)
def TransferCoins(self, request: qrl_pb2.TransferCoinsReq,
context) -> qrl_pb2.TransferCoinsResp:
logger.debug("[QRLNode] TransferCoins")
return qrl_pb2.TransferCoinsResp()
def clientConnectionLost(self, connector, reason):
logger.debug('connection lost: %s', reason)
def Ping(self, request: qrl_pb2.PingReq,
context: object) -> qrl_pb2.PongResp:
logger.debug("Ping!")
return qrl_pb2.PongResp(message='Hello, %s!' % request.name)
def GetTokenDetailedList(self, request: qrl_pb2.Empty,
context) -> qrl_pb2.TokenDetailedList:
logger.debug("[PublicAPI] TokenDetailedList")
token_detailed_list = self.qrlnode.get_token_detailed_list()
return token_detailed_list
def MR(self, data):
"""
Message Receipt
This function accepts message receipt from peer,
checks if the message hash already been received or not.
In case its a already received message, it is ignored.
Otherwise the request is made to get the full message.
:return:
"""
mr_data = qrl_pb2.MR()
try:
Parse(data, mr_data)
except Exception as e: # Disconnect peer not following protocol
logger.debug(
'Disconnected peer %s not following protocol in MR %s',
self.conn_identity, e)
self.transport.loseConnection()
msg_hash = mr_data.hash
if mr_data.type not in MessageReceipt.allowed_types:
return
if mr_data.type in [
'TX'
] and self.factory.sync_state.state != ESyncState.synced:
return
if mr_data.type == 'TX':
if len(self.factory.buffered_chain.tx_pool.pending_tx_pool
) >= config.dev.transaction_pool_size:
logger.warning(
'TX pool size full, incoming tx dropped. mr hash: %s',
bin2hstr(msg_hash))
return
if mr_data.type == 'ST' or mr_data.type == 'VT':
if self.factory.buffered_chain.height > 1 and self.factory.sync_state.state != ESyncState.synced:
return
if self.factory.master_mr.contains(msg_hash, mr_data.type):
return
self.factory.master_mr.add_peer(msg_hash, mr_data.type, self, mr_data)
if self.factory.master_mr.is_callLater_active(
msg_hash): # Ignore if already requested
return
if mr_data.type == 'BK':
block_chain_buffer = self.factory.buffered_chain
if not block_chain_buffer.verify_BK_hash(mr_data,
self.conn_identity):
if block_chain_buffer.is_duplicate_block(
block_idx=mr_data.block_number,
prev_headerhash=mr_data.prev_headerhash,
stake_selector=mr_data.stake_selector):
self.factory.RFM(mr_data)
return
blocknumber = mr_data.block_number
target_blocknumber = block_chain_buffer.bkmr_tracking_blocknumber(
self.factory.ntp)
if target_blocknumber != self.factory.bkmr_blocknumber:
self.factory.bkmr_blocknumber = target_blocknumber
del self.factory.bkmr_priorityq
self.factory.bkmr_priorityq = PriorityQueue()
if blocknumber != target_blocknumber or blocknumber == 1:
self.factory.RFM(mr_data)
return
score = block_chain_buffer.score_BK_hash(mr_data)
self.factory.bkmr_priorityq.put((score, msg_hash))
if not self.factory.bkmr_processor.active():
self.factory.bkmr_processor = reactor.callLater(
1, self.factory.select_best_bkmr)
return
self.factory.RFM(mr_data)
def ST(self, data):
"""
Stake Transaction
This function processes whenever a Transaction having
subtype ST is received.
:return:
"""
try:
st = Transaction.from_json(data)
except Exception as e:
logger.error(
'st rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
self.transport.loseConnection()
return
if not self.factory.master_mr.isRequested(st.get_message_hash(), self):
return
if len(self.factory.buffered_chain._chain.blockchain) == 1 and \
st.activation_blocknumber > self.factory.buffered_chain.height + config.dev.blocks_per_epoch:
return
height = self.factory.buffered_chain.height + 1
stake_validators_tracker = self.factory.buffered_chain.get_stake_validators_tracker(
height)
if st.txfrom in stake_validators_tracker.future_stake_addresses:
logger.debug(
'P2P dropping st as staker is already in future_stake_address %s',
st.txfrom)
return
if st.txfrom in stake_validators_tracker.sv_dict:
expiry = stake_validators_tracker.sv_dict[
st.txfrom].activation_blocknumber + config.dev.blocks_per_epoch
if st.activation_blocknumber < expiry:
logger.debug(
'P2P dropping st txn as it is already active for the given range %s',
st.txfrom)
return
if st.activation_blocknumber > height + config.dev.blocks_per_epoch:
logger.debug(
'P2P dropping st as activation_blocknumber beyond limit')
return False
for t in self.factory.buffered_chain.tx_pool.transaction_pool:
if st.get_message_hash() == t.get_message_hash():
return
tx_state = self.factory.buffered_chain.get_stxn_state(
blocknumber=self.factory.buffered_chain.height + 1, addr=st.txfrom)
if st.validate() and st.validate_extended(tx_state=tx_state):
self.factory.buffered_chain.tx_pool.add_tx_to_pool(st)
else:
logger.warning('>>>ST %s invalid state validation failed..',
bin2hstr(tuple(st.hash)))
return
self.factory.register_and_broadcast('ST', st.get_message_hash(),
st.to_json())
def GetNodeState(self, request: qrl_pb2.GetNodeStateReq,
context) -> qrl_pb2.GetNodeStateResp:
if self.context_observer is not None:
self.context_observer(context)
logger.debug("[GetNodeState]")
return qrl_pb2.GetNodeStateResp(info=self.qrlnode.getNodeInfo())
