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 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: xrd_pb2.GetObjectReq,
context) -> xrd_pb2.GetObjectResp:
logger.debug("[PublicAPI] GetObject")
answer = xrd_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.xrdnode.get_address_is_used(query):
address_state = self.xrdnode.get_optimized_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.xrdnode.get_transaction(query)
transaction = None
blockheader = None
if transaction_block_number:
transaction, block_number = transaction_block_number
answer.found = True
block = self.xrdnode.get_block_from_index(block_number)
blockheader = block.blockheader.pbdata
timestamp = block.blockheader.timestamp
else:
transaction_timestamp = self.xrdnode.get_unconfirmed_transaction(
query)
if transaction_timestamp:
transaction, timestamp = transaction_timestamp
answer.found = True
if transaction:
txextended = xrd_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.xrdnode.get_block_from_hash(query)
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.xrdnode.get_block_from_index(query_index)
if not block:
return answer
answer.found = True
block_extended = xrd_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 = xrd_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'))
def validate_address(self, qaddress: str) -> bool:
try:
return AddressState.address_is_valid(bytes(hstr2bin(qaddress[1:])))
except Exception:
return False