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