def test_load_bitfield_and_ots_key_reuse(self): with set_qrl_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 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_create(self): with set_wallet_dir("test_wallet"): with State() as state: self.assertIsNotNone(state) chain = Chain(state) self.assertIsNotNone(chain) self.assertEqual(chain.staking_address, b'Q1d6222fe3e53fafe8ce33acd2f8385c6dc044ab55452f0ebceb4d00233935ffaa72dd826') self.assertEqual(chain.wallet.address_bundle[0].address, b'Q1d6222fe3e53fafe8ce33acd2f8385c6dc044ab55452f0ebceb4d00233935ffaa72dd826')
def setUp(self): with set_qrl_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_remove_token_metadata(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() token_tx = get_token_transaction(alice_xmss, bob_xmss) state.create_token_metadata(token_tx) token_metadata = state.get_token_metadata(token_tx.txhash) self.assertEqual(token_metadata.token_txhash, token_tx.txhash) state.remove_token_metadata(token_tx) self.assertIsNone(state.get_token_metadata(token_tx.txhash))
def test_write_batch(self): with set_qrl_dir('no_data'): with State() as state: batch = state.get_batch() block = Block.create(block_number=10, prevblock_headerhash=b'aa', transactions=[], miner_address=b'aa') state.put_block(block, batch) self.assertIsNone(state.get_block(block.headerhash)) state.write_batch(batch) block2 = state.get_block(block.headerhash) self.assertEqual(block.headerhash, block2.headerhash)
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_get_token_metadata(self): with set_qrl_dir('no_data'): with State() as state: token_txhash = bytes(sha2_256(b'alpha')) token_metadata = TokenMetadata.create( token_txhash, [bytes(sha2_256(b'delta')), bytes(sha2_256(b'gamma'))]) state._db.get_raw = MagicMock( return_value=token_metadata.to_json()) self.assertEqual( state.get_token_metadata(token_txhash).to_json(), token_metadata.to_json())
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 setUp(self): with set_qrl_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_getBlockByNumber(self): with set_qrl_dir('no_data'): db_state = State() p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) alice_xmss = get_alice_xmss() b = Block.create(dev_config=config.dev, block_number=1, prev_headerhash=sha256(b'reveal'), prev_timestamp=10, transactions=[], miner_address=alice_xmss.address, seed_height=0, seed_hash=None) Block.put_block(db_state, b, None) Block.put_block_number_mapping(db_state, b.block_number, qrl_pb2.BlockNumberMapping(headerhash=b.headerhash), None) 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_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_set_block_pos(self): 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_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_update_tx_metadata(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() tx = TransferTransaction.create(addrs_to=[get_some_address(1), get_some_address(2)], amounts=[1, 2], fee=0, xmss_pk=alice_xmss.pk) block_number = 5 state.put_tx_metadata(tx, block_number, 10000, None) tx_metadata = state.get_tx_metadata(tx.txhash) self.assertEqual(tx_metadata[0].to_json(), tx.to_json()) self.assertEqual(tx_metadata[1], block_number)
def __init__(self, *args, **kwargs): super(TestMultiSigSpend, self).__init__(*args, **kwargs) with set_qrl_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_get_block_datapoint(self): with set_qrl_dir('no_data'): with State() as state: # Test Case: When block not found self.assertIsNone(state.get_block_datapoint(b'test')) 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, "256") self.assertEqual(datapoint.timestamp, 1615270947 + i) 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_qrl_dir('no_data'): with State() as state: 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) address_state = state.get_address_state(alice_address) self.assertTrue(isinstance(address_state.address, bytes))
def test_put_addresses_state(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_state = AddressState.get_default(alice_xmss.address) addresses_state = { alice_state.address: alice_state, b'test1': AddressState.get_default(b'test1') } state.put_addresses_state(addresses_state, None) alice_state2 = state.get_address_state(alice_xmss.address) self.assertEqual(alice_state.serialize(), alice_state2.serialize()) test_state = state.get_address_state(b'test1') self.assertEqual(test_state.serialize(), AddressState.get_default(b'test1').serialize())
def test_remove(self, mock_dev_config): with set_qrl_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) p.delete(storage_key, None) found_value = p.get_paginated_data(key, 11) self.assertEqual([], found_value)
def validate_mining_nonce(self, state: State, blockheader: BlockHeader, enable_logging=False): parent_metadata = state.get_block_metadata( blockheader.prev_blockheaderhash) parent_block = state.get_block(blockheader.prev_blockheaderhash) measurement = state.get_measurement(blockheader.timestamp, blockheader.prev_blockheaderhash, parent_metadata) diff, target = DifficultyTracker.get( measurement=measurement, parent_difficulty=parent_metadata.block_difficulty) if enable_logging: logger.debug('-----------------START--------------------') logger.debug('Validate #%s', blockheader.block_number) logger.debug('block.timestamp %s', blockheader.timestamp) logger.debug('parent_block.timestamp %s', parent_block.timestamp) logger.debug('parent_block.difficulty %s', UInt256ToString(parent_metadata.block_difficulty)) logger.debug('diff : %s | target : %s', UInt256ToString(diff), target) logger.debug('-------------------END--------------------') if not self.verify_input_cached(blockheader.mining_blob, target): if enable_logging: logger.warning("PoW verification failed") qn = Qryptonight() tmp_hash = qn.hash(blockheader.mining_blob) logger.warning("{}".format(tmp_hash)) logger.debug('%s', blockheader.to_json()) return False return True
def test_check_mock(self): with set_qrl_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_1(self): with set_qrl_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'] measurement = state.get_measurement(210, b'1', parent_metadata) self.assertEqual(55, measurement) measurement = state.get_measurement(250, b'1', parent_metadata) self.assertEqual(75, measurement)
def test_create_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) 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_add_many_and_save(self): with set_wallet_dir("test_wallet"): with State() as state: self.assertIsNotNone(state) chain = Chain(state) alice_xmss = get_alice_xmss() staking_address = bytes(alice_xmss.get_address().encode()) with patch('qrl.core.config.dev.disk_writes_after_x_blocks'): qrl.core.config.dev.disk_writes_after_x_blocks = 4 prev = bytes() address_state_dict = dict() address_state_dict[staking_address] = AddressState.create( address=staking_address, nonce=0, balance=100, pubhashes=[]) for i in range(10): tmp_block1 = Block.create( staking_address=staking_address, block_number=i, reveal_hash=bytes(), prevblock_headerhash=prev, transactions=[], duplicate_transactions=OrderedDict(), vote=VoteMetadata(), signing_xmss=alice_xmss, nonce=address_state_dict[staking_address].nonce + 1) prev = tmp_block1.headerhash res = chain.add_block(tmp_block1, address_state_dict, StakeValidatorsTracker(), b'1001', alice_xmss) address_state_dict[staking_address].increase_nonce() address_state_dict[ staking_address].balance += tmp_block1.block_reward self.assertEqual( i, chain.height ) # FIXME: wrong name, it is not height but max_index self.assertTrue(res) print(qrl.core.config.dev.disk_writes_after_x_blocks)
def test_put_tx_metadata(self): with set_qrl_dir('no_data'): with State() as state: self.assertIsNone(state.get_tx_metadata(b'test1')) alice_xmss = get_alice_xmss() tx = TransferTransaction.create(addrs_to=[b'q1', b'q2'], amounts=[1, 2], fee=0, xmss_pk=alice_xmss.pk) block_number = 5 state.put_tx_metadata(tx, block_number, 10000, None) tx_metadata = state.get_tx_metadata(tx.txhash) self.assertEqual(tx_metadata[0].to_json(), tx.to_json()) self.assertEqual(tx_metadata[1], block_number)
def test_last_block(self): with set_qrl_dir('no_data'): def get_block_by_number(block_number): block = Block() block.blockheader._data.block_number = block_number return block with State() as state: self.assertIsNone(state.last_block) state.get_block_by_number = MagicMock(side_effect=get_block_by_number) state.update_mainchain_height(10, None) self.assertEqual(state.last_block.block_number, 10) state.update_mainchain_height(1, None) self.assertEqual(state.last_block.block_number, 1)
def main(): args = parse_arguments() config.create_path(config.user.wallet_dir) mining_credit_wallet = get_mining_credit_wallet(args.mining_credit_wallet) if not mining_credit_wallet: logger.warning('Invalid Mining Credit Wallet Address') logger.warning('%s', args.mining_credit_wallet) return False logger.debug( "=====================================================================================" ) logger.info("Data Path: %s", args.data_dir) config.user.data_dir = args.data_dir config.create_path(config.user.data_dir) ntp.setDrift() logger.info('Initializing chain..') persistent_state = State() chain_manager = ChainManager(state=persistent_state) chain_manager.load(Block.from_json(GenesisBlock().to_json())) qrlnode = QRLNode(db_state=persistent_state, mining_credit_wallet=mining_credit_wallet) qrlnode.set_chain_manager(chain_manager) set_logger(args, qrlnode.sync_state) ####### # NOTE: Keep assigned to a variable or might get collected admin_service, grpc_service, mining_service = start_services(qrlnode) qrlnode.start_listening() qrlnode.connect_peers() qrlnode.start_pow(args.mining_thread_count) logger.info('QRL blockchain ledger %s', config.dev.version) logger.info('mining/staking address %s', args.mining_credit_wallet) # FIXME: This will be removed once we move away from Twisted reactor.run()
def test_put_block_metadata(self): with set_qrl_dir('no_data'): with State() as state: block_metadata = BlockMetadata.create() block_metadata.update_last_headerhashes([b'test1', b'test2'], b'test3') state.put_block_metadata(b'block_headerhash', block_metadata, None) state.put_block_metadata(b'block_headerhash2', BlockMetadata.create(), None) self.assertEqual(state.get_block_metadata(b'block_headerhash').to_json(), block_metadata.to_json()) expected_json = b'{\n "blockDifficulty": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",\n ' \ b'"cumulativeDifficulty": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="\n}' self.assertEqual(state.get_block_metadata(b'block_headerhash2').to_json(), expected_json)
def test_add_genesis(self): with State() as state: with set_wallet_dir("test_wallet"): chain = Mock(spec=Chain) chain.height = 0 chain.get_block = MagicMock(return_value=None) chain.wallet = Wallet() chain.pstate = state buffered_chain = BufferedChain(chain) b0 = buffered_chain.get_block(0) buffered_chain._chain.get_block.assert_called() self.assertIsNone(b0) res = buffered_chain.add_block(block=GenesisBlock()) self.assertTrue(res)