def test_getHeight(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) chain_manager._last_block = Mock() chain_manager._last_block.block_number = 100 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.GetHeightReq() response = service.GetHeight(request=request, context=context) self.assertEqual(response.height, 100)
def test_GetAddressFromPK(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) pk = hstr2bin( '01060057ac9cb6085a8135631dcf018dff46d9c368a0b64d508f512e584199b6800' 'f8cfcb672b931398a023680fe0308ed4b6ec75877d684bc2ccf11703e8369f064e7' ) request = qrl_pb2.GetAddressFromPKReq(pk=bytes(pk)) response = service.GetAddressFromPK(request=request, context=None) self.assertEqual( '010600b56d161c7de8aa741962e3e49b973b7e53456fa47f2443d69f17c632f29c8b1aab7d2491', bin2hstr(response.address))
def test_getKnownPeers(self): p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.num_connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 chain_manager.last_block = Block() qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode.peer_manager = Mock() qrlnode.peer_manager.known_peer_addresses = [ '127.0.0.1', '192.168.1.1' ] service = PublicAPIService(qrlnode) response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq, context=None) self.assertEqual(2, len(response.known_peers)) self.assertEqual('127.0.0.1', response.known_peers[0].ip) self.assertEqual('192.168.1.1', response.known_peers[1].ip) logger.info(response)
def start_services(node: QRLNode): public_server = grpc.server( ThreadPoolExecutor(max_workers=1), maximum_concurrent_rpcs=config.user.max_peers_limit) add_BaseServicer_to_server(BaseService(node), public_server) add_PublicAPIServicer_to_server(PublicAPIService(node), public_server) public_server.add_insecure_port("[::]:9009") public_server.start() logger.info("grpc public service - started !") admin_server = grpc.server( ThreadPoolExecutor(max_workers=1), maximum_concurrent_rpcs=config.user.max_peers_limit) add_AdminAPIServicer_to_server(AdminAPIService(node), admin_server) admin_server.add_insecure_port("127.0.0.1:9008") admin_server.start() mining_server = grpc.server( ThreadPoolExecutor(max_workers=1), maximum_concurrent_rpcs=config.user.max_peers_limit) add_MiningAPIServicer_to_server(MiningAPIService(node), mining_server) mining_server.add_insecure_port("[::]:9007") mining_server.start() logger.info("grpc admin service - started !") return admin_server, public_server, mining_server
def test_getBlock(self): with set_qrl_dir('no_data'): db_state = State() p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) alice_xmss = get_alice_xmss() b = Block.create(dev_config=config.dev, block_number=1, prev_headerhash=sha256(b'reveal'), prev_timestamp=10, transactions=[], miner_address=alice_xmss.address, seed_height=0, seed_hash=None) Block.put_block(db_state, b, None) db_state.get_block = MagicMock(return_value=b) context = Mock(spec=ServicerContext) request = qrl_pb2.GetBlockReq(header_hash=b.headerhash) response = service.GetBlock(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(1, response.block.header.block_number)
def test_getHeight(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) addresses_state = {optimized_address_state.address: optimized_address_state} AddressState.put_addresses_state(db_state, addresses_state) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) chain_manager._last_block = Mock() chain_manager._last_block.block_number = 100 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.GetHeightReq() response = service.GetHeight(request=request, context=context) self.assertEqual(response.height, 100)
def test_getKnownPeers(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pos = Mock() p2p_factory.pos.stake = False buffered_chain = Mock(spec=BufferedChain) buffered_chain.height = 0 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) response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq, context=None) self.assertEqual(2, len(response.known_peers)) self.assertEqual('127.0.0.1', response.known_peers[0].ip) self.assertEqual('192.168.1.1', response.known_peers[1].ip) logger.info(response)
def test_getTransactionsByAddress(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) # Find a transaction alice_xmss = get_alice_xmss() db_state.get_address_state = MagicMock( return_value=AddressState.get_default(alice_xmss.address)) db_state.address_used = MagicMock(return_value=False) context = Mock(spec=ServicerContext) request = qrl_pb2.GetTransactionsByAddressReq( address=alice_xmss.address) response = service.GetTransactionsByAddress(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(len(response.mini_transactions), 0) self.assertEqual(response.balance, 0)
def test_getBlockByNumber(self): db_state = Mock(spec=State) db_state.get_tx_metadata = MagicMock(return_value=None) db_state.get_block = MagicMock(return_value=None) p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) alice_xmss = get_alice_xmss() b = Block.create(block_number=1, prev_headerhash=sha256(b'reveal'), prev_timestamp=10, transactions=[], miner_address=alice_xmss.address) db_state.get_block_by_number = MagicMock(return_value=b) context = Mock(spec=ServicerContext) request = qrl_pb2.GetBlockByNumberReq(block_number=b.block_number) response = service.GetBlockByNumber(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(1, response.block.header.block_number)
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_transferCoins_get_unsigned(self): with set_data_dir('no_data'): with State() as db_state: with set_wallet_dir("test_wallet"): p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(db_state, slaves=[]) qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) alice = get_alice_xmss() bob = get_bob_xmss() request = qrl_pb2.TransferCoinsReq( address_from=alice.address, addresses_to=[bob.address], amounts=[101], fee=12, xmss_pk=alice.pk) response = service.TransferCoins(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertIsNotNone(response) self.assertIsNotNone(response.transaction_unsigned) self.assertEqual( 'transfer', response.transaction_unsigned.WhichOneof( 'transactionType')) self.assertEqual(alice.address, response.transaction_unsigned.addr_from) self.assertEqual(12, response.transaction_unsigned.fee) self.assertEqual(alice.pk, response.transaction_unsigned.public_key) self.assertEqual(0, response.transaction_unsigned.nonce) self.assertEqual(b'', response.transaction_unsigned.signature) self.assertEqual( b'', response.transaction_unsigned.transaction_hash) self.assertEqual( bob.address, response.transaction_unsigned.transfer.addrs_to[0]) self.assertEqual( 101, response.transaction_unsigned.transfer.amounts[0])
def test_getStakers(self): db_state = Mock(spec=State) db_state.stake_validators_tracker = Mock(spec=StakeValidatorsTracker) db_state.stake_validators_tracker.sv_dict = dict() p2p_factory = Mock(spec=P2PFactory) buffered_chain = Mock(spec=BufferedChain) buffered_chain.tx_pool = Mock() buffered_chain.get_block = Mock() buffered_chain._chain = Mock() qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT, offset=0, quantity=3) response = service.GetStakers(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertEqual(0, len(response.stakers)) # Add a few validators stake_tx = StakeTransaction.create(1, get_alice_xmss(), get_bob_xmss().pk(), sha256(b'terminator')) expected_address = bytes(get_alice_xmss().get_address().encode()) db_state.get_address = MagicMock( return_value=AddressState.create(address=expected_address, nonce=1, balance=100, pubhashes=[], tokens=dict())) db_state.get_address_tx_hashes = MagicMock(return_value=[]) validator1 = StakeValidator.create(100, stake_tx) db_state.stake_validators_tracker.sv_dict[ validator1.address] = validator1 request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT, offset=0, quantity=3) response = service.GetStakers(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertEqual(1, len(response.stakers)) self.assertEqual(expected_address, response.stakers[0].address_state.address)
def test_getStats_timeseries(self): with MockedBlockchain.create(10) as mock_blockchain: service = PublicAPIService(mock_blockchain.qrlnode) request = qrl_pb2.GetStatsReq(include_timeseries=1) stats = service.GetStats(request=request, context=None) print(stats.block_timeseries) self.assertEqual(11, len(stats.block_timeseries)) self.assertEqual(61, stats.block_time_mean) self.assertEqual(1, stats.block_time_sd)
def test_transferCoins_push_unsigned(self): with set_qrl_dir('wallet_ver1'): with State() as db_state: p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) alice = get_alice_xmss() bob = get_bob_xmss() request = qrl_pb2.TransferCoinsReq( addresses_to=[bob.address], amounts=[101], fee=12, xmss_pk=alice.pk ) response = service.TransferCoins(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertIsNotNone(response) self.assertIsNotNone(response.extended_transaction_unsigned) self.assertEqual('transfer', response.extended_transaction_unsigned.tx.WhichOneof('transactionType')) self.assertEqual(12, response.extended_transaction_unsigned.tx.fee) self.assertEqual(alice.pk, response.extended_transaction_unsigned.tx.public_key) self.assertEqual(0, response.extended_transaction_unsigned.tx.nonce) self.assertEqual(b'', response.extended_transaction_unsigned.tx.signature) self.assertEqual(b'', response.extended_transaction_unsigned.tx.transaction_hash) self.assertEqual(bob.address, response.extended_transaction_unsigned.tx.transfer.addrs_to[0]) self.assertEqual(101, response.extended_transaction_unsigned.tx.transfer.amounts[0]) req_push = qrl_pb2.PushTransactionReq(transaction_signed=response.extended_transaction_unsigned.tx) resp_push = service.PushTransaction(req_push, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertIsNotNone(resp_push) self.assertEqual(qrl_pb2.PushTransactionResp.VALIDATION_FAILED, resp_push.error_code)
def start_services(node: QRLNode): public_server = grpc.server( ThreadPoolExecutor(max_workers=config.user.public_api_threads), maximum_concurrent_rpcs=config.user.public_api_max_concurrent_rpc) add_BaseServicer_to_server(BaseService(node), public_server) add_PublicAPIServicer_to_server(PublicAPIService(node), public_server) if config.user.public_api_enabled: public_server.add_insecure_port("{0}:{1}".format( config.user.public_api_host, config.user.public_api_port)) public_server.start() logger.info("grpc public service - started !") admin_server = grpc.server( ThreadPoolExecutor(max_workers=config.user.admin_api_threads), maximum_concurrent_rpcs=config.user.admin_api_max_concurrent_rpc) add_AdminAPIServicer_to_server(AdminAPIService(node), admin_server) if config.user.admin_api_enabled: admin_server.add_insecure_port("{0}:{1}".format( config.user.admin_api_host, config.user.admin_api_port)) admin_server.start() logger.info("grpc admin service - started !") mining_server = grpc.server( ThreadPoolExecutor(max_workers=config.user.mining_api_threads), maximum_concurrent_rpcs=config.user.mining_api_max_concurrent_rpc) add_MiningAPIServicer_to_server(MiningAPIService(node), mining_server) if config.user.mining_api_enabled: mining_server.add_insecure_port("{0}:{1}".format( config.user.mining_api_host, config.user.mining_api_port)) mining_server.start() logger.info("grpc mining service - started !") debug_server = grpc.server( ThreadPoolExecutor(max_workers=config.user.debug_api_threads), maximum_concurrent_rpcs=config.user.debug_api_max_concurrent_rpc) add_DebugAPIServicer_to_server(DebugAPIService(node), debug_server) if config.user.debug_api_enabled: debug_server.add_insecure_port("{0}:{1}".format( config.user.debug_api_host, config.user.debug_api_port)) debug_server.start() logger.info("grpc debug service - started !") return admin_server, public_server, mining_server, debug_server
def start_services(node: QRLNode): server = grpc.server(ThreadPoolExecutor(max_workers=1), maximum_concurrent_rpcs=config.user.max_peers_limit) p2p_node = P2PNode(node) add_BaseServicer_to_server(BaseService(node), server) add_P2PAPIServicer_to_server(p2p_node.service, server) add_PublicAPIServicer_to_server(PublicAPIService(node), server) server.add_insecure_port("[::]:9009") server.start() logger.debug("grpc node - started !") return server, p2p_node
def test_getTransaction(self): db_state = Mock(spec=State) db_state.get_tx_metadata = MagicMock(return_value=None) db_state.get_block = MagicMock(return_value=None) p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) # Find an address bob_xmss = get_bob_xmss() # Find a transaction alice_xmss = get_alice_xmss() db_state.address_used = MagicMock(return_value=False) tx1 = TransferTransaction.create( addrs_to=[bob_xmss.address], amounts=[125], message_data=None, fee=19, xmss_pk=bob_xmss.pk, master_addr=alice_xmss.address) chain_manager.tx_pool.transaction_pool = [(0, TransactionInfo(tx1, 0))] context = Mock(spec=ServicerContext) request = qrl_pb2.GetTransactionReq() request.tx_hash = tx1.txhash response = service.GetTransaction(request=request, context=context) context.set_code.assert_not_called() self.assertIsNotNone(response.tx) self.assertEqual('transfer', response.tx.WhichOneof('transactionType')) self.assertEqual(alice_xmss.address, response.tx.master_addr) self.assertEqual(bob_xmss.pk, response.tx.public_key) self.assertEqual(tx1.txhash, response.tx.transaction_hash) self.assertEqual(b'', response.tx.signature) self.assertEqual(bob_xmss.address, response.tx.transfer.addrs_to[0]) self.assertEqual(125, response.tx.transfer.amounts[0]) self.assertEqual(19, response.tx.fee)
def test_getStats(self): number_blocks = 1 with MockedBlockchain.create(number_blocks) as mock_blockchain: with set_timeseries_size(10): service = PublicAPIService(mock_blockchain.qrlnode) for i in range(number_blocks + 1, 50): mock_blockchain.add_new_block() request = qrl_pb2.GetStatsReq() request.include_timeseries = True stats = service.GetStats(request=request, context=None) self.assertEqual(min(10, i + 1), len(stats.block_timeseries))
def test_getStats(self): db_state = Mock(spec=State) db_state.stake_validators_tracker = StakeValidatorsTracker() db_state.total_coin_supply = MagicMock(return_value=1000) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pos = Mock() p2p_factory.pos.stake = False buffered_chain = Mock(spec=BufferedChain) buffered_chain.height = 0 buffered_chain._chain = Mock() buffered_chain._chain.blockchain = [] buffered_chain.get_block = MagicMock(return_value=None) buffered_chain.state = db_state qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) service = PublicAPIService(qrlnode) stats = service.GetStats(request=qrl_pb2.GetStatsReq, context=None) # self.assertEqual(__version__, stats.node_info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, stats.node_info.state) self.assertEqual(23, stats.node_info.num_connections) # self.assertEqual("testnet", stats.node_info.network_id) # FIXME self.assertEqual(0, stats.epoch) self.assertEqual(0, stats.uptime_network) self.assertEqual(0, stats.stakers_count) self.assertEqual(0, stats.block_last_reward) self.assertEqual(0, stats.block_time_mean) self.assertEqual(0, stats.block_time_sd) self.assertEqual(105000000, stats.coins_total_supply) self.assertEqual(1000, stats.coins_emitted) self.assertEqual(0, stats.coins_atstake) logger.info(stats)
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_getStats(self): db_state = Mock(spec=State) db_state.total_coin_supply = MagicMock(return_value=1000) db_state.get_measurement = MagicMock(return_value=60) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 chain_manager.get_last_block = MagicMock(return_value=GenesisBlock()) chain_manager.get_block_by_number = MagicMock(return_value=None) chain_manager.state = db_state qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) request = qrl_pb2.GetStatsReq() stats = service.GetStats(request=request, context=None) # self.assertEqual(__version__, stats.node_info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, stats.node_info.state) self.assertEqual(23, stats.node_info.num_connections) # self.assertEqual("testnet", stats.node_info.network_id) # FIXME self.assertEqual(0, stats.epoch) self.assertEqual(0, stats.uptime_network) self.assertEqual(65000000000000000, stats.block_last_reward) self.assertEqual(60, stats.block_time_mean) self.assertEqual(0, stats.block_time_sd) self.assertEqual(105000000, stats.coins_total_supply) self.assertEqual(1000, stats.coins_emitted) self.assertEqual(0, len(stats.block_timeseries))
def test_getOTS(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) addresses_state = {optimized_address_state.address: optimized_address_state} AddressState.put_addresses_state(db_state, addresses_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.GetOTSReq(address=alice_xmss.address) response = service.GetOTS(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(0, response.next_unused_ots_index) paginated_bitfield = PaginatedBitfield(True, db_state._db) paginated_bitfield.set_ots_key(addresses_state, optimized_address_state.address, 0) paginated_bitfield.put_addresses_bitfield(None) response = service.GetOTS(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(1, response.next_unused_ots_index)
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 test_getNodeState(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq, context=None) # self.assertEqual(__version__, node_state.info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state) self.assertEqual(23, node_state.info.num_connections)
def test_GetTokenTxn_Error(self): p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.num_connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) request = qrl_pb2.TokenTxnReq() context = Mock(spec=ServicerContext) context.set_code = MagicMock() service.GetTokenTxn(request=request, context=context) context.set_code.assert_called_with(StatusCode.INVALID_ARGUMENT)
def getStats_forking(self, timeseries_size): number_blocks = 10 with MockedBlockchain.create(number_blocks) as mock_blockchain: with set_timeseries_size(timeseries_size): service = PublicAPIService(mock_blockchain.qrlnode) request = qrl_pb2.GetStatsReq(include_timeseries=True) stats = service.GetStats(request=request, context=None) self.assertEqual(timeseries_size, len(stats.block_timeseries)) # Fork at node 9 with 2 blocks (b) block_9 = mock_blockchain.qrlnode.get_block_from_index(9) block_10 = mock_blockchain.qrlnode.get_block_last() block_10b = mock_blockchain.create_block(block_9.headerhash) mock_blockchain.add_block(block_10b) block_11b = mock_blockchain.create_block(block_10b.headerhash) mock_blockchain.add_block(block_11b) # Get time series request = qrl_pb2.GetStatsReq(include_timeseries=True) stats = service.GetStats(request=request, context=None) self.assertEqual(timeseries_size, len(stats.block_timeseries)) # check stats have moved to the correct branch self.assertEqual(block_11b.headerhash, stats.block_timeseries[-1].header_hash) # Add back to the original chain (a) block_11 = mock_blockchain.create_block(block_10.headerhash) mock_blockchain.add_block(block_11) block_12 = mock_blockchain.create_block(block_11.headerhash) mock_blockchain.add_block(block_12) # Get time series request = qrl_pb2.GetStatsReq(include_timeseries=True) stats = service.GetStats(request=request, context=None) self.assertEqual(timeseries_size, len(stats.block_timeseries)) # check stats have moved back to the correct branch self.assertEqual(block_12.headerhash, stats.block_timeseries[-1].header_hash)
def test_getNodeState(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pos = Mock() p2p_factory.pos.stake = False buffered_chain = Mock(spec=BufferedChain) buffered_chain.height = 0 qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) service = PublicAPIService(qrlnode) node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq, context=None) # self.assertEqual(__version__, node_state.info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state) self.assertEqual(23, node_state.info.num_connections)
def test_getLatestData(self): blocks = [] txs = [] for i in range(1, 4): for j in range(1, 3): txs.append( TransferTransaction.create(addr_from=qrladdress('source'), addr_to=qrladdress('dest'), amount=i * 100 + j, fee=j, xmss_pk=get_alice_xmss().pk(), xmss_ots_index=i)) blocks.append( Block.create(staking_address=qrladdress('staking_addr'), block_number=i, reveal_hash=sha256(b'reveal'), prevblock_headerhash=sha256(b'reveal'), transactions=txs, duplicate_transactions=OrderedDict(), vote=VoteMetadata(), signing_xmss=get_alice_xmss(), nonce=i)) txpool = [] for j in range(10, 15): txpool.append( TransferTransaction.create(addr_from=qrladdress('source'), addr_to=qrladdress('dest'), amount=1000 + j, fee=j, xmss_pk=get_alice_xmss().pk(), xmss_ots_index=j)) db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) buffered_chain = Mock(spec=BufferedChain) buffered_chain.tx_pool = Mock() buffered_chain.tx_pool.transaction_pool = txpool buffered_chain.get_block = Mock() buffered_chain.get_block.side_effect = blocks buffered_chain.height = len(blocks) buffered_chain._chain = Mock() buffered_chain._chain.blockchain = blocks qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) request = qrl_pb2.GetLatestDataReq(filter=qrl_pb2.GetLatestDataReq.ALL, offset=1, quantity=3) response = service.GetLatestData(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() # Verify blockheaders self.assertEqual(2, len(response.blockheaders)) self.assertEqual(1, response.blockheaders[0].header.block_number) self.assertEqual(2, response.blockheaders[1].header.block_number) # Verify transactions self.assertEqual(3, len(response.transactions)) self.assertEqual(1, response.transactions[0].transfer.fee) self.assertEqual(2, response.transactions[1].transfer.fee) self.assertEqual(1, response.transactions[2].transfer.fee) # 302 should have been skipped self.assertEqual(301, response.transactions[0].transfer.amount) self.assertEqual(202, response.transactions[1].transfer.amount) self.assertEqual(201, response.transactions[2].transfer.amount) # Verify transactions_unconfirmed self.assertEqual(3, len(response.transactions_unconfirmed)) self.assertEqual(1013, response.transactions_unconfirmed[0].transfer.amount) self.assertEqual(1012, response.transactions_unconfirmed[1].transfer.amount) self.assertEqual(1011, response.transactions_unconfirmed[2].transfer.amount)
def test_getObject(self): SOME_ODD_HASH = sha256(b'this should not be found') SOME_ADDR1 = b'Q' + sha256(b'address1') SOME_ADDR2 = b'Q' + sha256(b'address2') db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) buffered_chain = Mock(spec=BufferedChain) buffered_chain.tx_pool = Mock() buffered_chain.tx_pool.transaction_pool = [] 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.GetObjectReq() response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertFalse(response.found) # Find an address db_state.get_address = MagicMock(return_value=AddressState.create( address=SOME_ADDR1, 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')]) context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = SOME_ODD_HASH response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertFalse(response.found) context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = SOME_ADDR1 response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.address_state) self.assertEqual(SOME_ADDR1, response.address_state.address) self.assertEqual(25, response.address_state.nonce) self.assertEqual(10, response.address_state.balance) self.assertEqual([sha256(b'a'), sha256(b'b')], response.address_state.pubhashes) self.assertEqual([sha256(b'0'), sha256(b'1')], response.address_state.transaction_hashes) # Find a transaction db_state.address_used = MagicMock(return_value=False) tx1 = TransferTransaction.create(addr_from=SOME_ADDR1, addr_to=SOME_ADDR2, amount=125, fee=19, xmss_pk=sha256(b'pk'), xmss_ots_index=13) buffered_chain.tx_pool.transaction_pool = [tx1] context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = tx1.txhash response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.transaction) self.assertEqual(qrl_pb2.Transaction.TRANSFER, response.transaction.type) self.assertEqual(SOME_ADDR1, response.transaction.addr_from) self.assertEqual(sha256(b'pk'), response.transaction.public_key) self.assertEqual(tx1.txhash, response.transaction.transaction_hash) self.assertEqual(13, response.transaction.ots_key) self.assertEqual(b'', response.transaction.signature) self.assertEqual(SOME_ADDR2, response.transaction.transfer.addr_to) self.assertEqual(125, response.transaction.transfer.amount) self.assertEqual(19, response.transaction.transfer.fee) # Find a block buffered_chain.get_block = MagicMock(return_value=Block.create( staking_address=qrladdress('staking_addr'), block_number=1, reveal_hash=sha256(b'reveal'), prevblock_headerhash=sha256(b'reveal'), transactions=[], duplicate_transactions=OrderedDict(), vote=VoteMetadata(), signing_xmss=get_alice_xmss(), nonce=1)) context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = bytes(str2bin('1')) response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.block) self.assertEqual(1, response.block.header.block_number)