def _validate_custom(self):
if self.fee <= 0:
raise ValueError('TransferTokenTransaction [%s] Invalid Fee = %d', bin2hstr(self.txhash), self.fee)
if (len(self.addrs_to) > config.dev.transaction_multi_output_limit or
len(self.amounts) > config.dev.transaction_multi_output_limit):
logger.warning('[TransferTokenTransaction] Number of addresses or amounts exceeds max limit')
logger.warning('Number of addresses %s', len(self.addrs_to))
logger.warning('Number of amounts %s', len(self.amounts))
return False
if len(self.addrs_to) != len(self.amounts):
logger.warning('[TransferTokenTransaction] Mismatch number of addresses to & amounts')
logger.warning('>> Length of addresses_to %s', len(self.addrs_to))
logger.warning('>> Length of amounts %s', len(self.amounts))
return False
if not AddressState.address_is_valid(self.addr_from):
logger.warning('[TransferTokenTransaction] Invalid address addr_from: %s', self.addr_from)
return False
for addr_to in self.addrs_to:
if not AddressState.address_is_valid(addr_to):
logger.warning('[TransferTokenTransaction] Invalid address addr_to: %s', addr_to)
return False
return True
def validate_extended(self, addr_from_state, addr_from_pk_state, transaction_pool):
if not self.validate_slave(addr_from_state, addr_from_pk_state):
return False
tx_balance = addr_from_state.balance
if self.fee < 0:
logger.info('State validation failed for %s because: Negative send', self.txhash)
return False
if not AddressState.address_is_valid(self.addr_from):
logger.warning('Invalid address addr_from: %s', self.addr_from)
return False
if not AddressState.address_is_valid(self.owner):
logger.warning('Invalid address owner_addr: %s', self.owner)
return False
for address_balance in self.initial_balances:
if not AddressState.address_is_valid(address_balance.address):
logger.warning('Invalid address address in initial_balances: %s', address_balance.address)
return False
if tx_balance < self.fee:
logger.info('TokenTxn State validation failed for %s because: Insufficient funds', self.txhash)
logger.info('balance: %s, Fee: %s', tx_balance, self.fee)
return False
if self.ots_key_reuse(addr_from_pk_state, self.ots_key):
logger.info('TokenTxn State validation failed for %s because: OTS Public key re-use detected', self.txhash)
return False
return True
def validate_extended(self, addr_from_state, addr_from_pk_state):
if not self.validate_slave(addr_from_state, addr_from_pk_state):
return False
tx_balance = addr_from_state.balance
if not AddressState.address_is_valid(self.addr_from):
logger.warning('Invalid address addr_from: %s', self.addr_from)
return False
if not AddressState.address_is_valid(self.owner):
logger.warning('Invalid address owner_addr: %s', self.owner)
return False
for address_balance in self.initial_balances:
if not AddressState.address_is_valid(address_balance.address):
logger.warning('Invalid address address in initial_balances: %s', address_balance.address)
return False
if tx_balance < self.fee:
logger.info('TokenTxn State validation failed for %s because: Insufficient funds', self.txhash)
logger.info('balance: %s, Fee: %s', tx_balance, self.fee)
return False
if addr_from_pk_state.ots_key_reuse(self.ots_key):
logger.info('TokenTxn State validation failed for %s because: OTS Public key re-use detected', self.txhash)
return False
return True
def validate_extended(self):
if self.master_addr != config.dev.coinbase_address:
return False
if not (AddressState.address_is_valid(self.master_addr) and AddressState.address_is_valid(self.addr_to)):
logger.warning('Invalid address addr_from: %s addr_to: %s', self.master_addr, self.addr_to)
return False
return self._validate_custom()
def _validate_custom(self):
if self.fee <= 0:
raise ValueError('TransferTokenTransaction [%s] Invalid Fee = %d', bin2hstr(self.txhash), self.fee)
if not (AddressState.address_is_valid(self.addr_from) and AddressState.address_is_valid(self.txto)):
logger.warning('Invalid address addr_from: %s addr_to: %s', self.addr_from, self.txto)
return False
return True
def _validate_custom(self):
if self.amount <= 0:
raise ValueError('[%s] Invalid amount = %d', bin2hstr(self.txhash), self.amount)
if not (AddressState.address_is_valid(self.addr_from) and AddressState.address_is_valid(self.txto)):
logger.warning('Invalid address addr_from: %s addr_to: %s', self.addr_from, self.txto)
return False
return True
def validate_extended(self, addr_from_state, addr_from_pk_state, transaction_pool):
if not self.validate_slave(addr_from_state, addr_from_pk_state):
return False
if self.addr_from != config.dev.coinbase_address:
return False
if not (AddressState.address_is_valid(self.addr_from) and AddressState.address_is_valid(self.txto)):
logger.warning('Invalid address addr_from: %s addr_to: %s', self.addr_from, self.txto)
return False
return self.validate()
def validate_extended(self, addr_from_state, addr_from_pk_state):
if not self.validate_slave(addr_from_state, addr_from_pk_state):
return False
if self.addr_from != config.dev.coinbase_address:
return False
if not (AddressState.address_is_valid(self.addr_from) and AddressState.address_is_valid(self.addr_to)):
logger.warning('Invalid address addr_from: %s addr_to: %s', self.addr_from, self.addr_to)
return False
if addr_from_pk_state.ots_key_reuse(self.ots_key):
logger.warning('CoinBase Txn: OTS Public key re-use detected %s', self.txhash)
return False
return True
def get_address_state(self, address: bytes) -> qrl_pb2.AddressState:
if not AddressState.address_is_valid(address):
raise ValueError("Invalid Address")
address_state = self.db_state.get_address(address)
return address_state
def get_address_state(self, address: bytes) -> qrl_pb2.AddressState:
if not AddressState.address_is_valid(address):
raise ValueError("Invalid Address")
address_state = self.db_state.get_address_state(address)
return address_state
def get_block_to_mine(self, wallet_address, tx_pool, last_block,
last_block_difficulty) -> list:
try:
mining_address = bytes(hstr2bin(wallet_address[1:].decode()))
if not AddressState.address_is_valid(mining_address):
raise ValueError(
"[get_block_to_mine] Invalid Wallet Address %s",
wallet_address)
except Exception as e:
raise ValueError("Error while decoding wallet address %s", e)
if self._mining_block:
if last_block.headerhash == self._mining_block.prev_headerhash:
if self._mining_block.transactions[
0].coinbase.addr_to == mining_address:
return [
bin2hstr(self._mining_block.mining_blob),
int(bin2hstr(self._current_difficulty), 16)
]
else:
self._mining_block.update_mining_address(
mining_address) # Updates only Miner Address
self.prepare_next_unmined_block_template(mining_address, tx_pool,
last_block,
last_block_difficulty)
return [
bin2hstr(self._mining_block.mining_blob),
int(bin2hstr(self._current_difficulty), 16)
]
def get_address_state(self, address: bytes) -> AddressState:
if address != config.dev.coinbase_address and not AddressState.address_is_valid(
address):
raise ValueError("Invalid Address")
address_state = self._chain_manager.get_address_state(address)
return address_state
def GetObject(self, request: qrl_pb2.GetObjectReq,
context) -> qrl_pb2.GetObjectResp:
logger.debug("[PublicAPI] GetObject")
answer = qrl_pb2.GetObjectResp()
answer.found = False
# FIXME: We need a unified way to access and validate data.
query = bytes(
request.query
) # query will be as a string, if Q is detected convert, etc.
if AddressState.address_is_valid(query):
if self.qrlnode.get_address_is_used(query):
address_state = self.qrlnode.get_address_state(query)
if address_state is not None:
answer.found = True
answer.address_state.CopyFrom(address_state.pbdata)
return answer
transaction, block_number = self.qrlnode.get_transaction(query)
if transaction is not None:
answer.found = True
blockheader = None
if block_number is not None:
block = self.qrlnode.get_block_from_index(block_number)
blockheader = block.blockheader.pbdata
txextended = qrl_pb2.TransactionExtended(
header=blockheader,
tx=transaction.pbdata,
addr_from=transaction.addr_from,
size=transaction.size)
answer.transaction.CopyFrom(txextended)
return answer
# NOTE: This is temporary, indexes are accepted for blocks
try:
block = self.qrlnode.get_block_from_hash(query)
if block is None:
query_str = query.decode()
query_index = int(query_str)
block = self.qrlnode.get_block_from_index(query_index)
answer.found = True
block_extended = qrl_pb2.BlockExtended()
block_extended.header.CopyFrom(block.blockheader.pbdata)
block_extended.size = block.size
for transaction in block.transactions:
tx = Transaction.from_pbdata(transaction)
extended_tx = qrl_pb2.TransactionExtended(
tx=transaction, addr_from=tx.addr_from, size=tx.size)
block_extended.extended_transactions.extend([extended_tx])
answer.block_extended.CopyFrom(block_extended)
return answer
except Exception:
pass
return answer
def get_mining_credit_wallet(mining_credit_wallet: str):
try:
mining_credit_wallet = bytes(hstr2bin(mining_credit_wallet[1:]))
if AddressState.address_is_valid(mining_credit_wallet):
return mining_credit_wallet
except Exception:
logger.info('Exception in validate_mining_credit_wallet')
return None
def get_address_state(self,
address: bytes,
exclude_ots_bitfield: bool = False,
exclude_transaction_hashes: bool = False) -> AddressState:
if address != config.dev.coinbase_address and not AddressState.address_is_valid(address):
raise ValueError("Invalid Address")
address_state = self._chain_manager.get_address_state(address,
exclude_ots_bitfield,
exclude_transaction_hashes)
return address_state
def get_mining_address(mining_address: str):
try:
if not mining_address:
return bytes(hstr2bin(config.user.mining_address[1:]))
mining_address = bytes(hstr2bin(mining_address[1:]))
if AddressState.address_is_valid(mining_address):
return mining_address
except Exception:
logger.info('Exception in validate_mining_address')
return None
def get_all_address_state(self) -> list:
addresses_state = []
try:
for address in self._db.get_db_keys(False):
if AddressState.address_is_valid(
address) or address == config.dev.coinbase_address:
addresses_state.append(
self.get_address_state(address).pbdata)
return addresses_state
except Exception as e:
logger.error("Exception in get_addresses_state %s", e)
return []
def get_mining_address(mining_address: str):
try:
if not mining_address:
mining_address = bytes(hstr2bin(config.user.mining_address[1:]))
else:
mining_address = bytes(hstr2bin(mining_address[1:]))
if not AddressState.address_is_valid(mining_address):
raise ValueError('Mining Address Validation Failed')
return mining_address
except Exception as e:
logger.info('Failed Parsing Mining Address %s', e)
return None
def GetObject(self, request: qrl_pb2.GetObjectReq, context) -> qrl_pb2.GetObjectResp:
logger.debug("[PublicAPI] GetObject")
answer = qrl_pb2.GetObjectResp()
answer.found = False
# FIXME: We need a unified way to access and validate data.
query = bytes(request.query) # query will be as a string, if Q is detected convert, etc.
if AddressState.address_is_valid(query):
if self.qrlnode.get_address_is_used(query):
address_state = self.qrlnode.get_address_state(query)
if address_state is not None:
answer.found = True
answer.address_state.CopyFrom(address_state)
return answer
transaction, block_number = self.qrlnode.get_transaction(query)
if transaction is not None:
answer.found = True
blockheader = None
if block_number is not None:
block = self.qrlnode.get_block_from_index(block_number)
blockheader = block.blockheader.pbdata
txextended = qrl_pb2.TransactionExtended(header=blockheader,
tx=transaction.pbdata)
answer.transaction.CopyFrom(txextended)
return answer
block = self.qrlnode.get_block_from_hash(query)
if block is not None:
answer.found = True
answer.block.CopyFrom(block.pbdata)
return answer
# NOTE: This is temporary, indexes are accepted for blocks
try:
query_str = query.decode()
query_index = int(query_str)
block = self.qrlnode.get_block_from_index(query_index)
if block is not None:
answer.found = True
answer.block.CopyFrom(block.pbdata)
return answer
except Exception:
pass
return answer
def parse_qaddress(qaddress: str) -> bytes:
"""
Converts from a Qaddress to an Address.
qaddress: 'Q' + hexstring representation of an XMSS tree's address
address: binary representation, the Q is ignored when transforming from qaddress.
:param qaddress:
:return:
"""
try:
qaddress = parse_hexblob(qaddress[1:])
if not AddressState.address_is_valid(qaddress):
raise ValueError("Invalid Addresss ", qaddress)
except Exception as e:
raise ValueError("Failed To Decode Address", e)
return qaddress
def validate_extended(self, block_number: int):
if self.master_addr != config.dev.coinbase_address:
logger.warning('Master address doesnt match with coinbase_address')
logger.warning('%s %s', bin2hstr(self.master_addr),
bin2hstr(config.dev.coinbase_address))
return False
if not AddressState.address_is_valid(self.addr_to):
logger.warning('Invalid address addr_from: %s addr_to: %s',
bin2hstr(self.master_addr), bin2hstr(self.addr_to))
return False
if self.nonce != block_number + 1:
logger.warning('Nonce %s doesnt match with block_number %s',
self.nonce, block_number)
return False
return self._validate_custom()
def validate_address(self, qaddress: str) -> bool:
try:
return AddressState.address_is_valid(bytes(hstr2bin(qaddress[1:])))
except Exception:
return False
def get_address_is_used(self, address: bytes) -> bool:
if not AddressState.address_is_valid(address):
raise ValueError("Invalid Address")
return self.db_state.address_used(address)
def get_address_is_used(self, address: bytes) -> bool:
if not AddressState.address_is_valid(address):
raise ValueError("Invalid Address")
return self.db_state.address_used(address)
def GetObject(self, request: qrl_pb2.GetObjectReq,
context) -> qrl_pb2.GetObjectResp:
logger.debug("[PublicAPI] GetObject")
answer = qrl_pb2.GetObjectResp()
answer.found = False
# FIXME: We need a unified way to access and validate data.
query = bytes(
request.query
) # query will be as a string, if Q is detected convert, etc.
try:
if AddressState.address_is_valid(query):
if self.qrlnode.get_address_is_used(query):
address_state = self.qrlnode.get_address_state(query)
if address_state is not None:
answer.found = True
answer.address_state.CopyFrom(address_state.pbdata)
return answer
except ValueError:
pass
transaction_block_number = self.qrlnode.get_transaction(query)
transaction = None
blockheader = None
if transaction_block_number:
transaction, block_number = transaction_block_number
answer.found = True
block = self.qrlnode.get_block_from_index(block_number)
blockheader = block.blockheader.pbdata
timestamp = block.blockheader.timestamp
else:
transaction_timestamp = self.qrlnode.get_unconfirmed_transaction(
query)
if transaction_timestamp:
transaction, timestamp = transaction_timestamp
answer.found = True
if transaction:
txextended = qrl_pb2.TransactionExtended(
header=blockheader,
tx=transaction.pbdata,
addr_from=transaction.addr_from,
size=transaction.size,
timestamp_seconds=timestamp)
answer.transaction.CopyFrom(txextended)
return answer
# NOTE: This is temporary, indexes are accepted for blocks
try:
block = self.qrlnode.get_block_from_hash(query)
# The condition after or is to avoid a bug, where a block is deserialized by BlockNumberMapping
if block is None or (block.block_number == 0
and block.prev_headerhash !=
config.user.genesis_prev_headerhash):
query_str = query.decode()
query_index = int(query_str)
block = self.qrlnode.get_block_from_index(query_index)
if not block:
return answer
answer.found = True
block_extended = qrl_pb2.BlockExtended()
block_extended.header.CopyFrom(block.blockheader.pbdata)
block_extended.size = block.size
for transaction in block.transactions:
tx = Transaction.from_pbdata(transaction)
extended_tx = qrl_pb2.TransactionExtended(
tx=transaction,
addr_from=tx.addr_from,
size=tx.size,
timestamp_seconds=block.blockheader.timestamp)
block_extended.extended_transactions.extend([extended_tx])
answer.block_extended.CopyFrom(block_extended)
return answer
except Exception:
pass
return answer
def test_address_is_valid(self):
self.assertTrue(AddressState.address_is_valid(alice.address))
self.assertFalse(AddressState.address_is_valid(b'fake address'))