def test_measurement_0(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone( state) # to avoid warning (unused variable) state.get_block = Mock( side_effect=TestStateMeasurement.get_block_example1) parent_metadata = Mock() parent_metadata.last_N_headerhashes = [] measurement = state.get_measurement( 100, parent_headerhash=b'0', parent_metadata=parent_metadata) self.assertEqual(60, measurement) measurement = state.get_measurement( 110, parent_headerhash=b'0', parent_metadata=parent_metadata) self.assertEqual(60, measurement) measurement = state.get_measurement( 1000, parent_headerhash=b'0', parent_metadata=parent_metadata) self.assertEqual(60, measurement)
def test_destroy_current_state(self): with set_data_dir('no_data'): with State() as state: genesis_block = GenesisBlock() state.put_block(genesis_block, None) dummy_state = StateLoader( bin2hstr(genesis_block.headerhash).encode(), state._db) state.state_objects.append_state_loader(dummy_state) alice_xmss = get_alice_xmss() alice_address_state = AddressState.get_default( alice_xmss.address) for _ in range(10): alice_address_state.increase_nonce() addresses_state = {alice_xmss.address: alice_address_state} state.state_objects.update_current_state(addresses_state) alice_address_state2 = state.get_address(alice_xmss.address) self.assertEqual(alice_address_state.nonce, alice_address_state2.nonce) state.state_objects.destroy_current_state(None) alice_address_state2 = state.get_address(alice_xmss.address) self.assertEqual(0, alice_address_state2.nonce)
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.address, token_txhash=token_transaction.txhash, addrs_to=[alice_xmss.address], amounts=[100000000], fee=1, xmss_pk=bob_xmss.pk) 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_block_size_limit(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.get_block_size_limit(blocks[-1]), 1048576)
def test_release_state(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable)
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 create(num_blocks): start_time = time.time() with mock.patch('qrl.core.misc.ntp.getTime') as ntp_mock, \ set_data_dir('no_data'), \ State() as state, \ mock.patch('time.time') as time_mock: # noqa time_mock.return_value = start_time ntp_mock.return_value = start_time state.get_measurement = MagicMock(return_value=10000000) genesis_difficulty = config.dev.genesis_difficulty try: config.dev.genesis_difficulty = 10 genesis_block = GenesisBlock() chain_manager = ChainManager(state) chain_manager.load(genesis_block) chain_manager._difficulty_tracker = Mock() dt = DifficultyTracker() tmp_difficulty = StringToUInt256('2') tmp_target = dt.get_target(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_target)) qrlnode = QRLNode(state, mining_credit_wallet=b'') qrlnode.set_chain_manager(chain_manager) mock_blockchain = MockedBlockchain(qrlnode, time_mock, ntp_mock, ) for block_idx in range(1, num_blocks + 1): mock_blockchain.add_new_block() yield mock_blockchain finally: config.dev.genesis_difficulty = genesis_difficulty
def test_load(self): with set_data_dir('no_data'): with State() as state: genesis_block = GenesisBlock() chain_manager = ChainManager(state) chain_manager.load(genesis_block) block = state.get_block(GenesisBlock().headerhash) self.assertIsNotNone(block)
def test_load(self): with set_data_dir('no_data'): with State() as state: genesis_block = GenesisBlock() chain_manager = ChainManager(state) chain_manager.load(genesis_block) block = state.get_block(GenesisBlock().headerhash) self.assertIsNotNone(block)
def test_state_block_map(self): with set_data_dir('no_data'): with State() as state: bm = qrl_pb2.BlockNumberMapping() state.put_block_number_mapping(b"0", bm, None) read_bm = state.get_block_number_mapping(b"0") self.assertEqual(type(bm), type(read_bm)) self.assertIsNone(state.get_block_by_number(b"4"))
def test_address_list(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) for block in blocks: self.assertIn(alice_xmss.address, State.prepare_address_list(block))
def test_state_tx(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.get_last_txs(), []) state.update_last_tx(blocks[-1], None) self.assertEqual(state.get_txn_count(alice_xmss.address), 0)
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_state_loader(self): with set_data_dir('no_data'): alice_xmss = get_alice_xmss() state_loader = StateLoader(b'current_', db.DB()) self.assertEqual(state_loader.total_coin_supply, 0) state_loader.update_total_coin_supply(100) self.assertEqual(state_loader.total_coin_supply, 100) self.assertIsNone(state_loader.get_address(alice_xmss.address)) state_loader.add_address(alice_xmss.address) self.assertEqual(state_loader._data.addresses, [alice_xmss.address])
def test_measurement_1(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) state.get_block = Mock(side_effect=TestStateMeasurement.get_block_example1) measurement = state.get_measurement(210, b'1') self.assertEqual(55, measurement) measurement = state.get_measurement(250, b'1') self.assertEqual(75, measurement)
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_get_block_datapoint(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) for i in range(1, 20): datapoint = state.get_block_datapoint(blocks[i].headerhash) self.assertEqual(datapoint.difficulty, "0") self.assertEqual(datapoint.timestamp, 1615270948) self.assertEqual(datapoint.header_hash, blocks[i].headerhash) self.assertEqual(datapoint.header_hash_prev, blocks[i - 1].headerhash)
def test_get_address2(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = alice_xmss.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_block_metadata(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) for block in blocks: state.put_block_metadata(block.headerhash, BlockMetadata(), None) for block in blocks: self.assertEqual(state.get_block_metadata(block.headerhash).to_json(), b'{}')
def test_basic_state_funcs(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() self.assertEqual(state.nonce(alice_xmss.address), 0) self.assertNotEqual(state.balance(alice_xmss.address), 0) self.assertTrue(state.address_used(alice_xmss.address)) self.assertEqual(state.return_all_addresses(), []) batch = state.get_batch() self.assertIsNotNone(batch) state.write_batch(batch) self.assertEqual(state.total_coin_supply(), 0)
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_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_address_state(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) for i, block in enumerate(blocks): self.assertIn(alice_xmss.address, state.prepare_address_list(block)) address_state = state.get_state(block.headerhash, state.prepare_address_list(block)) self.assertIn(alice_xmss.address, address_state.keys()) self.assertEqual(address_state[config.dev.coinbase_address].nonce, i + 1) with self.assertRaises(Exception): state.set_addresses_state({"state": 'test'}, 0)
def test_state_mainchain(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() blocks = gen_blocks(20, state, alice_xmss.address) address_set = state.prepare_address_list(blocks[-1]) m = state.get_state_mainchain(address_set) state.update_mainchain_state(m, 20, blocks[-1].headerhash) self.assertIsNotNone(m) self.assertTrue(len(m) > 0) state.update_mainchain_height(5, None) self.assertEqual(state.get_mainchain_height(), 5) self.assertIsNotNone(state.get_ephemeral_metadata(b"0"))
def test_check_mock(self): with set_data_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 test_measurement_0(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) state.get_block = Mock(side_effect=TestStateMeasurement.get_block_example1) measurement = state.get_measurement(100, prev_headerhash=b'0') self.assertEqual(60, measurement) measurement = state.get_measurement(110, prev_headerhash=b'0') self.assertEqual(60, measurement) measurement = state.get_measurement(1000, prev_headerhash=b'0') self.assertEqual(60, measurement)
def test_addr_tx_hashes(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = bytes(alice_xmss.get_address().encode()) # FIXME: This needs to be refactored some_hash1 = bin2hstr(sha256(b'some_hash1')).encode() some_hash2 = bin2hstr(sha256(b'some_hash2')).encode() state.update_address_tx_hashes(alice_address, some_hash1) state.update_address_tx_hashes(alice_address, some_hash2) result = state.get_address_tx_hashes(alice_address) self.assertEqual(some_hash1, result[0]) self.assertEqual(some_hash2, result[1])
def test_measurement_4(self): db_name = config.dev.db_name with mock.patch('qrl.core.config.dev') as devconfig: devconfig.N_measurement = 3 devconfig.db_name = db_name with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) state.get_block = Mock(side_effect=TestStateMeasurement.get_block_example1) measurement = state.get_measurement(350, b'3') self.assertEqual(63, measurement) measurement = state.get_measurement(370, b'3') self.assertEqual(70, measurement)
def test_set_block_pos(self): with set_data_dir('no_data'): with State() as state: block_number = 123 block_position = 234 block_size = 345 state._db.put('block_{}'.format(block_number), [block_position, block_size]) pos_size = state._db.get('block_{}'.format(block_number)) read_position, read_size = pos_size self.assertEqual(block_position, read_position) self.assertEqual(block_size, read_size)
def test_check_mock(self): with set_data_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 test_set_block_pos(self): with set_data_dir('no_data'): with State() as state: block_number = 123 block_position = 234 block_size = 345 state._db.put('block_{}'.format(block_number), [block_position, block_size]) pos_size = state._db.get('block_{}'.format(block_number)) read_position, read_size = pos_size self.assertEqual(block_position, read_position) self.assertEqual(block_size, read_size)
def test_check_mock_get(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable) state.get_block = Mock(side_effect=TestStateMeasurement.get_block_example1) block = state.get_block(b'1') self.assertEqual(1, block.block_number) self.assertEqual(160, block.timestamp) block = state.get_block(b'3') self.assertEqual(3, block.block_number) self.assertEqual(310, block.timestamp) block = state.get_block(b'0') self.assertEqual(0, block.block_number) self.assertEqual(10, block.timestamp)
def test_check_mock_get(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone( state) # to avoid warning (unused variable) state.get_block = Mock( side_effect=TestStateMeasurement.get_block_example1) block = state.get_block(b'1') self.assertEqual(1, block.block_number) self.assertEqual(160, block.timestamp) block = state.get_block(b'3') self.assertEqual(3, block.block_number) self.assertEqual(310, block.timestamp) block = state.get_block(b'0') self.assertEqual(0, block.block_number) self.assertEqual(10, block.timestamp)
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_get_address(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = bytes(alice_xmss.get_address().encode()) # FIXME: This needs to be refactored address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes)) alice_address = bytearray(alice_xmss.get_address().encode()) # FIXME: This needs to be refactored with self.assertRaises(TypeError): address_state = state.get_address(alice_address) alice_address = bytes(alice_xmss.get_address().encode()) # FIXME: This needs to be refactored 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_get_address(self): with set_data_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_address = alice_xmss.address address_state = state.get_address(alice_address) self.assertTrue(isinstance(address_state.address, bytes)) alice_address = bytearray(alice_xmss.address) with self.assertRaises(TypeError): address_state = state.get_address(alice_address) alice_address = alice_xmss.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_simple_add_block(self): with set_data_dir('no_data'): with State() as state: state.get_measurement = MagicMock(return_value=10000000) alice_xmss = get_alice_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_target = dt.get_target(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock( return_value=(tmp_difficulty, tmp_target)) block = state.get_block(genesis_block.headerhash) self.assertIsNotNone(block) 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( block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[], miner_address=alice_xmss.address) block_1.set_nonces(491, 0) from pyqrllib.pyqrllib import bin2hstr print(bin2hstr(block.headerhash)) # Uncomment only to determine the correct mining_nonce of above blocks # from qrl.core.PoWValidator import PoWValidator # while not PoWValidator().validate_mining_nonce(state, block_1.blockheader, False): # block_1.set_nonces(block_1.mining_nonce + 1) # print(block_1.mining_nonce) result = chain_manager.add_block(block_1) self.assertTrue(result) self.assertEqual(chain_manager.last_block, block_1)
def test_measurement_4(self): db_name = config.dev.db_name with mock.patch('qrl.core.config.dev') as devconfig: devconfig.N_measurement = 3 devconfig.db_name = db_name with set_data_dir('no_data'): with State() as state: self.assertIsNotNone( state) # to avoid warning (unused variable) state.get_block = Mock( side_effect=TestStateMeasurement.get_block_example1) parent_metadata = Mock() parent_metadata.last_N_headerhashes = [b'0', b'1', b'2'] measurement = state.get_measurement( 350, b'3', parent_metadata) self.assertEqual(63, measurement) measurement = state.get_measurement( 370, b'3', parent_metadata) self.assertEqual(70, measurement)
def test_simple_add_block(self): with set_data_dir('no_data'): with State() as state: state.get_measurement = MagicMock(return_value=10000000) alice_xmss = get_alice_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_target(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock( return_value=(tmp_difficulty, tmp_boundary)) block = state.get_block(genesis_block.headerhash) self.assertIsNotNone(block) 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( block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[], signing_xmss=alice_xmss, master_address=alice_xmss.address, nonce=1) while not PoWValidator().validate_mining_nonce( state, block_1.blockheader, 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)
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_create_state(self): with set_data_dir('no_data'): with State() as state: self.assertIsNotNone(state) # to avoid warning (unused variable)
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())
def test_multi_output_transaction_add_block(self): 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() extended_seed = "010300cebc4e25553afa0aab899f7838e59e18a48852fa9dfd5" \ "ae78278c371902aa9e6e9c1fa8a196d2dba0cbfd2f2d212d16c" random_xmss = XMSS.from_extended_seed(hstr2bin(extended_seed)) transfer_transaction = TransferTransaction.create( addrs_to=[alice_xmss.address, random_xmss.address], amounts=[ 40 * int(config.dev.shor_per_quanta), 59 * int(config.dev.shor_per_quanta) ], fee=1 * config.dev.shor_per_quanta, xmss_pk=bob_xmss.pk) transfer_transaction._data.nonce = 1 transfer_transaction.sign(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_target(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock( return_value=(tmp_difficulty, tmp_boundary)) block = state.get_block(genesis_block.headerhash) self.assertIsNotNone(block) 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( block_number=1, prevblock_headerhash=genesis_block.headerhash, transactions=[transfer_transaction], miner_address=alice_xmss.address) block_1.set_nonces(274, 0) # Uncomment only to determine the correct mining_nonce of above blocks # from qrl.core.PoWValidator import PoWValidator # while not PoWValidator().validate_mining_nonce(state, block_1.blockheader, False): # block_1.set_nonces(block_1.mining_nonce + 1) # print(block_1.mining_nonce) result = chain_manager.add_block(block_1) self.assertTrue(result) self.assertEqual(chain_manager.last_block, block_1) bob_addr_state = state.get_address(bob_xmss.address) alice_addr_state = state.get_address(alice_xmss.address) random_addr_state = state.get_address(random_xmss.address) self.assertEqual(bob_addr_state.balance, 0) self.assertEqual( alice_addr_state.balance, 140 * int(config.dev.shor_per_quanta) + block_1.block_reward + block_1.fee_reward) self.assertEqual(random_addr_state.balance, 159 * int(config.dev.shor_per_quanta))