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 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_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_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_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 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 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_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 test_getStats(self): db_state = Mock(spec=State) db_state.total_coin_supply = MagicMock(return_value=1000) db_state.get_measurement = MagicMock(return_value=60) 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 chain_manager.get_last_block = MagicMock(return_value=GenesisBlock()) chain_manager.get_block_by_number = MagicMock(return_value=None) chain_manager.state = db_state 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) request = qrl_pb2.GetStatsReq() stats = service.GetStats(request=request, context=None) # self.assertEqual(__version__, stats.node_info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, stats.node_info.state) self.assertEqual(23, stats.node_info.num_connections) # self.assertEqual("testnet", stats.node_info.network_id) # FIXME self.assertEqual(0, stats.epoch) self.assertEqual(0, stats.uptime_network) self.assertEqual(65000000000000000, stats.block_last_reward) self.assertEqual(60, stats.block_time_mean) self.assertEqual(0, stats.block_time_sd) self.assertEqual(105000000, stats.coins_total_supply) self.assertEqual(1000, stats.coins_emitted) self.assertEqual(0, len(stats.block_timeseries))
def test_getAddressState(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) AddressState.put_address_state(db_state, optimized_address_state) 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.GetAddressStateReq() request.address = get_alice_xmss().address response = service.GetAddressState(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(alice_xmss.address, response.state.address) self.assertEqual(25, response.state.nonce) self.assertEqual(10, response.state.balance) self.assertEqual([b'\x00'] * config.dev.ots_bitfield_size, response.state.ots_bitfield) self.assertEqual([], response.state.transaction_hashes)
def test_getAddressState(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) 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.GetAddressStateReq() request.address = get_alice_xmss().address response = service.GetAddressState(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(alice_xmss.address, response.state.address) self.assertEqual(25, response.state.nonce) self.assertEqual(10, response.state.balance) self.assertEqual([b'\x00'] * config.dev.ots_bitfield_size, response.state.ots_bitfield) self.assertEqual([], response.state.transaction_hashes)
def test_getOTS(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) 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.GetOTSReq(address=alice_xmss.address) response = service.GetOTS(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(0, response.next_unused_ots_index) paginated_bitfield = PaginatedBitfield(True, db_state._db) paginated_bitfield.set_ots_key(addresses_state, optimized_address_state.address, 0) paginated_bitfield.put_addresses_bitfield(None) response = service.GetOTS(request=request, context=context) context.set_code.assert_not_called() self.assertEqual(1, response.next_unused_ots_index)
def test_getNodeState(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) node_state = service.GetNodeState(request=qrl_pb2.GetNodeStateReq, context=None) # self.assertEqual(__version__, node_state.info.version) # FIXME self.assertEqual(qrl_pb2.NodeInfo.UNSYNCED, node_state.info.state) self.assertEqual(23, node_state.info.num_connections)
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 ntp.setDrift() logger.info('Initializing chain..') persistent_state = State() if args.mocknet: args.debug = True config.user.mining_enabled = True config.user.mining_thread_count = 1 config.user.mining_pause = 500 config.dev.mining_setpoint_blocktime = 1 config.user.genesis_difficulty = 2 # Mocknet mining address # Q01050058bb3f8cb66fd90d0347478e5bdf3a475e82cfc5fe5dc276500ca21531e6edaf3d2d0f7e # Mocknet mining hexseed # 010500dd70f898c2cb4c11ce7fd85aa04554e41dcc46569871d189a3f48d84e2fbedbe176695e291e9b81e619b3625c624cde6 args.mining_address = 'Q01050058bb3f8cb66fd90d0347478e5bdf3a475e82cfc5fe5dc276500ca21531e6edaf3d2d0f7e' if args.debug: logger.warning("FAULT HANDLER ENABLED") faulthandler.enable() 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 if args.measurement > -1: persistent_state.get_measurement = MagicMock(return_value=args.measurement) chain_manager = ChainManager(state=persistent_state) chain_manager.load(Block.deserialize(GenesisBlock().serialize())) qrlnode = QRLNode(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, debug_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) if config.user.mining_enabled: logger.info('Mining/staking address %s using %s threads (0 = auto)', 'Q' + bin2hstr(mining_address), args.mining_thread_count) elif args.mining_address or args.mining_thread_count: logger.warning('Mining is not enabled but you sent some "mining related" param via CLI') # FIXME: This will be removed once we move away from Twisted reactor.run()
def test_getObject(self): SOME_ODD_HASH = sha256(b'this should not be found') 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) # First try an empty request context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertFalse(response.found) # Some odd address context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = SOME_ODD_HASH response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertFalse(response.found) # Find an address bob_xmss = get_bob_xmss() addr1_state = AddressState.create(address=bob_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) addr1_state.transaction_hashes.append(sha256(b'0')) addr1_state.transaction_hashes.append(sha256(b'1')) db_state.get_address_state = MagicMock(return_value=addr1_state) context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = bob_xmss.address response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.address_state) self.assertEqual(bob_xmss.address, response.address_state.address) self.assertEqual(25, response.address_state.nonce) self.assertEqual(10, response.address_state.balance) self.assertEqual([sha256(b'0'), sha256(b'1')], response.address_state.transaction_hashes) # 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], 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.GetObjectReq() request.query = tx1.txhash response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.transaction) self.assertEqual('transfer', response.transaction.tx.WhichOneof('transactionType')) self.assertEqual(alice_xmss.address, response.transaction.tx.master_addr) self.assertEqual(bob_xmss.pk, response.transaction.tx.public_key) self.assertEqual(tx1.txhash, response.transaction.tx.transaction_hash) self.assertEqual(b'', response.transaction.tx.signature) self.assertEqual(bob_xmss.address, response.transaction.tx.transfer.addrs_to[0]) self.assertEqual(125, response.transaction.tx.transfer.amounts[0]) self.assertEqual(19, response.transaction.tx.fee) alice_xmss = get_alice_xmss() # Find a block db_state.get_block_by_number = MagicMock( return_value=Block.create(block_number=1, prev_headerhash=sha256(b'reveal'), prev_timestamp=10, transactions=[], miner_address=alice_xmss.address)) context = Mock(spec=ServicerContext) request = qrl_pb2.GetObjectReq() request.query = bytes(str2bin('1')) response = service.GetObject(request=request, context=context) context.set_code.assert_not_called() self.assertTrue(response.found) self.assertIsNotNone(response.block_extended) self.assertEqual(1, response.block_extended.header.block_number)
def test_getLatestData(self): blocks = [] txs = [] alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() for i in range(1, 4): for j in range(1, 3): txs.append( TransferTransaction.create(addrs_to=[bob_xmss.address], amounts=[i * 100 + j], fee=j, xmss_pk=alice_xmss.pk)) blocks.append( Block.create(block_number=i, prev_headerhash=sha256(b'reveal'), prev_timestamp=10, transactions=txs, miner_address=alice_xmss.address)) txpool = [] for j in range(10, 15): tx = TransferTransaction.create(addrs_to=[bob_xmss.address], amounts=[1000 + j], fee=j, xmss_pk=get_alice_xmss().pk) txpool.append((tx.fee, TransactionInfo(tx, 0))) db_state = Mock(spec=State) db_state.get_tx_metadata = MagicMock(return_value=None) db_state.get_last_txs = MagicMock(return_value=txs) db_state.get_block_by_number = Mock() db_state.get_block_by_number.side_effect = blocks p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) chain_manager.tx_pool = Mock() chain_manager.tx_pool.transactions = heapq.nlargest( len(txpool), txpool) chain_manager.tx_pool.transaction_pool = txpool chain_manager._last_block = Mock() chain_manager._last_block.block_number = len(blocks) qrlnode = QRLNode(mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode.get_block_from_index = MagicMock(return_value=None) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) request = qrl_pb2.GetLatestDataReq(filter=qrl_pb2.GetLatestDataReq.ALL, offset=1, quantity=3) response = service.GetLatestData(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() # Verify blockheaders self.assertEqual(3, len(response.blockheaders)) self.assertEqual(1, response.blockheaders[0].header.block_number) self.assertEqual(2, response.blockheaders[1].header.block_number) self.assertEqual(3, response.blockheaders[2].header.block_number) # Verify transactions_unconfirmed self.assertEqual(3, len(response.transactions_unconfirmed)) # TODO: Verify expected order self.assertEqual( 1013, response.transactions_unconfirmed[0].tx.transfer.amounts[0]) self.assertEqual( 1012, response.transactions_unconfirmed[1].tx.transfer.amounts[0]) self.assertEqual( 1011, response.transactions_unconfirmed[2].tx.transfer.amounts[0]) # Verify transactions self.assertEqual(3, len(response.transactions)) self.assertEqual(2, response.transactions[0].tx.fee) self.assertEqual(1, response.transactions[1].tx.fee) self.assertEqual(2, response.transactions[2].tx.fee) self.assertEqual(102, response.transactions[0].tx.transfer.amounts[0]) self.assertEqual(201, response.transactions[1].tx.transfer.amounts[0]) self.assertEqual(202, response.transactions[2].tx.transfer.amounts[0])
def test_messageTxn_sign(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() my_message = b'Hello QRL!' request = qrl_pb2.MessageTxnReq( message=my_message, fee=12, xmss_pk=alice.pk ) response = service.GetMessageTxn(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.tx) self.assertEqual('message', 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(my_message, response.extended_transaction_unsigned.tx.message.message_hash) tmp_hash_pre = response.extended_transaction_unsigned.tx.master_addr tmp_hash_pre += response.extended_transaction_unsigned.tx.fee.to_bytes(8, byteorder='big', signed=False) tmp_hash_pre += response.extended_transaction_unsigned.tx.message.message_hash tmp_hash = sha256(tmp_hash_pre) hash_found = bin2hstr(Transaction.from_pbdata(response.extended_transaction_unsigned.tx). get_hashable_bytes()) self.assertEqual(hash_found, bin2hstr(tmp_hash)) signed_transaction = response.extended_transaction_unsigned.tx signed_transaction.signature = alice.sign(tmp_hash) req_push = qrl_pb2.PushTransactionReq(transaction_signed=signed_transaction) 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.SUBMITTED, resp_push.error_code) self.assertEqual('b7ee814a548a6bbb8d97b2d3a0eb9e1f8b6ceee49b764e3c7b23d104aca6abeb', bin2hstr(resp_push.tx_hash))