def handle_ephemeral(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Receives Ephemeral Message
:param source:
:param message:
:return:
"""
try:
encrypted_ephemeral = EncryptedEphemeralMessage(message.ephData)
except Exception as e:
logger.error(
'ephemeral_message rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(
encrypted_ephemeral.get_message_hash(), self):
return
if not encrypted_ephemeral.validate():
return
source.factory.broadcast_ephemeral_message(
encrypted_ephemeral) # FIXME(cyyber) : Fix broken link
def handle_slave(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Receives Lattice Public Key Transaction
:param message:
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.SL)
try:
tx = Transaction.from_pbdata(message.slData)
except Exception as e:
logger.error(
'slave_txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
if not tx.validate():
logger.warning('>>>Slave Txn %s invalid state validation failed..',
tx.hash)
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_message_transaction(self, source,
message: qrllegacy_pb2.LegacyMessage):
"""
Message Transaction
This function processes whenever a Transaction having
subtype MESSAGE is received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.MT)
try:
tx = Transaction.from_pbdata(message.mtData)
except Exception as e:
logger.error(
'Message Txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
if tx.txhash in source.factory.buffered_chain.tx_pool.pending_tx_pool_hash:
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_block(self, source,
message: qrllegacy_pb2.LegacyMessage): # block received
"""
Block
This function processes any new block received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.BK)
try:
block = Block(message.block)
except Exception as e:
logger.error(
'block rejected - unable to decode serialised data %s',
source.addr_remote)
logger.exception(e)
return
logger.info('>>>Received block from %s %s %s', source.addr_remote,
block.block_number, bin2hstr(block.headerhash))
if not source.factory.master_mr.isRequested(block.headerhash, source,
block):
return
source.factory.pow.pre_block_logic(
block) # FIXME: Ignores return value
source.factory.master_mr.register(qrllegacy_pb2.LegacyMessage.BK,
block.headerhash, message.block)
def handle_transfer_token_transaction(
source, message: qrllegacy_pb2.LegacyMessage):
"""
Transfer Token Transaction
This function processes whenever a Transaction having
subtype TRANSFERTOKEN is received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.TT)
try:
tx = Transaction.from_pbdata(message.ttData)
except Exception as e:
logger.error(
'Transfer Token Txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def _store(self):
if self._filename is not None:
try:
with open(self._filename, 'w') as f:
json.dump(self._data, f)
except Exception as e:
logger.error("not possible to save banned peers")
logger.exception(e)
def get_re_org_limit(self) -> int:
try:
return int.from_bytes(self._db.get_raw(b'reorg_limit'), byteorder='big', signed=False)
except KeyError:
return 0
except Exception as e:
logger.error('get_re_org_limit Exception %s', e)
return -1
def get_mainchain_height(self) -> int:
try:
return int.from_bytes(self._db.get_raw(b'blockheight'), byteorder='big', signed=False)
except KeyError:
pass
except Exception as e:
logger.error('get_blockheight Exception %s', e)
return -1
def get_dev_config_current_state_key(self):
try:
return self._db.get_raw(b'dev_config_current_state_key')
except KeyError:
logger.debug('[get_dev_config_current_state_key] Dev Config not found')
except Exception as e:
logger.error('[get_dev_config_current_state_key] %s', e)
return None
def get_mainchain_height(self) -> int:
try:
return self._db.get('blockheight')
except KeyError:
pass
except Exception as e:
logger.error('get_blockheight Exception %s', e)
return -1
def _parse_tx_object(source, message: qrllegacy_pb2.LegacyMessage, kind):
tx = None
try:
tx = Transaction.from_pbdata(message.mtData)
except Exception as e:
logger.error('Message Txn rejected - unable to decode serialised data - closing connection')
logger.exception(e)
source.loseConnection()
return tx
def get_mainchain_height(self) -> int:
try:
return self._db.get('blockheight')
except KeyError:
pass
except Exception as e:
logger.error('get_blockheight Exception %s', e)
return -1
def get_block(state: State, header_hash: bytes):
try:
data = state._db.get_raw(header_hash)
return Block.deserialize(data)
except KeyError:
logger.debug('[get_block] Block header_hash %s not found', bin2hstr(header_hash).encode())
except Exception as e:
logger.error('[get_block] %s', e)
return None
def get_token_metadata(self, token_txhash: bytes):
try:
json_data = self._db.get_raw(b'token_' + token_txhash)
return TokenMetadata.from_json(json_data)
except KeyError:
pass
except Exception as e:
logger.error('[get_token_metadata] %s', e)
return None
def get_token_metadata(state: State, token_txhash: bytes):
try:
data = state._db.get_raw(b'token_' + token_txhash)
return TokenMetadata.deserialize(data)
except KeyError:
pass
except Exception as e:
logger.error('[get_token_metadata] %s', e)
return None
def get_token_metadata(db, state_code, token_txhash: bytes):
try:
json_data = db.get_raw(state_code + b'token_' + token_txhash)
return TokenMetadata.from_json(json_data)
except KeyError:
pass
except Exception as e:
logger.error('[get_token_metadata] %s', e)
return None
def get_block(self, header_hash: bytes) -> Optional[Block]:
try:
json_data = self._db.get_raw(bin2hstr(header_hash).encode())
return Block.from_json(json_data)
except KeyError:
logger.debug('[get_block] Block header_hash %s not found', bin2hstr(header_hash).encode())
except Exception as e:
logger.error('[get_block] %s', e)
return None
def get_block(self, header_hash: bytes) -> Optional[Block]:
try:
json_data = self._db.get_raw(bin2hstr(header_hash).encode())
return Block.from_json(json_data)
except KeyError:
logger.debug('[get_block] Block header_hash %s not found', bin2hstr(header_hash).encode())
except Exception as e:
logger.error('[get_block] %s', e)
return None
def address_used(self, address: bytes):
# FIXME: Probably obsolete
try:
return self._get_address_state(address)
except KeyError:
return False
except Exception as e:
# FIXME: Review
logger.error('Exception in address_used')
logger.exception(e)
raise
def get_block_number_mapping(state: State, block_number: int):
try:
data = state._db.get_raw(str(block_number).encode())
block_number_mapping = qrl_pb2.BlockNumberMapping()
return Parse(data, block_number_mapping)
except KeyError:
logger.debug('[get_block_number_mapping] Block #%s not found', block_number)
except Exception as e:
logger.error('[get_block_number_mapping] %s', e)
return None
def get_token(self, address: bytes, token_txhash: bytes) -> qrl_pb2.TokenBalance:
try:
token_balance = qrl_pb2.TokenBalance()
token_balance.ParseFromString(self._db.get_raw(self.generate_token_key(address, token_txhash)))
return token_balance
except KeyError:
pass
except Exception as e:
logger.error('[get_token] %s', e)
return None
def get_state(state: State, shared_key):
try:
data = state._db.get_raw(b'shared_key_' + shared_key)
return VoteStats.deserialize(data)
except KeyError:
logger.debug('[get_state] VoteStats %s not found',
bin2hstr(shared_key).encode())
except Exception as e:
logger.error('[get_state] %s', e)
return None
def get_block_number_mapping(self, block_number: int) -> Optional[qrl_pb2.BlockNumberMapping]:
try:
json_data = self._db.get_raw(str(block_number).encode())
block_number_mapping = qrl_pb2.BlockNumberMapping()
return Parse(json_data, block_number_mapping)
except KeyError:
logger.debug('[get_block_number_mapping] Block #%s not found', block_number)
except Exception as e:
logger.error('[get_block_number_mapping] %s', e)
return None
def get_block_number_mapping(self, block_number: bytes) -> Optional[qrl_pb2.BlockNumberMapping]:
try:
json_data = self._db.get_raw(str(block_number).encode())
block_number_mapping = qrl_pb2.BlockNumberMapping()
return Parse(json_data, block_number_mapping)
except KeyError:
logger.debug('[get_block_number_mapping] Block #%s not found', block_number)
except Exception as e:
logger.error('[get_block_number_mapping] %s', e)
return None
def get_txn_count(self, addr):
try:
return self._db.get((b'txn_count_' + addr))
except KeyError:
pass
except Exception as e:
# FIXME: Review
logger.error('Exception in get_txn_count')
logger.exception(e)
return 0
def address_used(self, address: bytes):
# FIXME: Probably obsolete
try:
return self.get_address_state(address)
except KeyError:
return False
except Exception as e:
# FIXME: Review
logger.error('Exception in address_used')
logger.exception(e)
raise
def get_address_is_used(self, address: bytes) -> bool:
# FIXME: Probably obsolete
try:
return self._db.get_raw(address)
except KeyError:
return False
except Exception as e:
# FIXME: Review
logger.error('Exception in address_used')
logger.exception(e)
raise
def get_txn_count(db, state_code, addr):
try:
return db.get(state_code + b'txn_count_' + addr)
except KeyError:
pass
except Exception as e:
# FIXME: Review
logger.error('Exception in get_txn_count')
logger.exception(e)
return 0
def get_txn_count(self, addr):
try:
return self._db.get(b'txn_count_' + addr)
except KeyError:
pass
except Exception as e:
# FIXME: Review
logger.error('Exception in get_txn_count')
logger.exception(e)
return 0
def get_slave_pk_access_type(self, address: bytes, slave_pk: bytes) -> qrl_pb2.SlaveMetadata:
slave_key = self.generate_slave_key(address, slave_pk)
try:
slave_metadata = qrl_pb2.SlaveMetadata()
slave_metadata.ParseFromString(self._db.get_raw(slave_key))
return slave_metadata
except KeyError:
pass
except Exception as e:
logger.error('[get_slave_pk_access_type] %s', e)
return None
def _revert_copy_key_value(src: dict, dst: dict,
error_if_key_not_found: bool) -> bool:
for key in src:
if key in dst:
del dst[key]
elif error_if_key_not_found:
logger.error(
"Key %s not found while reverting key from state_container",
key)
return False
return True
def get_block_metadata(self,
header_hash: bytes) -> Optional[BlockMetadata]:
try:
data = self._db.get_raw(b'metadata_' + header_hash)
return BlockMetadata.deserialize(data)
except KeyError:
logger.debug('[get_block_metadata] Block header_hash %s not found',
b'metadata_' + bin2hstr(header_hash).encode())
except Exception as e:
logger.error('[get_block_metadata] %s', e)
return None
def get_fork_state(self) -> Optional[qrlstateinfo_pb2.ForkState]:
try:
data = self._db.get_raw(b'fork_state')
fork_state = qrlstateinfo_pb2.ForkState()
fork_state.ParseFromString(bytes(data))
return fork_state
except KeyError:
return None
except Exception as e:
logger.error('Exception in get_fork_state')
logger.exception(e)
raise
def get_dev_config_state(self, dev_config_state_key: bytes):
try:
data = self._db.get_raw(dev_config_state_key)
pbdata = qrl_pb2.DevConfig()
pbdata.ParseFromString(bytes(data))
return pbdata
except KeyError:
logger.debug('[get_dev_config_state] Dev Config not found')
except Exception as e:
logger.error('[get_dev_config_state] %s', e)
return None
def get_txn_count(self, addr):
try:
return int.from_bytes(self._db.get_raw(b'txn_count_' + addr),
byteorder='big',
signed=False)
except KeyError:
pass
except Exception as e:
# FIXME: Review
logger.error('Exception in get_txn_count')
logger.exception(e)
return 0
def handle_push_block(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Push Block
This function processes requested blocks received while syncing.
Block received under this function are directly added to the main
chain i.e. chain.blockchain
It is expected to receive only one block for a given blocknumber.
:return:
"""
# FIXME: Later rename
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.PB)
if message.pbData is None:
return
try:
block = Block(message.pbData.block)
source.factory.block_received(source, block)
except Exception as e:
logger.error('block rejected - unable to decode serialised data %s', source.peer_ip)
logger.exception(e)
def mining_wallet_checks(args):
slaves_filename = os.path.join(config.user.wallet_dir, config.user.slaves_filename)
if args.randomizeSlaveXMSS:
addrBundle = Wallet.get_new_address()
slaves = [addrBundle.xmss.get_address(), [addrBundle.xmss.get_seed()], None]
write_slaves(slaves_filename, slaves)
try:
slaves = read_slaves(slaves_filename)
except FileNotFoundError:
logger.warning('No Slave Seeds found!!')
logger.warning('It is highly recommended to use the slave for mining')
try:
ans = input('Do you want to use main wallet for mining? (Y/N) ')
if ans == 'N':
quit(0)
seed = input('Enter hex or mnemonic seed of mining wallet ').encode()
except KeyboardInterrupt:
quit(0)
if len(seed) == 96: # hexseed
bin_seed = hstr2bin(seed.decode())
elif len(seed.split()) == 32:
bin_seed = mnemonic2bin(seed.decode())
else:
logger.warning('Invalid XMSS seed')
quit(1)
addrBundle = Wallet.get_new_address(seed=bin_seed)
slaves = [addrBundle.xmss.get_address(), [addrBundle.xmss.get_seed()], None]
write_slaves(slaves_filename, slaves)
slaves = read_slaves(slaves_filename)
except KeyboardInterrupt:
quit(1)
except Exception as e:
logger.error('Exception %s', e)
quit(1)
return slaves
def handle_block(self, source, message: qrllegacy_pb2.LegacyMessage): # block received
"""
Block
This function processes any new block received.
:return:
"""
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.BK)
try:
block = Block(message.block)
except Exception as e:
logger.error('block rejected - unable to decode serialised data %s', source.peer_ip)
logger.exception(e)
return
logger.info('>>>Received block from %s %s %s',
source.connection_id,
block.block_number,
bin2hstr(block.headerhash))
if not source.factory.master_mr.isRequested(block.headerhash, source, block):
return
source.factory.pow.pre_block_logic(block) # FIXME: Ignores return value
source.factory.master_mr.register(qrllegacy_pb2.LegacyMessage.BK, block.headerhash, message.block)
def validate(self, data):
try:
for key in self.params.keys():
if self.params[key] != data[key]:
return False
return True
except KeyError as k:
logger.error('Params Keys %s', self.params.keys())
logger.error('Data Keys %s', data.keys())
logger.error('Key Not found %s ', k)
return False
def reset_processor_flag_with_err(self, msg):
logger.error('Exception in txn task')
logger.error('%s', msg)
self._txn_processor_running = False
