class TestQRLNodeReal(TestCase): @patch('qrl.core.misc.ntp.getTime', new=replacement_getTime) def setUp(self): # You have to set_qrl_dir to an empty one, otherwise State will have some Transactions from disk with set_qrl_dir('no_data'): self.db_state = State() self.chainmanager = ChainManager(self.db_state) self.qrlnode = QRLNode(mining_address=b'') self.qrlnode.set_chain_manager(self.chainmanager) @patch('qrl.core.qrlnode.QRLNode.block_height', new_callable=PropertyMock, return_value=19) def test_get_latest_blocks(self, m_height): # [Block 0, Block 1, Block 2... Block 19] blocks = gen_blocks(20, self.db_state, alice.address) # get_latest_blocks(offset=0, count=1) from [Block 0.... Block 19] should return [Block 19] latest_blocks = self.qrlnode.get_latest_blocks(0, 1) self.assertTrue( latest_blocks[0] == blocks[19] ) # These are different instances, so cannot use assertEqual # get_latest_blocks(offset=0, count=2) from [Block 0.... Block 19] should return [Block 18, Block 19] latest_blocks = self.qrlnode.get_latest_blocks(0, 2) self.assertTrue(latest_blocks[0] == blocks[18]) self.assertTrue(latest_blocks[1] == blocks[19]) # get_latest_blocks(offset=10, count=3) from [Block 0.... Block 19] should return [Block 7 - Block 9] latest_blocks = self.qrlnode.get_latest_blocks(10, 3) self.assertTrue(latest_blocks[0] == blocks[7]) self.assertTrue(latest_blocks[1] == blocks[8]) self.assertTrue(latest_blocks[2] == blocks[9])
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 setUp(self): p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.num_connections = 23 p2p_factory.pow = Mock() b = Block() self.chain_manager = Mock(spec=ChainManager) self.chain_manager.height = 0 self.chain_manager.get_last_block = MagicMock(return_value=b) self.chain_manager.get_block_header_hash_by_number = MagicMock( return_value=b.headerhash) self.qrlnode = QRLNode(mining_address=b'') self.qrlnode.set_chain_manager(self.chain_manager) self.qrlnode._p2pfactory = p2p_factory self.qrlnode._pow = p2p_factory.pow self.block_header_params = { "dev_config": config.dev, "blocknumber": 10, "prev_headerhash": sha256(b'prevblock'), "prev_timestamp": 1234567890, "hashedtransactions": sha256(b'tx1'), "fee_reward": 1, "seed_height": 0, "seed_hash": None, } self.service = MiningAPIService(self.qrlnode)
def setUp(self): # You have to set_qrl_dir to an empty one, otherwise State will have some Transactions from disk with set_qrl_dir('no_data'): self.db_state = State() self.chainmanager = ChainManager(self.db_state) self.qrlnode = QRLNode(mining_address=b'') self.qrlnode.set_chain_manager(self.chainmanager)
def setUp(self): self.db_state = Mock(autospec=State, name='mocked State') # self.db_state = State() self.qrlnode = QRLNode(mining_address=b'') # As the QRLNode is instantiated and torn down for each test, the minuscule or negative diff between present # time and start_time can cause problems. self.qrlnode.start_time -= 10 self.qrlnode._pow = Mock(autospec=POW) self.qrlnode._pow.miner.lock.__enter__ = Mock() self.qrlnode._pow.miner.lock.__exit__ = Mock() self.qrlnode.peer_manager = Mock(autospec=P2PPeerManager, name='mock P2PPeerManager', known_peer_addresses=set()) self.qrlnode.p2pchain_manager = Mock(autospec=P2PChainManager, name='mock P2PChainManager') self.chain_manager = ChainManager(self.db_state) self.chain_manager.tx_pool = Mock(autospec=TransactionPool) mock_last_block = Mock(autospec=Block, name='mock last Block', block_number=2, headerhash=b'deadbeef') self.chain_manager._last_block = mock_last_block self.chain_manager.get_unconfirmed_transaction = Mock() self.qrlnode.set_chain_manager(self.chain_manager)
def qrlnode_with_mock_blockchain(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) required_height = ceil(log(num_blocks, 2)) required_height = int(required_height + required_height % 2) alice_xmss = get_alice_xmss(xmss_height=required_height) 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_target = dt.get_target(tmp_difficulty) chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_target)) block_prev = state.get_block(genesis_block.headerhash) for block_idx in range(1, num_blocks): transactions = [] if block_idx == 1: slave_tx = SlaveTransaction.create(slave_pks=[bob_xmss.pk], access_types=[0], fee=0, xmss_pk=alice_xmss.pk) slave_tx.sign(alice_xmss) slave_tx._data.nonce = 2 transactions = [slave_tx] time_mock.return_value = time_mock.return_value + 60 ntp_mock.return_value = ntp_mock.return_value + 60 block_new = Block.create(block_number=block_idx, prevblock_headerhash=block_prev.headerhash, transactions=transactions, miner_address=alice_xmss.address) while not PoWValidator().validate_mining_nonce(state, block_new.blockheader, False): block_new.set_nonces(block_new.mining_nonce + 1, 0) chain_manager.add_block(block_new) block_prev = block_new qrlnode = QRLNode(state, mining_credit_wallet=alice_xmss.address) qrlnode.set_chain_manager(chain_manager) yield qrlnode
def main(): args = parse_arguments() logger.debug( "=====================================================================================" ) logger.info("QRL Path: %s", args.qrl_dir) config.user.qrl_dir = expanduser(args.qrl_dir) config.create_path(config.user.qrl_dir) logger.debug( "=====================================================================================" ) config.create_path(config.user.wallet_dir) mining_address = None if config.user.mining_enabled: mining_address = get_mining_address(args.mining_address) if not mining_address: logger.warning('Invalid Mining Credit Wallet Address') logger.warning('%s', args.mining_address) return False ntp.setDrift() if args.debug: logger.warning("FAULT HANDLER ENABLED") faulthandler.enable() logger.info('Initializing chain..') persistent_state = State() if args.measurement > -1: persistent_state.get_measurement = MagicMock( return_value=args.measurement) chain_manager = ChainManager(state=persistent_state) chain_manager.load(Block.from_json(GenesisBlock().to_json())) qrlnode = QRLNode(db_state=persistent_state, mining_address=mining_address) 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_address) # FIXME: This will be removed once we move away from Twisted reactor.run()
def setUp(self): state = Mock() self.m_chain_manager = ChainManager(state=state) self.m_chain_manager._last_block = None self.m_chain_manager._state.get_block_by_number.return_value = None self.m_peer_manager = Mock(name='mock P2PPeerManager') self.qrlnode = QRLNode(mining_address=b'') self.qrlnode.set_chain_manager(self.m_chain_manager) self.qrlnode.peer_manager = self.m_peer_manager
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_GetBlockMiningCompatible(self): p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.num_connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 chain_manager.get_last_block = MagicMock(return_value=Block()) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow block_header = BlockHeader.create(blocknumber=10, prev_headerhash=sha256(b'prevblock'), prev_timestamp=1234567890, hashedtransactions=sha256(b'tx1'), fee_reward=1) qrlnode.get_blockheader_and_metadata = MagicMock( return_value=[block_header, BlockMetadata()]) service = MiningAPIService(qrlnode) req = qrlmining_pb2.GetBlockMiningCompatibleReq(height=10) answer = service.GetBlockMiningCompatible(request=req, context=None) self.assertEqual(10, answer.blockheader.block_number) self.assertEqual(1, answer.blockheader.reward_fee)
def test_getBlock(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) db_state.get_block = MagicMock(return_value=b) context = Mock(spec=ServicerContext) request = qrl_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_getKnownPeers(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pos = Mock() p2p_factory.pos.stake = False buffered_chain = Mock(spec=BufferedChain) buffered_chain.height = 0 qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq, context=None) self.assertEqual(2, len(response.known_peers)) self.assertEqual('127.0.0.1', response.known_peers[0].ip) self.assertEqual('192.168.1.1', response.known_peers[1].ip) logger.info(response)
def test_getKnownPeers(self): p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.num_connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 chain_manager.last_block = Block() qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode.peer_manager = Mock() qrlnode.peer_manager.known_peer_addresses = [ '127.0.0.1', '192.168.1.1' ] service = PublicAPIService(qrlnode) response = service.GetKnownPeers(request=qrl_pb2.GetKnownPeersReq, context=None) self.assertEqual(2, len(response.known_peers)) self.assertEqual('127.0.0.1', response.known_peers[0].ip) self.assertEqual('192.168.1.1', response.known_peers[1].ip) logger.info(response)
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_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 main(): args = parse_arguments() logger.debug( "=====================================================================================" ) logger.info("Data Path: %s", args.data_path) logger.info("Wallet Path: %s", args.wallet_path) config.user.data_path = args.data_path config.user.wallet_path = args.wallet_path config.create_path(config.user.data_path) config.create_path(config.user.wallet_path) sync_state = SyncState() set_logger(args, sync_state) ntp.setDrift() logger.info('Initializing chain..') persistent_state = State() buffered_chain = BufferedChain(Chain(state=persistent_state)) qrlnode = QRLNode(db_state=persistent_state) qrlnode.set_chain(buffered_chain) logger.info('QRL blockchain ledger %s', config.dev.version) logger.info('mining/staking address %s', buffered_chain.staking_address) if args.get_wallets: tmp = qrlnode.addresses if len(tmp) > 0: print(tmp[0].decode()) return ####### # NOTE: Keep assigned to a variable or might get collected grpc_service, p2p_node = start_services(qrlnode) buffered_chain.load() start_legacy_services(buffered_chain, qrlnode, sync_state)
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_GetAddressFromPK(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pow = Mock() chain_manager = Mock(spec=ChainManager) chain_manager.height = 0 qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) pk = hstr2bin( '01060057ac9cb6085a8135631dcf018dff46d9c368a0b64d508f512e584199b6800' 'f8cfcb672b931398a023680fe0308ed4b6ec75877d684bc2ccf11703e8369f064e7' ) request = qrl_pb2.GetAddressFromPKReq(pk=bytes(pk)) response = service.GetAddressFromPK(request=request, context=None) self.assertEqual( '010600b56d161c7de8aa741962e3e49b973b7e53456fa47f2443d69f17c632f29c8b1aab7d2491', bin2hstr(response.address))
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_getHeight(self): with set_qrl_dir('no_data'): db_state = State() alice_xmss = get_alice_xmss() optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address, nonce=25, balance=10, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) addresses_state = {optimized_address_state.address: optimized_address_state} AddressState.put_addresses_state(db_state, addresses_state) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) 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 start_legacy_services(buffered_chain: BufferedChain, qrlnode: QRLNode, sync_state: SyncState): # NOTE: These services are obsolete and will be removed soon # FIXME: Again, we have cross-references between node, factory, chain and node_state p2p_factory = P2PFactory(buffered_chain=buffered_chain, sync_state=sync_state, qrl_node=qrlnode) pos = POS(buffered_chain=buffered_chain, p2p_factory=p2p_factory, sync_state=sync_state, time_provider=ntp) qrlnode.set_p2pfactory(p2p_factory) reactor.listenTCP(9000, p2p_factory) p2p_factory.connect_peers() pos.restart_monitor_bk(80) reactor.callLater(20, pos.unsynced_logic) reactor.run()
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_transferCoins_push_unsigned(self): with set_qrl_dir('wallet_ver1'): with State() as db_state: p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(db_state, 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) context = Mock(spec=ServicerContext) alice = get_alice_xmss() bob = get_bob_xmss() request = qrl_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 = qrl_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(qrl_pb2.PushTransactionResp.VALIDATION_FAILED, resp_push.error_code)
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_getNodeInfo(self): qrlnode = QRLNode(mining_address=b'') service = BaseService(qrlnode) response = service.GetNodeInfo(request=GetNodeInfoReq, context=None) self.assertEqual(config.dev.version, response.version) proto_path = os.path.abspath( os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, "src", "qrl", "protos", "qrl.proto")) with open(proto_path, 'r') as content_file: proto_content = content_file.read() self.assertEqual(proto_content, response.grpcProto)
def test_getTransaction(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) # Find an address bob_xmss = get_bob_xmss() # Find a transaction alice_xmss = get_alice_xmss() db_state.address_used = MagicMock(return_value=False) tx1 = TransferTransaction.create( addrs_to=[bob_xmss.address], amounts=[125], message_data=None, fee=19, xmss_pk=bob_xmss.pk, master_addr=alice_xmss.address) chain_manager.tx_pool.transaction_pool = [(0, TransactionInfo(tx1, 0))] context = Mock(spec=ServicerContext) request = qrl_pb2.GetTransactionReq() request.tx_hash = tx1.txhash response = service.GetTransaction(request=request, context=context) context.set_code.assert_not_called() self.assertIsNotNone(response.tx) self.assertEqual('transfer', response.tx.WhichOneof('transactionType')) self.assertEqual(alice_xmss.address, response.tx.master_addr) self.assertEqual(bob_xmss.pk, response.tx.public_key) self.assertEqual(tx1.txhash, response.tx.transaction_hash) self.assertEqual(b'', response.tx.signature) self.assertEqual(bob_xmss.address, response.tx.transfer.addrs_to[0]) self.assertEqual(125, response.tx.transfer.amounts[0]) self.assertEqual(19, response.tx.fee)
def main(): args = parse_arguments() config.create_path(config.user.wallet_dir) slaves = mining_wallet_checks(args) 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, slaves=slaves) qrlnode.set_chain(chain_manager) set_logger(args, qrlnode.sync_state) ####### # NOTE: Keep assigned to a variable or might get collected admin_service, grpc_service = start_services(qrlnode) qrlnode.start_listening() qrlnode.connect_peers() qrlnode.start_pow() logger.info('QRL blockchain ledger %s', config.dev.version) logger.info('mining/staking address %s', slaves[0]) # FIXME: This will be removed once we move away from Twisted reactor.run()
def test_getNodeInfo(self): db_state = Mock(spec=State) qrlnode = QRLNode(db_state, slaves=[]) service = BaseService(qrlnode) response = service.GetNodeInfo(request=GetNodeInfoReq, context=None) self.assertEqual(config.dev.version, response.version) proto_path = os.path.abspath( os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, "qrl", "protos", "qrl.proto")) with open(proto_path, 'r') as content_file: proto_content = content_file.read() self.assertEqual(proto_content, response.grpcProto)
def test_create(self): db_state = Mock(spec=State) qrlnode = QRLNode(db_state) with patch('qrl.generated.qrl_pb2_grpc.P2PAPIStub'): pm = PeerManager(qrlnode) self.assertIsNotNone(pm) self.assertEqual(0, pm.stable_peer_count) pm.add(['127.0.0.1']) pm.add(['0.0.0.0']) self.assertEqual(0, pm.peer_count) pm.add(['1.1.1.1']) self.assertEqual(1, pm.peer_count) self.assertEqual(0, pm.stable_peer_count) sleep(2)
def setUp(self): db_state = Mock(spec=State) p2p_factory = Mock(spec=P2PFactory) p2p_factory.sync_state = SyncState() p2p_factory.connections = 23 p2p_factory.pos = Mock() p2p_factory.pos.stake = False buffered_chain = Mock(spec=BufferedChain) buffered_chain.height = 0 qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] self.service = P2PAPIService(qrlnode)
def test_getAddressState(self): db_state = Mock(spec=State) db_state.get_address = MagicMock(return_value=AddressState.create( address=b'Q' + sha256(b'address'), nonce=25, balance=10, pubhashes=[sha256(b'a'), sha256(b'b')], tokens=dict())) db_state.get_address_tx_hashes = MagicMock( return_value=[sha256(b'0'), sha256(b'1')]) p2p_factory = Mock(spec=P2PFactory) chain = Chain(db_state) buffered_chain = BufferedChain(chain) qrlnode = QRLNode(db_state) qrlnode.set_p2pfactory(p2p_factory) qrlnode.set_chain(buffered_chain) qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) request = qrl_pb2.GetAddressStateReq() response = service.GetAddressState(request=request, context=context) context.set_code.assert_called() context.set_details.assert_called() context = Mock(spec=ServicerContext) request = qrl_pb2.GetAddressStateReq() request.address = b'Q' + sha256(b'address') response = service.GetAddressState(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(b'Q' + sha256(b'address'), response.state.address) self.assertEqual(25, response.state.nonce) self.assertEqual(10, response.state.balance) self.assertEqual([sha256(b'a'), sha256(b'b')], response.state.pubhashes) self.assertEqual([sha256(b'0'), sha256(b'1')], response.state.transaction_hashes)