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 = xrd_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 = xrd_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 test_getAddressState(self):
with set_xrd_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)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = xrd_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 get_addr_state(addr: bytes) -> AddressState:
stub = get_public_stub()
response = stub.GetAddressState(request=xrd_pb2.GetAddressStateReq(
address=addr))
return AddressState(response.state)
def getbalance():
stub = get_public_stub()
grpc_response = stub.GetOptimizedAddressState(
request=xrd_pb2.GetAddressStateReq(address=payment_slaves[0]))
return grpc_response.state.balance
def test_getTotalBalance(self):
with set_xrd_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)
xrdnode = xrdNode(mining_address=b'')
xrdnode.set_chain_manager(chain_manager)
xrdnode._p2pfactory = p2p_factory
xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1']
service = PublicAPIService(xrdnode)
context = Mock(spec=ServicerContext)
request = xrd_pb2.GetAddressStateReq()
service.GetAddressState(request=request, context=context)
context.set_code.assert_called()
context.set_details.assert_called()
context = Mock(spec=ServicerContext)
request = xrd_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 _public_get_address_balance(ctx, address):
stub = ctx.obj.get_stub_public_api()
get_address_state_req = xrd_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 get_address_state(self, qaddress: str) -> AddressState:
request = xrd_pb2.GetAddressStateReq(
address=bytes(hstr2bin(qaddress[1:])))
resp = self._public_stub.GetAddressState(request=request)
return AddressState(resp.state)