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_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_validate_signature(self): xmss = get_alice_xmss() xmss2 = get_alice_xmss(8) pk = xmss.pk signature = xmss.sign(b"hello") self.assertTrue(XMSS.validate_signature(signature, pk)) with self.assertRaises(ValueError): XMSS.validate_signature(signature, None) self.assertFalse(XMSS.validate_signature(signature, xmss2.pk))
def __init__(self, *args, **kwargs): super(TestMultiSigSpend, self).__init__(*args, **kwargs) with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() self.random = get_alice_xmss(4) self.random_signer = get_bob_xmss(4) self.signatories = [ self.alice.address, self.bob.address, self.random.address ] self.weights = [20, 30, 10] self.threshold = 30
def test_relay_slave_txn(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() qaddress = walletd.add_new_address(height=4) walletd.encrypt_wallet(self.passphrase) walletd.unlock_wallet(self.passphrase) alice_xmss = get_alice_xmss(4) slave_pks = [alice_xmss.pk] access_types = [0] walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp( error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) tx = walletd.relay_slave_txn(slave_pks=slave_pks, access_types=access_types, fee=100000000, master_qaddress=None, signer_address=qaddress, ots_index=0) self.assertIsNotNone(tx) walletd.lock_wallet() with self.assertRaises(ValueError): walletd.relay_slave_txn(slave_pks=slave_pks, access_types=access_types, fee=100000000, master_qaddress=None, signer_address=qaddress, ots_index=0)
def test_relay_transfer_token_txn(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() qaddress = walletd.add_new_address(height=4) walletd.encrypt_wallet(self.passphrase) walletd.unlock_wallet(self.passphrase) alice_xmss = get_alice_xmss(4) bob_xmss = get_bob_xmss(4) qaddresses_to = [alice_xmss.qaddress, bob_xmss.qaddress] amounts = [1000000000, 1000000000] walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp( error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) tx = walletd.relay_transfer_token_txn(qaddresses_to=qaddresses_to, amounts=amounts, token_txhash='', fee=100000000, master_qaddress=None, signer_address=qaddress, ots_index=0) self.assertIsNotNone(tx) walletd.lock_wallet() with self.assertRaises(ValueError): walletd.relay_transfer_token_txn(qaddresses_to=qaddresses_to, amounts=amounts, token_txhash='', fee=100000000, master_qaddress=None, signer_address=qaddress, ots_index=0)
def test_getBlock(self): with set_xrd_dir('no_data'): db_state = State() p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._pow = p2p_factory.pow xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) 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 = xrd_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_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) 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 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.GetHeightReq() response = service.GetHeight(request=request, context=context) self.assertEqual(response.height, 100)
def test_put_multi_sig_addresses_state(self): alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() random_xmss = get_random_xmss() signatories = [alice_xmss.address, bob_xmss.address] weights = [20, 20] threshold = 21 multi_sig_tx = MultiSigCreate.create(signatories, weights, threshold, 0, random_xmss.pk) multi_sig_tx.sign(random_xmss) multi_sig_address_state = MultiSigAddressState.get_default( multi_sig_tx.txhash, signatories, weights, threshold) multi_sig_addresses_state = { multi_sig_address_state.address: multi_sig_address_state } AddressState.put_addresses_state(self.state, multi_sig_addresses_state) multi_sig_address_state2 = MultiSigAddressState.get_multi_sig_address_state_by_address( self.state._db, MultiSigAddressState.generate_multi_sig_address( multi_sig_tx.txhash)) self.assertEqual(multi_sig_address_state.pbdata, multi_sig_address_state2.pbdata)
def test_relaySlaveTxn(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address alice_xmss = get_alice_xmss(4) slave_pks = [alice_xmss.pk] access_types = [0] walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp( error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) resp = service.RelaySlaveTxn(qrlwallet_pb2.RelaySlaveTxnReq( slave_pks=slave_pks, access_types=access_types, fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_sync_state_change_synced(self): chain_manager = Mock() chain_manager.height = 0 chain_manager.get_block = MagicMock(return_value=GenesisBlock()) chain_manager.last_block = GenesisBlock() chain_manager.tx_pool = Mock() chain_manager.tx_pool.transaction_pool = [] get_block_metadata_response = Mock() get_block_metadata_response.block_difficulty = StringToUInt256('2') chain_manager.state.get_block_metadata = MagicMock(return_value=get_block_metadata_response) alice_xmss = get_alice_xmss() chain_manager.state.get_address = MagicMock(return_value=AddressState.get_default(alice_xmss.get_address())) chain_manager.state.get_measurement = MagicMock(return_value=60) p2p_factory = Mock() sync_state = Mock() time_provider = Mock() node = POW(chain_manager=chain_manager, p2p_factory=p2p_factory, sync_state=sync_state, time_provider=time_provider, slaves=get_random_master()) self.assertIsNotNone(node) node.update_node_state(ESyncState.synced)
def test_relayTokenTxn(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address alice_xmss = get_alice_xmss(4) bob_xmss = get_bob_xmss(4) qaddresses = [alice_xmss.qaddress, bob_xmss.qaddress] amounts = [1000000000, 1000000000] walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp( error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) resp = service.RelayTokenTxn(qrlwallet_pb2.RelayTokenTxnReq( symbol=b'QRL', name=b'Quantum Resistant Ledger', owner=alice_xmss.qaddress, decimals=5, addresses=qaddresses, amounts=amounts, fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_prepare_address_list(self): with set_qrl_dir('no_data'): with State() as state: block = Block.create(block_number=10, prev_headerhash=b'', prev_timestamp=10, transactions=[], miner_address=get_some_address(1)) # Test Case: without any transactions of block self.assertEqual(state.prepare_address_list(block), {config.dev.coinbase_address, get_some_address(1)}) alice_xmss = get_alice_xmss() block = Block.create(block_number=10, prev_headerhash=b'', prev_timestamp=10, transactions=[TransferTransaction.create(addrs_to=[get_some_address(2), get_some_address(3)], amounts=[100, 100], fee=0, xmss_pk=alice_xmss.pk)], miner_address=get_some_address(1)) # Test Case, with one Transaction self.assertEqual(state.prepare_address_list(block), {config.dev.coinbase_address, get_some_address(1), get_some_address(2), get_some_address(3), alice_xmss.address})
def test_add_vote2(self): validator_xmss1 = get_alice_xmss() slave_xmss1 = XMSS(validator_xmss1.height, validator_xmss1.get_seed()) stake_amount1 = 101.5012 headerhash1 = b'ffff' vote1 = Vote.create(addr_from=validator_xmss1.get_address().encode(), blocknumber=0, headerhash=headerhash1, xmss=slave_xmss1) vote1.sign(slave_xmss1) vote_metadata = VoteMetadata() vote_metadata.add_vote(vote=vote1, stake_amount=stake_amount1) self.assertIn(vote1.txfrom, vote_metadata.stake_validator_vote) validator_xmss2 = get_random_xmss() slave_xmss2 = XMSS(validator_xmss2.height, validator_xmss2.get_seed()) stake_amount2 = 10000 headerhash2 = b'ffff' vote2 = Vote.create(addr_from=validator_xmss2.get_address().encode(), blocknumber=0, headerhash=headerhash2, xmss=slave_xmss2) vote2.sign(slave_xmss2) vote_metadata.add_vote(vote=vote2, stake_amount=stake_amount2) self.assertIn(vote2.txfrom, vote_metadata.stake_validator_vote) total_stake_amount = stake_amount1 + stake_amount2 self.assertEqual(total_stake_amount, vote_metadata.total_stake_amount)
def test_get_all_address_state(self): with set_qrl_dir('no_data'): with State() as state: addresses_state = state.get_all_address_state() self.assertEqual(len(addresses_state), 0) alice_xmss = get_alice_xmss() alice_address = alice_xmss.address address_state = state.get_address_state(alice_address) addresses_state = { alice_address: address_state } self.assertTrue(isinstance(address_state.address, bytes)) state.put_addresses_state(addresses_state) addresses_state = state.get_all_address_state() self.assertEqual(len(addresses_state), 1) bob_xmss = get_bob_xmss() bob_address = bob_xmss.address address_state = state.get_address_state(bob_address) addresses_state = { bob_address: address_state } self.assertTrue(isinstance(address_state.address, bytes)) state.put_addresses_state(addresses_state) addresses_state = state.get_all_address_state() self.assertEqual(len(addresses_state), 2)
def test_sync_state_change_synced(self): chain_manager = Mock() chain_manager.height = 0 chain_manager.get_block = MagicMock(return_value=GenesisBlock()) chain_manager.last_block = GenesisBlock() chain_manager.tx_pool = Mock() chain_manager.tx_pool.transaction_pool = [] get_block_metadata_response = Mock() get_block_metadata_response.block_difficulty = StringToUInt256('2') chain_manager.state.get_block_metadata = MagicMock(return_value=get_block_metadata_response) alice_xmss = get_alice_xmss() chain_manager.state.get_address = MagicMock(return_value=AddressState.get_default(alice_xmss.address)) chain_manager.state.get_measurement = MagicMock(return_value=60) p2p_factory = Mock() sync_state = Mock() time_provider = Mock() node = POW(chain_manager=chain_manager, p2p_factory=p2p_factory, sync_state=sync_state, time_provider=time_provider, slaves=get_random_master(), mining_thread_count=0) self.assertIsNotNone(node) node.update_node_state(ESyncState.synced)
def test_relayTransferTokenTxn(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address alice_xmss = get_alice_xmss(4) bob_xmss = get_bob_xmss(4) qaddresses_to = [alice_xmss.qaddress, bob_xmss.qaddress] amounts = [1000000000, 1000000000] walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp( error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) resp = service.RelayTransferTokenTxn( qrlwallet_pb2.RelayTransferTokenTxnReq( addresses_to=qaddresses_to, amounts=amounts, token_txhash='', fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_update_used_page_in_address_state4(self, mock_ots_bitfield_size, mock_ots_tracking_per_page): mock_ots_bitfield_size.return_value = ceil(config.dev.ots_tracking_per_page / 8) alice_xmss = get_alice_xmss(12) address = alice_xmss.address address_state = OptimizedAddressState.get_default(address) addresses_state = {address: address_state} paginated_bitfield = PaginatedBitfield(True, self.state._db) paginated_bitfield.update_used_page_in_address_state(address, addresses_state, 1) self.assertEqual(address_state.ots_bitfield_used_page, 0) for i in range(2048, 3072): paginated_bitfield.set_ots_key(addresses_state, address, i) self.assertEqual(address_state.ots_bitfield_used_page, 0) for i in range(1024, 2048): paginated_bitfield.set_ots_key(addresses_state, address, i) self.assertEqual(address_state.ots_bitfield_used_page, 0) for i in range(0, 1024): paginated_bitfield.set_ots_key(addresses_state, address, i) if i + 1 == 1024: self.assertEqual(address_state.ots_bitfield_used_page, 3) for i in range(3072, 2 ** alice_xmss.height): paginated_bitfield.set_ots_key(addresses_state, address, i) if i + 1 == 2 ** alice_xmss.height: self.assertEqual(address_state.ots_bitfield_used_page, 4) else: self.assertEqual(address_state.ots_bitfield_used_page, 3) self.assertEqual(address_state.ots_bitfield_used_page, 4)
def test_update_used_page_in_address_state(self): alice_xmss = get_alice_xmss(4) address = alice_xmss.address address_state = OptimizedAddressState.get_default(address) addresses_state = {address: address_state} paginated_bitfield = PaginatedBitfield(True, self.state._db) key = paginated_bitfield.generate_bitfield_key(address, 1) paginated_bitfield.update_used_page_in_address_state(address, addresses_state, 1) self.assertEqual(address_state.ots_bitfield_used_page, 0) for i in range(0, 16): paginated_bitfield.set_ots_key(addresses_state, address, i) if i != 15: self.assertEqual(address_state.ots_bitfield_used_page, 0) else: self.assertEqual(address_state.ots_bitfield_used_page, 1) for i in range(0, 16): ots_bitfield = paginated_bitfield.key_value[key] ots_key_index = i % config.dev.ots_tracking_per_page offset = ots_key_index >> 3 relative = ots_key_index % 8 bitfield = bytearray(ots_bitfield[offset]) self.assertEqual(bytes([bitfield[0] >> relative & 1]), b'\x01') self.assertEqual(address_state.ots_bitfield_used_page, 1)
def test_get_block_size_limit(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) self.assertEqual(state.get_block_size_limit(blocks[-1]), 1048576)
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))
def test_set_ots_key2(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) alice_xmss = get_alice_xmss(12) address = alice_xmss.address address_state = OptimizedAddressState.get_default(address) addresses_state = {address: address_state} paginated_bitfield = PaginatedBitfield(True, state._db) paginated_bitfield.update_used_page_in_address_state(address, addresses_state, 1) self.assertEqual(address_state.ots_bitfield_used_page, 0) ots_indexes = list(range(0, 2**alice_xmss.height)) random.shuffle(ots_indexes) for i in ots_indexes: paginated_bitfield.set_ots_key(addresses_state, address, i) if i == ots_indexes[-1]: self.assertEqual(address_state.ots_bitfield_used_page, 4) self.assertEqual(address_state.ots_bitfield_used_page, 4)
def test_remove_transfer_token_metadata(self): alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() token_transaction = get_token_transaction(alice_xmss, bob_xmss) TokenMetadata.create_token_metadata(self.state, token_transaction, None) transfer_token = TransferTokenTransaction.create( token_txhash=token_transaction.txhash, addrs_to=[alice_xmss.address], amounts=[100000000], fee=1, xmss_pk=bob_xmss.pk) transfer_token.sign(alice_xmss) TokenMetadata.update_token_metadata(self.state, transfer_token, None) token_metadata = TokenMetadata.get_token_metadata( self.state, transfer_token.token_txhash) self.assertIn(transfer_token.txhash, token_metadata.transfer_token_tx_hashes) TokenMetadata.remove_transfer_token_metadata(self.state, transfer_token, None) token_metadata = TokenMetadata.get_token_metadata( self.state, transfer_token.token_txhash) self.assertNotIn(transfer_token.txhash, token_metadata.transfer_token_tx_hashes)
def test_remove_transfer_token_metadata(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() token_transaction = get_token_transaction(alice_xmss, bob_xmss) state.create_token_metadata(token_transaction) transfer_token = TransferTokenTransaction.create(token_txhash=token_transaction.txhash, addrs_to=[alice_xmss.address], amounts=[100000000], fee=1, xmss_pk=bob_xmss.pk) transfer_token.sign(alice_xmss) state.update_token_metadata(transfer_token) token_metadata = state.get_token_metadata(transfer_token.token_txhash) self.assertIn(transfer_token.txhash, token_metadata.transfer_token_tx_hashes) state.remove_transfer_token_metadata(transfer_token) token_metadata = state.get_token_metadata(transfer_token.token_txhash) self.assertNotIn(transfer_token.txhash, token_metadata.transfer_token_tx_hashes)
def test_state_object(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) self.assertEqual(state.state_objects.total_coin_supply(), 0) self.assertEqual(state.state_objects.state_loaders, []) state.state_objects.append_state_loader(StateLoader(b'current_', state._db)) self.assertIsNotNone(state.state_objects.get_state_loader_by_index(0)) state.state_objects.destroy_state_loader(0) self.assertEqual(state.state_objects.state_loaders, []) self.assertIsNone(state.state_objects.get(b'current')) state.state_objects.push(blocks[-1].headerhash, None) self.assertEqual(len(state.state_objects.state_loaders), 1) loader = state.state_objects.state_loaders[0] loader.increase_txn_count(state._db, b'', 0, alice_xmss.address) self.assertEqual(loader.get_txn_count(state._db, b'', alice_xmss.address), 1) self.assertEqual(loader.get_last_txs(state._db, b''), []) loader.commit(StateLoader(b'current_', state._db)) loader.update_last_tx(blocks[-1], None) loader.commit(StateLoader(b'current_', state._db)) state.state_objects.update_current_state({alice_xmss.address: state._get_address_state(alice_xmss.address)}) self.assertEqual(state.state_objects.get_txn_count(alice_xmss.address), 1) state.state_objects.increase_txn_count(alice_xmss.address) self.assertEqual(state.state_objects.get_last_txs(), []) state.state_objects.update_last_tx(blocks[-1], None) state.state_objects.update_tx_metadata(blocks[-1], None) self.assertEqual(state.state_objects.get_last_txs(), []) state.state_objects.destroy_fork_states(blocks[-1].block_number, blocks[-1].headerhash) state.state_objects.destroy_current_state(None) self.assertIsNone(state.state_objects.get(b'current'))
def test_validate_transaction_pool_reusing_ots_index(self, m_logger): """ Two different TransferTransactions. They are signed with the same OTS indexe, from the same public key. Therefore they should conflict. :return: """ tx = self.tx tx2 = TransferTransaction.create(addrs_to=[self.bob.address], amounts=[100], message_data=None, fee=5, xmss_pk=self.alice.pk) # alice_clone's OTS index is still at 10, while self.alice will be at 11 after signing. alice_clone = get_alice_xmss() alice_clone.set_ots_index(10) tx.sign(self.alice) tx2.sign(alice_clone) tx_info = Mock(autospec=TransactionInfo, transaction=tx) tx2_info = Mock(autospec=TransactionInfo, transaction=tx2) transaction_pool = [(replacement_getTime(), tx_info), (replacement_getTime(), tx2_info)] result = tx.validate_transaction_pool(transaction_pool) self.assertFalse(result)
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 __init__(self, *args, **kwargs): super(TestMessageTransaction, self).__init__(*args, **kwargs) self.alice = get_alice_xmss() self.bob = get_bob_xmss() self.alice.set_ots_index(10) self.maxDiff = None
def test_create(self): alice_xmss = get_alice_xmss() slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed()) staking_address = bytes(alice_xmss.get_address().encode()) h0 = sha256(b'hashchain_seed') h1 = sha256(h0) h2 = sha256(h1) stake_transaction = StakeTransaction.create(activation_blocknumber=0, xmss=alice_xmss, slavePK=slave_xmss.pk(), hashchain_terminator=h2) sv = StakeValidator(100, stake_transaction) self.assertEqual(staking_address, sv.address) self.assertEqual(slave_xmss.pk(), sv.slave_public_key) self.assertEqual(h2, sv.terminator_hash) self.assertEqual(100, sv.balance) self.assertEqual(0, sv.nonce) self.assertFalse(sv.is_banned) self.assertTrue(sv.is_active)
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_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_get_address2(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = alice_xmss.get_address() address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes)) state._save_address_state(address_state) address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes))
def test_create_token_metadata(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() token_transaction = get_token_transaction(alice_xmss, bob_xmss) state.create_token_metadata(token_transaction) token_metadata = state.get_token_metadata(token_transaction.txhash) self.assertEqual(token_metadata.token_txhash, token_transaction.txhash) self.assertEqual(token_metadata.transfer_token_tx_hashes[0], token_transaction.txhash)
def test_get_address(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = alice_xmss.get_address() address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes)) alice_address = bytearray(alice_xmss.get_address()) with self.assertRaises(TypeError): address_state = state.get_address(alice_address) alice_address = alice_xmss.get_address() address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes)) state._save_address_state(address_state) address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes))
def test_update_token_metadata(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() token_transaction = get_token_transaction(alice_xmss, bob_xmss) state.create_token_metadata(token_transaction) transfer_token_transaction = TransferTokenTransaction.create(addr_from=bob_xmss.get_address(), token_txhash=token_transaction.txhash, addr_to=alice_xmss.get_address(), amount=100000000, fee=1, xmss_pk=bob_xmss.pk(), xmss_ots_index=bob_xmss.get_index()) state.update_token_metadata(transfer_token_transaction) token_metadata = state.get_token_metadata(token_transaction.txhash) self.assertEqual(len(token_metadata.transfer_token_tx_hashes), 2) self.assertEqual(token_metadata.transfer_token_tx_hashes[0], token_transaction.txhash) self.assertEqual(token_metadata.transfer_token_tx_hashes[1], transfer_token_transaction.txhash)
def test_orphan_block(self): """ Testing add_block logic in case of orphan_blocks :return: """ with mock.patch('qrl.core.config.DevConfig') as devconfig: devconfig.genesis_difficulty = 2 devconfig.minimum_minting_delay = 10 with set_data_dir('no_data'): with State() as state: # FIXME: Move state to temporary directory state.get_measurement = MagicMock(return_value=10000000) genesis_block = GenesisBlock() chain_manager = ChainManager(state) chain_manager.load(genesis_block) chain_manager._difficulty_tracker = Mock() dt = DifficultyTracker() tmp_difficulty = StringToUInt256('2') tmp_boundary = dt.get_boundary(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_boundary)) block = state.get_block(genesis_block.headerhash) self.assertIsNotNone(block) alice_xmss = get_alice_xmss() with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1615270948 # Very high to get an easy difficulty block_1 = Block.create(mining_nonce=10, block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[], signing_xmss=alice_xmss, master_address=alice_xmss.get_address(), nonce=1) block_1.set_mining_nonce(10) while not chain_manager.validate_mining_nonce(block_1, False): block_1.set_mining_nonce(block_1.mining_nonce + 1) result = chain_manager.add_block(block_1) self.assertTrue(result) self.assertEqual(chain_manager.last_block, block_1) bob_xmss = get_bob_xmss() with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 2 block = Block.create(mining_nonce=18, block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[], signing_xmss=bob_xmss, master_address=bob_xmss.get_address(), nonce=1) block.set_mining_nonce(18) while not chain_manager.validate_mining_nonce(block, False): block.set_mining_nonce(block.mining_nonce + 1) with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 3 block_2 = Block.create(mining_nonce=17, block_number=2, prevblock_headerhash=block.headerhash, transactions=[], signing_xmss=bob_xmss, master_address=bob_xmss.get_address(), nonce=2) block_2.set_mining_nonce(17) result = chain_manager.add_block(block_2) self.assertTrue(result) result = chain_manager.add_block(block) self.assertTrue(result) block = state.get_block(block.headerhash) self.assertIsNotNone(block) self.assertEqual(chain_manager.last_block.block_number, block_1.block_number) self.assertEqual(chain_manager.last_block.headerhash, block_1.headerhash)
def test_add_block(self): """ Testing add_block, with fork logic :return: """ with set_data_dir('no_data'): with State() as state: state.get_measurement = MagicMock(return_value=10000000) alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() genesis_block = GenesisBlock() chain_manager = ChainManager(state) chain_manager.load(genesis_block) chain_manager._difficulty_tracker = Mock() dt = DifficultyTracker() tmp_difficulty = StringToUInt256('2') tmp_boundary = dt.get_boundary(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_boundary)) block = state.get_block(genesis_block.headerhash) self.assertIsNotNone(block) slave_tx = SlaveTransaction.create(addr_from=alice_xmss.get_address(), slave_pks=[bob_xmss.pk()], access_types=[0], fee=0, xmss_pk=alice_xmss.pk(), xmss_ots_index=alice_xmss.get_index()) slave_tx.sign(alice_xmss) slave_tx._data.nonce = 2 self.assertTrue(slave_tx.validate()) with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1615270948 # Very high to get an easy difficulty block_1 = Block.create(mining_nonce=10, block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[slave_tx], signing_xmss=alice_xmss, master_address=alice_xmss.get_address(), nonce=1) while not chain_manager.validate_mining_nonce(block_1, False): block_1.set_mining_nonce(block_1.mining_nonce + 1) result = chain_manager.add_block(block_1) self.assertTrue(result) self.assertEqual(chain_manager.last_block, block_1) alice_state = chain_manager.get_address(alice_xmss.get_address()) self.assertEqual(len(alice_state.slave_pks_access_type), 1) self.assertTrue(str(bob_xmss.pk()) in alice_state.slave_pks_access_type) with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1715270948 # Very high to get an easy difficulty block = Block.create(mining_nonce=15, block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[], signing_xmss=bob_xmss, master_address=bob_xmss.get_address(), nonce=1) while not chain_manager.validate_mining_nonce(block, False): block.set_mining_nonce(block.mining_nonce + 1) result = chain_manager.add_block(block) self.assertTrue(result) self.assertEqual(chain_manager.last_block, block_1) block = state.get_block(block.headerhash) self.assertIsNotNone(block) with mock.patch('qrl.core.misc.ntp.getTime') as time_mock: time_mock.return_value = 1815270948 # Very high to get an easy difficulty block_2 = Block.create(mining_nonce=15, block_number=2, prevblock_headerhash=block.headerhash, transactions=[], signing_xmss=bob_xmss, master_address=bob_xmss.get_address(), nonce=2) while not chain_manager.validate_mining_nonce(block_2, False): block_2.set_mining_nonce(block_2.mining_nonce + 1) result = chain_manager.add_block(block_2) self.assertTrue(result) self.assertEqual(chain_manager.last_block.block_number, block_2.block_number) self.assertEqual(chain_manager.last_block.to_json(), block_2.to_json())