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)