def test_getHeight(self): with set_xrd_dir('no_data'): db_state = State() alice_xmss = get_alice_xmss() optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address, nonce=25, balance=10, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) addresses_state = {optimized_address_state.address: optimized_address_state} AddressState.put_addresses_state(db_state, addresses_state) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) chain_manager._last_block = Mock() chain_manager._last_block.block_number = 100 xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) context = Mock(spec=ServicerContext) request = xrd_pb2.GetHeightReq() response = service.GetHeight(request=request, context=context) self.assertEqual(response.height, 100)
def test_put_multi_sig_addresses_state(self): alice_xmss = get_alice_xmss() bob_xmss = get_bob_xmss() random_xmss = get_random_xmss() signatories = [alice_xmss.address, bob_xmss.address] weights = [20, 20] threshold = 21 multi_sig_tx = MultiSigCreate.create(signatories, weights, threshold, 0, random_xmss.pk) multi_sig_tx.sign(random_xmss) multi_sig_address_state = MultiSigAddressState.get_default( multi_sig_tx.txhash, signatories, weights, threshold) multi_sig_addresses_state = { multi_sig_address_state.address: multi_sig_address_state } AddressState.put_addresses_state(self.state, multi_sig_addresses_state) multi_sig_address_state2 = MultiSigAddressState.get_multi_sig_address_state_by_address( self.state._db, MultiSigAddressState.generate_multi_sig_address( multi_sig_tx.txhash)) self.assertEqual(multi_sig_address_state.pbdata, multi_sig_address_state2.pbdata)
def test_get_default_coinbase(self): # Make sure that Coinbase AddressState gets all the coins supply by default coinbase_addr_state = AddressState.get_default( config.dev.coinbase_address) self.assertEqual( coinbase_addr_state.balance, int(config.dev.max_coin_supply * config.dev.shor_per_quanta))
def test_relaySlaveTxnBySlave(self): with set_xrd_dir("wallet_ver1"): walletd = WalletD() walletd._public_stub.PushTransaction = Mock( return_value=xrd_pb2.PushTransactionResp(error_code=xrd_pb2.PushTransactionResp.SUBMITTED)) service = WalletAPIService(walletd) resp = service.AddNewAddressWithSlaves(xrdwallet_pb2.AddNewAddressWithSlavesReq(), context=None) qaddress = resp.address addr_state = AddressState.get_default(walletd.qaddress_to_address(qaddress)) slaves = walletd.get_slave_list(qaddress) addr_state.add_slave_pks_access_type(bytes(hstr2bin(slaves[0][0].pk)), 0) walletd._public_stub.GetAddressState = Mock( return_value=xrd_pb2.GetAddressStateResp(state=addr_state.pbdata)) alice_xmss = get_alice_xmss(4) slave_pks = [alice_xmss.pk] access_types = [0] resp = service.RelaySlaveTxnBySlave( xrdwallet_pb2.RelaySlaveTxnBySlaveReq(slave_pks=slave_pks, access_types=access_types, fee=100000000, master_address=qaddress), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_relaySlaveTxn(self): with set_xrd_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(xrdwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address addr_state = AddressState.get_default(walletd.qaddress_to_address(qaddress)) walletd._public_stub.GetAddressState = Mock( return_value=xrd_pb2.GetAddressStateResp(state=addr_state.pbdata)) walletd._public_stub.IsSlave = Mock( return_value=xrd_pb2.IsSlaveResp(result=True)) walletd._public_stub.GetOTS = Mock( return_value=xrd_pb2.GetOTSResp(next_unused_ots_index=0, unused_ots_index_found=True)) alice_xmss = get_alice_xmss(4) slave_pks = [alice_xmss.pk] access_types = [0] walletd._public_stub.PushTransaction = Mock( return_value=xrd_pb2.PushTransactionResp(error_code=xrd_pb2.PushTransactionResp.SUBMITTED)) resp = service.RelaySlaveTxn(xrdwallet_pb2.RelaySlaveTxnReq(slave_pks=slave_pks, access_types=access_types, fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_relayTokenTxnBySlave(self): with set_xrd_dir("wallet_ver1"): walletd = WalletD() walletd._public_stub.PushTransaction = Mock( return_value=xrd_pb2.PushTransactionResp(error_code=xrd_pb2.PushTransactionResp.SUBMITTED)) service = WalletAPIService(walletd) resp = service.AddNewAddressWithSlaves(xrdwallet_pb2.AddNewAddressWithSlavesReq(), context=None) qaddress = resp.address addr_state = AddressState.get_default(walletd.qaddress_to_address(qaddress)) slaves = walletd.get_slave_list(qaddress) addr_state.add_slave_pks_access_type(bytes(hstr2bin(slaves[0][0].pk)), 0) walletd._public_stub.GetAddressState = Mock( return_value=xrd_pb2.GetAddressStateResp(state=addr_state.pbdata)) alice_xmss = get_alice_xmss(4) bob_xmss = get_bob_xmss(4) qaddresses = [alice_xmss.qaddress, bob_xmss.qaddress] amounts = [1000000000, 1000000000] resp = service.RelayTokenTxnBySlave( xrdwallet_pb2.RelayTokenTxnBySlaveReq(symbol=b'xrd', name=b'Quantum Resistant Ledger', owner=alice_xmss.qaddress, decimals=5, addresses=qaddresses, amounts=amounts, fee=100000000, master_address=qaddress), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_relayMessageTxn(self): with set_xrd_dir("wallet_ver1"): walletd = WalletD() walletd._public_stub.PushTransaction = Mock( return_value=xrd_pb2.PushTransactionResp(error_code=xrd_pb2.PushTransactionResp.SUBMITTED)) service = WalletAPIService(walletd) resp = service.AddNewAddress(xrdwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address addr_state = AddressState.get_default(walletd.qaddress_to_address(qaddress)) walletd._public_stub.GetAddressState = Mock( return_value=xrd_pb2.GetAddressStateResp(state=addr_state.pbdata)) walletd._public_stub.GetOTS = Mock( return_value=xrd_pb2.GetOTSResp(next_unused_ots_index=0, unused_ots_index_found=True)) resp = service.RelayMessageTxn(xrdwallet_pb2.RelayMessageTxnReq(message=b'Hello xrd!', fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(0, resp.code) self.assertIsNotNone(resp.tx)
def test_get_unused_ots_index2(self): old_value = config.dev.max_ots_tracking_index config.dev.max_ots_tracking_index = 128 try: random_xmss = get_random_xmss(xmss_height=8) addr_state = AddressState.get_default(random_xmss.address) self.assertEqual(addr_state.get_unused_ots_index(), 0) addr_state.set_ots_key(0) self.assertEqual(addr_state.get_unused_ots_index(), 1) addr_state.set_ots_key(2) self.assertEqual(addr_state.get_unused_ots_index(), 1) addr_state.set_ots_key(1) self.assertEqual(addr_state.get_unused_ots_index(), 3) for i in range( 3, min(2**addr_state.height, config.dev.max_ots_tracking_index)): addr_state.set_ots_key(i) self.assertEqual(addr_state.get_unused_ots_index(), i + 1) self.assertEqual(addr_state.get_unused_ots_index(), config.dev.max_ots_tracking_index) for i in range(config.dev.max_ots_tracking_index, 2**addr_state.height): addr_state.set_ots_key(i) self.assertIsNone(addr_state.get_unused_ots_index()) finally: config.dev.max_ots_tracking_index = old_value
def get_address_state(self, address: bytes) -> AddressState: if address != config.dev.coinbase_address and not AddressState.address_is_valid(address): raise ValueError("Invalid Address") address_state = self._chain_manager.get_address_state(address) return address_state
def test_getAddressState(self): with set_xrd_dir('no_data'): db_state = State() alice_xmss = get_alice_xmss() optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address, nonce=25, balance=10, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) AddressState.put_address_state(db_state, optimized_address_state) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) context = Mock(spec=ServicerContext) request = xrd_pb2.GetAddressStateReq() service.GetAddressState(request=request, context=context) context.set_code.assert_called() context.set_details.assert_called() context = Mock(spec=ServicerContext) request = xrd_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_put_addresses_state(self): with set_xrd_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() alice_state = OptimizedAddressState.get_default( alice_xmss.address) addresses_state = { alice_state.address: alice_state, b'test1': OptimizedAddressState.get_default(b'test1') } AddressState.put_addresses_state(state, addresses_state, None) alice_state2 = OptimizedAddressState.get_optimized_address_state( state, alice_xmss.address) self.assertEqual(alice_state.serialize(), alice_state2.serialize()) test_state = OptimizedAddressState.get_optimized_address_state( state, b'test1') self.assertEqual( test_state.serialize(), OptimizedAddressState.get_default(b'test1').serialize())
def test_getOTS(self): with set_xrd_dir('no_data'): db_state = State() alice_xmss = get_alice_xmss() optimized_address_state = OptimizedAddressState.create(address=alice_xmss.address, nonce=25, balance=10, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) addresses_state = {optimized_address_state.address: optimized_address_state} AddressState.put_addresses_state(db_state, addresses_state) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) context = Mock(spec=ServicerContext) request = xrd_pb2.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_get_optimized_address_state(self): alice_xmss = get_alice_xmss() alice_address = alice_xmss.address address_state = OptimizedAddressState.get_optimized_address_state(self.state, alice_address) self.assertTrue(isinstance(address_state.address, bytes)) alice_address = bytearray(alice_xmss.address) with self.assertRaises(TypeError): OptimizedAddressState.get_optimized_address_state(self.state, alice_address) alice_address = alice_xmss.address address_state = OptimizedAddressState.get_optimized_address_state(self.state, alice_address) addresses_state = { alice_address: address_state } self.assertTrue(isinstance(address_state.address, bytes)) AddressState.put_addresses_state(self.state, addresses_state) address_state = OptimizedAddressState.get_optimized_address_state(self.state, alice_address) self.assertTrue(isinstance(address_state.address, bytes))
def get_mining_address(mining_address: str): try: if not mining_address: mining_address = bytes(hstr2bin(config.user.mining_address[1:])) else: mining_address = bytes(hstr2bin(mining_address[1:])) if not AddressState.address_is_valid(mining_address): raise ValueError('Mining Address Validation Failed') return mining_address except Exception as e: logger.info('Failed Parsing Mining Address %s', e) return None
def test_get_unused_ots_index(self): random_xmss = get_random_xmss(xmss_height=4) addr_state = AddressState.get_default(random_xmss.address) self.assertEqual(addr_state.get_unused_ots_index(), 0) addr_state.set_ots_key(0) self.assertEqual(addr_state.get_unused_ots_index(), 1) addr_state.set_ots_key(2) self.assertEqual(addr_state.get_unused_ots_index(), 1) addr_state.set_ots_key(1) self.assertEqual(addr_state.get_unused_ots_index(), 3) for i in range( 3, min(2**addr_state.height, config.dev.max_ots_tracking_index)): addr_state.set_ots_key(i) self.assertIsNone(addr_state.get_unused_ots_index())
def test_ots_key_validation(self): random_xmss = get_random_xmss(xmss_height=4) addr = AddressState.get_default(random_xmss.address) ots_indexes = list(range(0, 2**random_xmss.height)) shuffle(ots_indexes) for i in ots_indexes: if i < config.dev.max_ots_tracking_index: self.assertFalse(addr.ots_key_reuse(i)) else: result = addr.ots_key_reuse(i) if i > addr.ots_counter: self.assertFalse(result) else: self.assertTrue(result) addr.set_ots_key(i) self.assertTrue(addr.ots_key_reuse(i))
def test_create_and_properties(self): a = AddressState.create(address=alice.address, nonce=0, balance=10, ots_bitfield=[b'\x00'] * config.dev.ots_bitfield_size, tokens={ b'010101': 100, b'020202': 200 }, slave_pks_access_type={slave.pk: 1}, ots_counter=0) self.assertEqual(a.pbdata.address, a.address) self.assertEqual(a.pbdata.balance, a.balance) a.balance = 3 self.assertEqual(a.balance, 3) self.assertEqual(a.pbdata.nonce, a.nonce) self.assertEqual(a.pbdata.ots_bitfield, a.ots_bitfield) self.assertEqual(a.pbdata.ots_counter, a.ots_counter) self.assertEqual(a.pbdata.transaction_hashes, a.transaction_hashes) self.assertEqual(a.pbdata.latticePK_list, a.latticePK_list) self.assertEqual(a.pbdata.slave_pks_access_type, a.slave_pks_access_type)
def test_relayTokenTxn(self): with set_xrd_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(xrdwallet_pb2.AddNewAddressReq(), context=None) qaddress = resp.address addr_state = AddressState.get_default(walletd.qaddress_to_address(qaddress)) walletd._public_stub.GetAddressState = Mock( return_value=xrd_pb2.GetAddressStateResp(state=addr_state.pbdata)) walletd._public_stub.IsSlave = Mock( return_value=xrd_pb2.IsSlaveResp(result=True)) walletd._public_stub.GetOTS = Mock( return_value=xrd_pb2.GetOTSResp(next_unused_ots_index=0, unused_ots_index_found=True)) alice_xmss = get_alice_xmss(4) bob_xmss = get_bob_xmss(4) qaddresses = [alice_xmss.qaddress, bob_xmss.qaddress] amounts = [1000000000, 1000000000] walletd._public_stub.PushTransaction = Mock( return_value=xrd_pb2.PushTransactionResp(error_code=xrd_pb2.PushTransactionResp.SUBMITTED)) resp = service.RelayTokenTxn(xrdwallet_pb2.RelayTokenTxnReq(symbol=b'xrd', name=b'Quantum Resistant Ledger', owner=alice_xmss.qaddress, decimals=5, addresses=qaddresses, amounts=amounts, fee=100000000, master_address=None, signer_address=qaddress, ots_index=0), context=None) self.assertEqual(resp.code, 0) self.assertIsNotNone(resp.tx)
def test_revert_multi_sig_create_txn(self): addresses_state = { self.alice.address: OptimizedAddressState.get_default(self.alice.address), self.bob.address: OptimizedAddressState.get_default(self.bob.address), self.random.address: OptimizedAddressState.get_default(self.random.address), self.random_signer.address: OptimizedAddressState.get_default(self.random_signer.address), } addresses_state[self.random_signer.address].pbdata.balance = 200 tx = MultiSigCreate.create(self.signatories, self.weights, self.threshold, 1, self.random_signer.pk) tx.sign(self.random_signer) state_container = StateContainer(addresses_state=addresses_state, tokens=Indexer(b'token', None), slaves=Indexer(b'slave', None), lattice_pk=Indexer( b'lattice_pk', None), multi_sig_spend_txs=dict(), votes_stats=dict(), block_number=1, total_coin_supply=100, current_dev_config=config.dev, write_access=True, my_db=self.state._db, batch=None) self.assertFalse( state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse( self.random_signer.address, tx.ots_key)) tx.apply(self.state, state_container) self.assertEqual(200 - tx.fee, addresses_state[self.random_signer.address].balance) storage_key = state_container.paginated_tx_hash.generate_key( self.random_signer.address, 1) self.assertEqual( [tx.txhash], state_container.paginated_tx_hash.key_value[storage_key]) for signatory_address in self.signatories: storage_key = state_container.paginated_tx_hash.generate_key( signatory_address, 1) self.assertEqual( [tx.txhash], state_container.paginated_tx_hash.key_value[storage_key]) self.assertTrue( state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse( self.random_signer.address, tx.ots_key)) AddressState.put_addresses_state(self.state, addresses_state) state_container.paginated_multisig_address.put_paginated_data(None) multi_sig_addresses_state = MultiSigAddressState.get_multi_sig_address_state_by_address( self.state._db, MultiSigAddressState.generate_multi_sig_address(tx.txhash)) self.assertEqual(self.signatories, multi_sig_addresses_state.signatories) self.assertEqual(self.weights, multi_sig_addresses_state.weights) self.assertEqual(self.threshold, multi_sig_addresses_state.threshold) for signatory_address in self.signatories: multi_sig_addresses = state_container.paginated_multisig_address.get_paginated_data( signatory_address, 1) self.assertEqual(len(multi_sig_addresses), 1) tx.revert(self.state, state_container) state_container.paginated_multisig_address.put_paginated_data(None) self.assertFalse( state_container.paginated_bitfield.load_bitfield_and_ots_key_reuse( self.random_signer.address, tx.ots_key)) self.assertIsNone( MultiSigAddressState.get_multi_sig_address_state_by_address( self.state._db, MultiSigAddressState.generate_multi_sig_address(tx.txhash))) for signatory_address in self.signatories: multi_sig_addresses = state_container.paginated_multisig_address.get_paginated_data( signatory_address, 1) self.assertEqual(len(multi_sig_addresses), 0)
def get_addr_state(addr: bytes) -> AddressState: stub = get_public_stub() response = stub.GetAddressState(request=xrd_pb2.GetAddressStateReq( address=addr)) return AddressState(response.state)
def test_getTotalBalance(self): with set_xrd_dir('no_data'): db_state = State() xmss1 = get_alice_xmss() xmss2 = get_alice_xmss(4) xmss3 = get_bob_xmss(4) address_state1 = OptimizedAddressState.create(address=xmss1.address, nonce=25, balance=1000, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) address_state2 = OptimizedAddressState.create(address=xmss2.address, nonce=25, balance=2000, ots_bitfield_used_page=0, transaction_hash_count=0, tokens_count=0, lattice_pk_count=0, slaves_count=0, multi_sig_address_count=0) address_state3 = OptimizedAddressState.create(address=xmss3.address, nonce=25, balance=3000, 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, address_state1) AddressState.put_address_state(db_state, address_state2) AddressState.put_address_state(db_state, address_state3) p2p_factory = Mock(spec=P2PFactory) chain_manager = ChainManager(db_state) xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) context = Mock(spec=ServicerContext) request = xrd_pb2.GetAddressStateReq() service.GetAddressState(request=request, context=context) context.set_code.assert_called() context.set_details.assert_called() context = Mock(spec=ServicerContext) request = xrd_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 setUp(self): self.addr_state = AddressState.get_default(alice.address)
def test_getObject(self): SOME_ODD_HASH = sha256(b'this should not be found') with set_xrd_dir('no_data'): db_state = State() p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) xrdnode = xrdNode(mining_address=b'') xrdnode.set_chain_manager(chain_manager) xrdnode._p2pfactory = p2p_factory xrdnode._pow = p2p_factory.pow xrdnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(xrdnode) # First try an empty request context = Mock(spec=ServicerContext) request = xrd_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 = xrd_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 = OptimizedAddressState.create(address=bob_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, addr1_state, None) context = Mock(spec=ServicerContext) request = xrd_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) # 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 = xrd_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 block = 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, block, None) Block.put_block_number_mapping(db_state, block.block_number, xrd_pb2.BlockNumberMapping(headerhash=block.headerhash), None) context = Mock(spec=ServicerContext) request = xrd_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_serialize(self): # Simply test that serialize() works and you can deserialize from it. output = self.addr_state.serialize() another_addr_state = AddressState(protobuf_block=output) self.assertIsInstance(another_addr_state, AddressState)
def test_address_is_valid(self): self.assertTrue(AddressState.address_is_valid(alice.address)) self.assertFalse(AddressState.address_is_valid(b'fake address'))
def test_return_all_addresses(self): with set_xrd_dir('no_data'): with State() as state: self.assertEqual(AddressState.return_all_addresses(state), [])
def get_address_state(self, qaddress: str) -> AddressState: request = xrd_pb2.GetAddressStateReq( address=bytes(hstr2bin(qaddress[1:]))) resp = self._public_stub.GetAddressState(request=request) return AddressState(resp.state)
def GetObject(self, request: xrd_pb2.GetObjectReq, context) -> xrd_pb2.GetObjectResp: logger.debug("[PublicAPI] GetObject") answer = xrd_pb2.GetObjectResp() answer.found = False # FIXME: We need a unified way to access and validate data. query = bytes( request.query ) # query will be as a string, if Q is detected convert, etc. try: if AddressState.address_is_valid(query): if self.xrdnode.get_address_is_used(query): address_state = self.xrdnode.get_optimized_address_state( query) if address_state is not None: answer.found = True answer.address_state.CopyFrom(address_state.pbdata) return answer except ValueError: pass transaction_block_number = self.xrdnode.get_transaction(query) transaction = None blockheader = None if transaction_block_number: transaction, block_number = transaction_block_number answer.found = True block = self.xrdnode.get_block_from_index(block_number) blockheader = block.blockheader.pbdata timestamp = block.blockheader.timestamp else: transaction_timestamp = self.xrdnode.get_unconfirmed_transaction( query) if transaction_timestamp: transaction, timestamp = transaction_timestamp answer.found = True if transaction: txextended = xrd_pb2.TransactionExtended( header=blockheader, tx=transaction.pbdata, addr_from=transaction.addr_from, size=transaction.size, timestamp_seconds=timestamp) answer.transaction.CopyFrom(txextended) return answer # NOTE: This is temporary, indexes are accepted for blocks try: block = self.xrdnode.get_block_from_hash(query) if block is None or (block.block_number == 0 and block.prev_headerhash != config.user.genesis_prev_headerhash): query_str = query.decode() query_index = int(query_str) block = self.xrdnode.get_block_from_index(query_index) if not block: return answer answer.found = True block_extended = xrd_pb2.BlockExtended() block_extended.header.CopyFrom(block.blockheader.pbdata) block_extended.size = block.size for transaction in block.transactions: tx = Transaction.from_pbdata(transaction) extended_tx = xrd_pb2.TransactionExtended( tx=transaction, addr_from=tx.addr_from, size=tx.size, timestamp_seconds=block.blockheader.timestamp) block_extended.extended_transactions.extend([extended_tx]) answer.block_extended.CopyFrom(block_extended) return answer except Exception: pass return answer
def validate_address(self, qaddress: str) -> bool: try: return AddressState.address_is_valid(bytes(hstr2bin(qaddress[1:]))) except Exception: return False