예제 #1
0
    def test_ots_key_reuse(self, mock_ots_bitfield_size, mock_ots_tracking_per_page):
        """
        Randomly using OTS key
        :return:
        """
        with set_qrl_dir('no_data'):
            state = State()

            mock_ots_bitfield_size.return_value = ceil(config.dev.ots_tracking_per_page / 8)
            paginated_bitfield = PaginatedBitfield(True, state._db)

            alice_xmss = get_alice_xmss(12)
            address = alice_xmss.address
            address_state = OptimizedAddressState.get_default(address)
            addresses_state = {address: address_state}
            bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
            self.assertFalse(paginated_bitfield.ots_key_reuse(bitfield_data, 0))

            paginated_bitfield.set_ots_key(addresses_state, address, 0)
            bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
            # False, as bitfield has been set but has not been written to state.
            self.assertFalse(paginated_bitfield.ots_key_reuse(bitfield_data, 0))

            # Writing bitfield to the state.
            paginated_bitfield.put_addresses_bitfield(None)
            bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
            self.assertTrue(paginated_bitfield.ots_key_reuse(bitfield_data, 0))
예제 #2
0
    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)