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
