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 rollback_tx_metadata(state: State, block, batch): fee_reward = 0 for protobuf_txn in block.transactions: txn = Transaction.from_pbdata(protobuf_txn) fee_reward += txn.fee TransactionMetadata.remove_tx_metadata(state, txn, batch) txn = Transaction.from_pbdata( block.transactions[0]) # Coinbase Transaction state._update_total_coin_supply(fee_reward - txn.amount, batch) LastTransactions._remove_last_tx(state, block, batch)
def state_migration_step_1(self, state: State) -> bool: """ Migration Step from State Version 0 to 1 :return: """ if state.is_older_state_version(): db_dir_v1 = os.path.join(config.user.data_dir, config.dev.db_name + '2') self._tmp_state = State(state._db) # DB Pointing to Older State state._db = db.DB(db_dir_v1) # DB Pointing to Newer State return True return False
def setUp(self): with set_xrd_dir('no_data'): self.state = State() self.chain_manager = ChainManager(self.state) self.alice = get_alice_xmss() self.bob = get_bob_xmss() self.slave = get_slave_xmss() self.tx1 = TransferTransaction.create(addrs_to=[self.bob.address], amounts=[10], message_data=None, fee=1, xmss_pk=self.alice.pk) self.tx2 = TransferTransaction.create(addrs_to=[self.bob.address], amounts=[10], message_data=None, fee=1, xmss_pk=self.slave.pk, master_addr=self.alice.address) self.tx1._data.nonce = 3 self.tx2._data.nonce = 6 self.tx1.sign(self.alice) self.tx2.sign(self.slave) self.block_attrs = { "dev_config": config.dev, "block_number": 5, "prev_headerhash": bytes(sha2_256(b'test')), "prev_timestamp": 10, "transactions": [self.tx1, self.tx2], "miner_address": self.alice.address, "seed_height": 0, "seed_hash": None, } self.coinbase_addrstate_attrs = OptimizedAddressState.get_default( config.dev.coinbase_address) self.coinbase_addrstate_attrs.update_balance( None, int(config.dev.coin_remaining_at_genesis * config.dev.shor_per_quanta)) self.bob_addrstate_attrs = OptimizedAddressState.get_default( self.bob.address) self.bob_addrstate_attrs.update_balance(None, 20) self.alice_addrstate_attrs = OptimizedAddressState.get_default( self.alice.address) self.alice_addrstate_attrs.update_balance(None, 100) self.alice_addrstate_attrs.pbdata.nonce = 2 self.slave_addrstate_attrs = OptimizedAddressState.get_default( self.slave.address) self.slave_addrstate_attrs.pbdata.nonce = 5
def test_insert(self): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) p.insert(OptimizedAddressState.get_default(b'a'), b'10') self.assertEqual(p.get_value(b'a', 0), [b'10'])
def update_tx_metadata(state: State, block, batch) -> bool: fee_reward = 0 for protobuf_txn in block.transactions: txn = Transaction.from_pbdata(protobuf_txn) fee_reward += txn.fee if not TransactionMetadata.put_tx_metadata( state, txn, block.block_number, block.timestamp, batch): return False txn = Transaction.from_pbdata( block.transactions[0]) # Coinbase Transaction state._update_total_coin_supply(txn.amount - fee_reward, batch) LastTransactions._update_last_tx(state, block, batch) return True
def setUp(self): with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() alice_address_state = OptimizedAddressState.get_default( self.alice.address) alice_address_state.pbdata.balance = 100 self.addresses_state = { self.alice.address: alice_address_state, self.bob.address: OptimizedAddressState.get_default(self.bob.address) } self.params = { "token_txhash": b'I declare the TEST token', "addrs_to": [self.bob.address], "amounts": [100], "fee": 1, "xmss_pk": self.alice.pk } self.unused_chain_manager_mock = Mock(autospec=ChainManager, name='unused ChainManager')
def setUp(self): # You have to set_xrd_dir to an empty one, otherwise State will have some Transactions from disk with set_xrd_dir('no_data'): self.db_state = State() self.chainmanager = ChainManager(self.db_state) self.xrdnode = xrdNode(mining_address=b'') self.xrdnode.set_chain_manager(self.chainmanager)
def setUp(self): with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() alice_address_state = OptimizedAddressState.get_default( self.alice.address) alice_address_state.pbdata.balance = 100 self.addresses_state = { self.alice.address: alice_address_state, self.bob.address: OptimizedAddressState.get_default(self.bob.address) } self.params = { "symbol": b'xrd', "name": b'Quantum Resistant Ledger', "owner": self.alice.address, "decimals": 15, "initial_balances": [], "fee": 1, "xmss_pk": self.alice.pk } self.unused_chain_manager_mock = Mock(autospec=ChainManager, name='unused ChainManager')
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_revert_paginated_data2(self, mock_dev_config): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) alice_address_state = OptimizedAddressState.get_default( address=self.alice.address) for i in range(0, 25): p.insert( alice_address_state, b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) p.put_paginated_data(None) full_hash = [] for i in range(0, (25 // config.dev.data_per_page) + 1): data = p.get_paginated_data( self.alice.address, (i + 1) * config.dev.data_per_page - 1) full_hash.extend(data) for tx_hash in full_hash[-1::-1]: p.remove(alice_address_state, tx_hash) p.put_paginated_data(None) self.assertEqual( alice_address_state.get_counter_by_name(b'p_tx_hash'), 0) self.assertEqual( len(p.get_paginated_data(alice_address_state.address, 22)), 0) self.assertEqual( len(p.get_paginated_data(alice_address_state.address, 12)), 0) self.assertEqual( len(p.get_paginated_data(alice_address_state.address, 2)), 0)
def test_ots_key_reuse(self, mock_ots_bitfield_size, mock_ots_tracking_per_page): """ Randomly using OTS key :return: """ with set_xrd_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_get_value(self): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) storage_key = p.generate_key(b'a', 0) p.key_value[storage_key] = [10] self.assertEqual(p.get_value(b'a', 0), [10])
def test_get_paginated_data(self, mock_dev_config): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) alice_address_state = OptimizedAddressState.get_default( address=self.alice.address) total_hashes = 25 expected_full_hash = [] for i in range(0, total_hashes): tx_hash = b'p_tx_hash_' + i.to_bytes( 8, byteorder='big', signed=False) p.insert(alice_address_state, tx_hash) expected_full_hash.append(tx_hash) p.put_paginated_data(None) found_full_hash = [] expected_data_count = [10, 10, 5] for i in range(0, (total_hashes // config.dev.data_per_page) + 1): data = p.get_paginated_data( self.alice.address, (i + 1) * config.dev.data_per_page - 1) self.assertEqual(len(data), expected_data_count[i]) found_full_hash.extend(data) self.assertEqual(expected_full_hash, found_full_hash)
def test_set_ots_key2(self, mock_ots_bitfield_size, mock_ots_tracking_per_page): """ Randomly using OTS key :return: """ with set_xrd_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 setUp(self): with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() self.alice.set_ots_index(10) self.maxDiff = None
def test_put(self, mock_dev_config): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) key = b'test_key' value = [b'hello world'] storage_key = p.generate_key(key, 11) p.put(storage_key, value, None) found_value = p.get_paginated_data(key, 11) self.assertEqual(value, found_value)
def __init__(self, *args, **kwargs): super(TestTokenTransaction, self).__init__(*args, **kwargs) with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() self._decimals = 15 self.alice.set_ots_index(10) self.maxDiff = None
def test_generate_bitfield_key(self): with set_xrd_dir('no_data'): state = State() paginated_bitfield = PaginatedBitfield(True, state._db) address = b'addr1' page = 1 expected_key = b'bitfield_' + address + b'_' + page.to_bytes( 8, byteorder='big', signed=False) found_key = paginated_bitfield.generate_bitfield_key(address, page) self.assertEqual(expected_key, found_key)
def test_put_paginated_data(self, mock_dev_config): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) alice_address_state = OptimizedAddressState.get_default( address=self.alice.address) for i in range(0, 10): p.insert( alice_address_state, b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual( alice_address_state.get_counter_by_name(p.name), i + 1) p.put_paginated_data(None) self.assertEqual(alice_address_state.get_counter_by_name(p.name), 10) for i in range(10, 25): p.insert( alice_address_state, b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual( alice_address_state.get_counter_by_name(p.name), i + 1) p.put_paginated_data(None) self.assertEqual(alice_address_state.get_counter_by_name(p.name), 25) self.assertEqual(len(p.key_value), 0) pages_data = [] for i in range(0, (25 // config.dev.data_per_page) + 1): data = p.get_paginated_data( self.alice.address, (i + 1) * config.dev.data_per_page - 1) pages_data.append(data) self.assertEqual(len(pages_data), 3) self.assertEqual(len(pages_data[0]), 10) for i in range(0, 10): self.assertEqual( pages_data[0][i], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual(len(pages_data[1]), 10) for i in range(10, 20): self.assertEqual( pages_data[1][i - 10], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual(len(pages_data[2]), 5) for i in range(20, 25): self.assertEqual( pages_data[2][i - 20], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False))
def test_reset_key_value(self): with set_xrd_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) self.assertEqual(len(p.key_value), 0) p.key_value[b'a'] = [10] self.assertEqual(len(p.key_value), 1) p.reset_key_value() self.assertEqual(len(p.key_value), 0)
def test_transferCoins_push_unsigned(self): with set_xrd_dir('wallet_ver1'): with State() as db_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) context = Mock(spec=ServicerContext) alice = get_alice_xmss() bob = get_bob_xmss() request = xrd_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 = xrd_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(xrd_pb2.PushTransactionResp.VALIDATION_FAILED, resp_push.error_code)
def test_check_mock(self): with set_xrd_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) state.get_block = Mock() state.get_block.side_effect = self.get_block_list_example1() block = state.get_block(b'0') self.assertEqual(10, block.timestamp) self.assertEqual(0, block.block_number) self.assertEqual(b'0', block.headerhash)
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_measurement_1(self, mock_get_block): with set_xrd_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) chain_manager = ChainManager(state) mock_get_block.side_effect = TestStateMeasurement.get_block_example1 parent_metadata = Mock() parent_metadata.last_N_headerhashes = [b'0'] measurement = chain_manager.get_measurement(config.dev, 210, b'1', parent_metadata) self.assertEqual(55, measurement) measurement = chain_manager.get_measurement(config.dev, 250, b'1', parent_metadata) self.assertEqual(75, measurement)
def test_unset_ots_key3(self, mock_ots_bitfield_size, mock_ots_tracking_per_page): """ Features Tested - Sequentially marking OTS indexes as used - Sequentially marking OTS indexes as unused - ots_bitfield_used_page value with each OTS index being used Expectation - The ots_bitfield_used_page must increase by 1 for every sequential 1024 (ots_tracking_per_page) ots indexes marked as used :param mock_ots_bitfield_size: :param mock_ots_tracking_per_page: :return: """ with set_xrd_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) total_ots = 2**alice_xmss.height for i in range(0, total_ots + 1): paginated_bitfield.set_ots_key(addresses_state, address, i) self.assertEqual(address_state.ots_bitfield_used_page, (i + 1) // config.dev.ots_tracking_per_page) self.assertEqual(address_state.ots_bitfield_used_page, total_ots // config.dev.ots_tracking_per_page) self.assertEqual(total_ots // config.dev.ots_tracking_per_page, 4) paginated_bitfield.unset_ots_key(addresses_state, address, total_ots - 1) self.assertEqual(address_state.ots_bitfield_used_page, 3) for i in range(total_ots - 2, -1, -1): paginated_bitfield.unset_ots_key(addresses_state, address, i) self.assertEqual(address_state.ots_bitfield_used_page, i // config.dev.ots_tracking_per_page)
def setUp(self): with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.params = { "message_hash": b'Test Message', "addr_to": None, "fee": 1, "xmss_pk": self.alice.pk } self.m_addr_state = Mock(autospec=OptimizedAddressState, name='addr_state', balance=200) self.m_addr_from_pk_state = Mock(autospec=OptimizedAddressState, name='addr_from_pk_state')
def test_load_bitfield_and_ots_key_reuse(self): with set_xrd_dir('no_data'): state = State() alice_xmss = get_alice_xmss(4) paginated_bitfield = PaginatedBitfield(True, state._db) self.assertFalse( paginated_bitfield.load_bitfield_and_ots_key_reuse( alice_xmss.address, 0)) addresses_state = { alice_xmss.address: OptimizedAddressState.get_default(alice_xmss.address) } paginated_bitfield.set_ots_key(addresses_state, alice_xmss.address, 0) self.assertTrue( paginated_bitfield.load_bitfield_and_ots_key_reuse( alice_xmss.address, 0))
def state_migration_step_2(self, state: State): """ Migration Step from State Version 0 to 1 :return: """ del self._tmp_state self._tmp_state = None del state._db tmp_db_dir = os.path.join(config.user.data_dir, config.dev.db_name + "3") db_dir = os.path.join(config.user.data_dir, config.dev.db_name) shutil.move(db_dir, tmp_db_dir) tmp_db_dir = os.path.join(config.user.data_dir, config.dev.db_name + "2") shutil.move(tmp_db_dir, db_dir) state._db = db.DB() logger.warning("State Migration Finished")
def setUp(self): with set_xrd_dir('no_data'): self.state = State() self.alice = get_alice_xmss() alice_address_state = OptimizedAddressState.get_default( self.alice.address) alice_address_state.pbdata.balance = 100 self.addresses_state = {self.alice.address: alice_address_state} self.params = { "message_hash": b'Test Message', "addr_to": None, "fee": 1, "xmss_pk": self.alice.pk } self.unused_chain_manager_mock = Mock(autospec=ChainManager, name='unused ChainManager')