def token_list(ctx, owner):
"""
Fetch the list of tokens owned by an address.
"""
try:
owner_address = parse_qaddress(owner)
except Exception as e:
click.echo("Error validating arguments: {}".format(e))
quit(1)
try:
stub = ctx.obj.get_stub_public_api()
address_state_req = qrl_pb2.GetAddressStateReq(address=owner_address)
address_state_resp = stub.GetAddressState(address_state_req,
timeout=CONNECTION_TIMEOUT)
for token_hash in address_state_resp.state.tokens:
get_object_req = qrl_pb2.GetObjectReq(
query=bytes(hstr2bin(token_hash)))
get_object_resp = stub.GetObject(get_object_req,
timeout=CONNECTION_TIMEOUT)
click.echo('Hash: %s' % (token_hash, ))
click.echo(
'Symbol: %s' %
(get_object_resp.transaction.tx.token.symbol.decode(), ))
click.echo('Name: %s' %
(get_object_resp.transaction.tx.token.name.decode(), ))
click.echo('Balance: %s' %
(address_state_resp.state.tokens[token_hash], ))
except Exception as e:
print("Error {}".format(str(e)))
def _public_get_address_balance(ctx, address):
stub = ctx.obj.get_stub_public_api()
get_address_state_req = qrl_pb2.GetAddressStateReq(
address=parse_qaddress(address))
get_optimized_address_state_resp = stub.GetOptimizedAddressState(
get_address_state_req, timeout=CONNECTION_TIMEOUT)
return get_optimized_address_state_resp.state.balance
def token_list(ctx, owner):
"""
Create Token Transaction, that results into the formation of new token if accepted.
"""
if not ctx.obj.remote:
click.echo('This command is unsupported for local wallets')
return
try:
owner_address = _parse_qaddress(owner)
except Exception as e:
click.echo("Error validating arguments: {}".format(e))
quit(1)
try:
stub = ctx.obj.get_stub_public_api()
addressStateReq = qrl_pb2.GetAddressStateReq(address=owner_address)
addressStateResp = stub.GetAddressState(addressStateReq, timeout=5)
for token_hash in addressStateResp.state.tokens:
click.echo('Hash: %s' % (token_hash, ))
click.echo('Balance: %s' %
(addressStateResp.state.tokens[token_hash], ))
except Exception as e:
print("Error {}".format(str(e)))
def _public_get_address_balance(ctx, address):
address = address[1:]
stub = qrl_pb2_grpc.PublicAPIStub(ctx.obj.channel_public)
getAddressStateReq = qrl_pb2.GetAddressStateReq(
address=bytes(hstr2bin(address)))
getAddressStateResp = stub.GetAddressState(getAddressStateReq, timeout=1)
return getAddressStateResp.state.balance
def test_getTotalBalance(self):
db_state = Mock(spec=State)
xmss1 = get_alice_xmss()
xmss2 = get_alice_xmss(4)
xmss3 = get_bob_xmss(4)
address_state1 = AddressState.create(address=xmss1.address,
nonce=25,
balance=1000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state2 = AddressState.create(address=xmss2.address,
nonce=25,
balance=2000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state3 = AddressState.create(address=xmss3.address,
nonce=25,
balance=3000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
m = MockFunction()
m.put(xmss1.address, address_state1)
m.put(xmss2.address, address_state2)
m.put(xmss3.address, address_state3)
db_state.get_address_state = m.get
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTotalBalanceReq()
request.addresses.extend([xmss1.address, xmss2.address, xmss3.address])
response = service.GetTotalBalance(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(6000, response.balance)
def test_getAddressState(self):
db_state = Mock(spec=State)
db_state.get_address = MagicMock(return_value=AddressState.create(
address=b'Q' + sha256(b'address'),
nonce=25,
balance=10,
pubhashes=[sha256(b'a'), sha256(b'b')],
tokens=dict()))
db_state.get_address_tx_hashes = MagicMock(
return_value=[sha256(b'0'), sha256(b'1')])
p2p_factory = Mock(spec=P2PFactory)
chain = Chain(db_state)
buffered_chain = BufferedChain(chain)
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
request.address = b'Q' + sha256(b'address')
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(b'Q' + sha256(b'address'), response.state.address)
self.assertEqual(25, response.state.nonce)
self.assertEqual(10, response.state.balance)
self.assertEqual([sha256(b'a'), sha256(b'b')],
response.state.pubhashes)
self.assertEqual([sha256(b'0'), sha256(b'1')],
response.state.transaction_hashes)
def test_getAddressState(self):
with set_qrl_dir('no_data'):
db_state = State()
alice_xmss = get_alice_xmss()
optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
AddressState.put_address_state(db_state, optimized_address_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
request.address = get_alice_xmss().address
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(alice_xmss.address, response.state.address)
self.assertEqual(25, response.state.nonce)
self.assertEqual(10, response.state.balance)
self.assertEqual([b'\x00'] * config.dev.ots_bitfield_size, response.state.ots_bitfield)
self.assertEqual([], response.state.transaction_hashes)
def test_getAddressState(self):
db_state = Mock(spec=State)
alice_xmss = get_alice_xmss()
address_state = AddressState.create(address=alice_xmss.address,
nonce=25,
balance=10,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
db_state.get_address_state = MagicMock(return_value=address_state)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
request.address = get_alice_xmss().address
response = service.GetAddressState(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(alice_xmss.address, response.state.address)
self.assertEqual(25, response.state.nonce)
self.assertEqual(10, response.state.balance)
self.assertEqual([b'\x00'] * config.dev.ots_bitfield_size,
response.state.ots_bitfield)
self.assertEqual([], response.state.transaction_hashes)
def query_addr(qrl_client, addr):
request = qrl_pb2.GetObjectReq(query=bytes.fromhex(addr[1:]))
response = qrl_client.GetObject(request)
log_msg('', response)
if addr.startswith('Q1'):
request = qrl_pb2.GetMultiSigAddressStateReq(
address=bytes.fromhex(addr[1:]))
response = qrl_client.GetMultiSigAddressState(request)
log_msg('', response)
request = qrl_pb2.GetMultiSigSpendTxsByAddressReq(
address=bytes.fromhex(addr[1:]),
item_per_page=8,
page_number=1,
filter_type=qrl_pb2.GetMultiSigSpendTxsByAddressReq.NONE)
response = qrl_client.GetMultiSigSpendTxsByAddress(request)
log_msg('', response)
else:
request = qrl_pb2.GetAddressStateReq(address=bytes.fromhex(addr[1:]))
response = qrl_client.GetAddressState(request)
log_msg('', response)
def token_list(ctx, owner):
"""
Fetch the list of tokens owned by an address.
"""
try:
owner_address = parse_qaddress(owner)
except Exception as e:
click.echo("Error validating arguments: {}".format(e))
quit(1)
try:
stub = ctx.obj.get_stub_public_api()
address_state_req = qrl_pb2.GetAddressStateReq(address=owner_address)
address_state_resp = stub.GetAddressState(address_state_req, timeout=CONNECTION_TIMEOUT)
for token_hash in address_state_resp.state.tokens:
click.echo('Hash: %s' % (token_hash,))
click.echo('Balance: %s' % (address_state_resp.state.tokens[token_hash],))
except Exception as e:
print("Error {}".format(str(e)))
def token_list(ctx, owner):
"""
Create Token Transaction, that results into the formation of new token if accepted.
"""
if not ctx.obj.remote:
click.echo('This command is unsupported for local wallets')
return
try:
channel = grpc.insecure_channel(ctx.obj.node_public_address)
stub = qrl_pb2_grpc.PublicAPIStub(channel)
addressStateReq = qrl_pb2.GetAddressStateReq(address=owner.encode())
addressStateResp = stub.GetAddressState(addressStateReq, timeout=5)
for token_hash in addressStateResp.state.tokens:
click.echo('Hash: %s' % (token_hash,))
click.echo('Balance: %s' % (addressStateResp.state.tokens[token_hash],))
except Exception as e:
print("Error {}".format(str(e)))
def audit_regular_addr(qrl_client, addr):
""" Validate the provided regular address """
balance = 0
tx_count = 0
bad_tx_count = 0
request_addr = qrl_pb2.GetAddressStateReq(address=bytes.fromhex(addr[1:]))
response_addr = qrl_client.GetAddressState(request_addr)
if not response_addr.HasField('state'):
logging.error('could not find address {}'.format(addr))
return balance, tx_count, bad_tx_count
balance = response_addr.state.balance
tx_count = len(response_addr.state.transaction_hashes)
for txhash in response_addr.state.transaction_hashes:
request_tx = qrl_pb2.GetObjectReq(query=bytes.fromhex(txhash.hex()))
response_tx = qrl_client.GetObject(request_tx)
if not response_tx.HasField('transaction'):
bad_tx_count += 1
logging.error('txhash {} for addr {} does not exist'.format(
txhash, addr))
continue
tx = response_tx.transaction.tx
if tx.HasField('transfer') or tx.HasField('multi_sig_spend'):
tmptxhash = (tx.master_addr + to_bytes(tx.fee))
if tx.HasField('transfer'):
tmptxhash += (tx.transfer.message_data +
get_tx_hash(tx.transfer))
if tx.HasField('multi_sig_spend'):
tmptxhash += (
tx.multi_sig_spend.multi_sig_address +
to_bytes(tx.multi_sig_spend.expiry_block_number) +
get_tx_hash(tx.multi_sig_spend))
data_hash = sha256(tmptxhash)
signature = tx.signature
public_key = tx.public_key
if not XmssFast.verify(data_hash, signature, public_key):
logging.info(
'txhash {} for addr {} failed XmssFast verification'.
format(txhash, addr))
return balance, tx_count, bad_tx_count
def getbalance():
stub = get_public_stub()
grpc_response = stub.GetOptimizedAddressState(
request=qrl_pb2.GetAddressStateReq(address=payment_slaves[0]))
return grpc_response.state.balance
def _public_get_address_balance(ctx, address):
stub = ctx.obj.get_stub_public_api()
getAddressStateReq = qrl_pb2.GetAddressStateReq(
address=_parse_qaddress(address))
getAddressStateResp = stub.GetAddressState(getAddressStateReq, timeout=1)
return getAddressStateResp.state.balance
def test_getTotalBalance(self):
with set_qrl_dir('no_data'):
db_state = State()
xmss1 = get_alice_xmss()
xmss2 = get_alice_xmss(4)
xmss3 = get_bob_xmss(4)
address_state1 = OptimizedAddressState.create(address=xmss1.address,
nonce=25,
balance=1000,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
address_state2 = OptimizedAddressState.create(address=xmss2.address,
nonce=25,
balance=2000,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
address_state3 = OptimizedAddressState.create(address=xmss3.address,
nonce=25,
balance=3000,
ots_bitfield_used_page=0,
transaction_hash_count=0,
tokens_count=0,
lattice_pk_count=0,
slaves_count=0,
multi_sig_address_count=0)
AddressState.put_address_state(db_state, address_state1)
AddressState.put_address_state(db_state, address_state2)
AddressState.put_address_state(db_state, address_state3)
p2p_factory = Mock(spec=P2PFactory)
chain_manager = ChainManager(db_state)
qrlnode = QRLNode(mining_address=b'')
qrlnode.set_chain_manager(chain_manager)
qrlnode._p2pfactory = p2p_factory
qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTotalBalanceReq()
request.addresses.extend([xmss1.address, xmss2.address, xmss3.address])
response = service.GetTotalBalance(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(6000, response.balance)
def get_addr_state(addr: bytes) -> AddressState:
stub = get_public_stub()
response = stub.GetAddressState(request=qrl_pb2.GetAddressStateReq(
address=addr))
return AddressState(response.state)
def get_address_state(self, qaddress: str) -> AddressState:
request = qrl_pb2.GetAddressStateReq(
address=bytes(hstr2bin(qaddress[1:])))
resp = self._public_stub.GetAddressState(request=request)
return AddressState(resp.state)
