def test_transferCoins_get_unsigned(self):
with set_qrl_dir('test_wallet'):
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])
def test_generate_bitfield_key(self):
with set_qrl_dir('no_data'):
state = State()
paginated_bitfield = PaginatedBitfield(True, state._db)
address = b'addr1'
page = 1
expected_key = b'bitfield_' + address + b'_' + page.to_bytes(8, byteorder='big', signed=False)
found_key = paginated_bitfield.generate_bitfield_key(address, page)
self.assertEqual(expected_key, found_key)
def test_addAddressFromSeed2(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddAddressFromSeed(
qrlwallet_pb2.AddAddressFromSeedReq(seed=self.mnemonic),
context=None)
self.assertEqual(resp.code, 0)
self.assertEqual(resp.address, self.qaddress)
def test_add_address_from_seed(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
qaddress1 = walletd.add_address_from_seed(
seed=self.hex_seed) # Using hexseed
self.assertEqual(self.qaddress, qaddress1)
self.assertEqual(len(walletd.list_address()), 1)
def test_get_block_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNone(state.get_block_metadata(b'test1'))
state.put_block_metadata(b'block_headerhash2', BlockMetadata(),
None)
self.assertEqual(
state.get_block_metadata(b'block_headerhash2').to_json(),
b'{}')
def test_authenticate(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
walletd.authenticate()
walletd._wallet = Mock()
walletd._wallet.encrypted = Mock(return_value=True)
with self.assertRaises(ValueError):
walletd.authenticate()
def test_get_block_number_mapping(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNone(state.get_block_number_mapping(0))
bm = qrl_pb2.BlockNumberMapping()
state.put_block_number_mapping(0, bm, None)
read_bm = state.get_block_number_mapping(0)
self.assertEqual(bm.SerializeToString(),
read_bm.SerializeToString())
def test_release_state(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
with State() as state:
self.assertIsNotNone(
state) # to avoid warning (unused variable)
def test_delete(self):
with set_qrl_dir('no_data'):
with State() as state:
block = Block()
state.put_block(block, None)
block1 = state.get_block(block.headerhash)
self.assertEqual(block.serialize(), block1.serialize())
state._delete(block.headerhash, None)
self.assertIsNone(state.get_block(block.headerhash))
def test_list_address(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
qaddress = walletd.add_new_address(height=4)
self.assertEqual(qaddress[0], 'Q')
self.assertEqual(len(walletd.list_address()), 1)
list_address = walletd.list_address()
self.assertEqual(list_address[0], qaddress)
def test_get_measurement(self):
def block(headerhash):
nth_block = Block()
if headerhash == b'test_block_1':
nth_block.blockheader._data.timestamp_seconds = 50000
elif headerhash == b'test_block_2':
nth_block.blockheader._data.timestamp_seconds = 80000
elif headerhash == b'test_block_3':
nth_block.blockheader._data.timestamp_seconds = 90000
return nth_block
with set_qrl_dir('no_data'):
with State() as state:
parent_metadata = BlockMetadata.create(block_difficulty=b'\x00' * 32,
cumulative_difficulty=b'\x00' * 32,
child_headerhashes=[])
measurement = state.get_measurement(block_timestamp=100000,
parent_headerhash=b'',
parent_metadata=parent_metadata)
# Test Case, when count_headerhashes equals 0
self.assertEqual(measurement, config.dev.mining_setpoint_blocktime)
state.get_block = MagicMock(side_effect=block)
parent_metadata.update_last_headerhashes([], b'test_block_1')
measurement = state.get_measurement(block_timestamp=100000,
parent_headerhash=b'test_block_1',
parent_metadata=parent_metadata)
# Test Case, when count_headerhashes equals 1
self.assertEqual(measurement,
(100000 - 50000 + config.dev.mining_setpoint_blocktime) // 2)
parent_metadata.update_last_headerhashes([b'test_block_1'], b'test_block_2')
measurement = state.get_measurement(block_timestamp=100000,
parent_headerhash=b'test_block_2',
parent_metadata=parent_metadata)
# Test Case, when count_headerhashes is greater than 1
# but less than config.dev.N_measurement
self.assertEqual(measurement,
(100000 - 80000 + config.dev.mining_setpoint_blocktime) // 2)
parent_metadata.update_last_headerhashes([b'test_block_3'] * config.dev.N_measurement,
b'test_block_2')
measurement = state.get_measurement(block_timestamp=100000,
parent_headerhash=b'test_block_2',
parent_metadata=parent_metadata)
# Test Case, when count_headerhashes is greater than config.dev.N_measurement
self.assertEqual(measurement,
(100000 - 90000) // config.dev.N_measurement)
def test_basic_state_funcs(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
self.assertTrue(state.get_address_is_used(alice_xmss.address))
self.assertEqual(state._return_all_addresses(), [])
batch = state.batch
self.assertIsNotNone(batch)
state.write_batch(batch)
self.assertEqual(state.total_coin_supply, 0)
def test_put(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
key = b'test_key'
value = [b'hello world']
storage_key = p.generate_key(key, 11)
p.put(storage_key, value, None)
found_value = p.get_paginated_data(key, 11)
self.assertEqual(value, found_value)
def test_getRecoverySeeds(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
service.AddAddressFromSeed(qrlwallet_pb2.AddAddressFromSeedReq(seed=self.mnemonic), context=None)
resp = service.GetRecoverySeeds(qrlwallet_pb2.GetRecoverySeedsReq(address=self.qaddress), context=None)
self.assertEqual(resp.hexseed, self.hex_seed)
self.assertEqual(resp.mnemonic, self.mnemonic)
def test_create_custom_hash_function_load(self):
with set_qrl_dir("no_data"):
wallet = Wallet()
xmss = wallet.add_new_address(height=4, hash_function="sha2_256")
wallet.save()
self.assertEqual("sha2_256", xmss.hash_function)
wallet_reloaded = Wallet()
self.assertEqual("sha2_256", wallet_reloaded.address_items[0].hashFunction)
def test_addNewAddressWithSlaves(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
walletd._public_stub.PushTransaction = Mock(
return_value=qrl_pb2.PushTransactionResp(error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
service = WalletAPIService(walletd)
resp = service.AddNewAddressWithSlaves(qrlwallet_pb2.AddNewAddressWithSlavesReq(), context=None)
self.assertEqual(resp.code, 0)
self.assertEqual(resp.address[0], 'Q')
def test_get_ots(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
walletd._public_stub.GetOTS = Mock(return_value=qrl_pb2.GetOTSResp(
ots_bitfield=[b'\x00'] * 10, next_unused_ots_index=1))
ots_bitfield, next_unused_ots_index = walletd.get_ots(
self.qaddress)
self.assertEqual(ots_bitfield, [b'\x00'] * 10)
self.assertEqual(next_unused_ots_index, 1)
def test_encrypt_last_item(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
walletd.authenticate()
walletd.add_new_address(height=4)
self.assertFalse(walletd.get_wallet_info()[2])
walletd._passphrase = self.passphrase
walletd._encrypt_last_item()
self.assertTrue(walletd.get_wallet_info()[2])
def test_listAddresses(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(), context=None)
address = resp.address
resp = service.ListAddresses(qrlwallet_pb2.ListAddressesReq(), context=None)
self.assertEqual(resp.addresses[0], address)
def test_addAddressFromSeed(self):
with set_qrl_dir("wallet_ver1"):
qaddress = "Q010400ff39df1ba4d1d5b8753e6d04c51c34b95b01fc3650c10ca7b296a18bdc105412c59d0b3b"
hex_seed = "0104008441d43524996f76236141d16b7b324323abf796e77ad7c874622a82f5744bb803f9b404d25733d0db82be7ac6f3c4cf"
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddAddressFromSeed(qrlwallet_pb2.AddAddressFromSeedReq(seed=hex_seed), context=None)
self.assertEqual(resp.code, 0)
self.assertEqual(resp.address, qaddress)
def test_get_token_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
token_txhash = bytes(sha2_256(b'alpha'))
token_metadata = TokenMetadata.create(token_txhash,
[bytes(sha2_256(b'delta')),
bytes(sha2_256(b'gamma'))])
state._db.get_raw = MagicMock(return_value=token_metadata.serialize())
self.assertEqual(state.get_token_metadata(token_txhash).to_json(),
token_metadata.to_json())
def test_create_load(self):
with set_qrl_dir("no_data"):
wallet = Wallet()
wallet.add_new_address(height=4)
wallet_b = Wallet()
self.assertEqual(1, len(wallet_b.address_items))
self.assertEqual(wallet.address_items[0],
wallet_b.address_items[0])
def test_getWalletInfo(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.GetWalletInfo(qrlwallet_pb2.GetWalletInfoReq(), context=None)
self.assertEqual(resp.version, 1)
self.assertEqual(resp.address_count, 0)
self.assertFalse(resp.is_encrypted)
def setUp(self):
with set_qrl_dir('no_data'):
self.state = State()
self.state.get_measurement = Mock(return_value=10000000)
del GenesisBlock.instance # Removing Singleton instance
self.genesis_block = GenesisBlock()
self.chain_manager = ChainManager(self.state)
self.chain_manager._difficulty_tracker = Mock()
def __init__(self, *args, **kwargs):
super(TestTokenTransaction, self).__init__(*args, **kwargs)
with set_qrl_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self._decimals = 15
self.alice.set_ots_index(10)
self.maxDiff = None
def test_read_wallet_ver0_saves_wallet_ver1(self):
with set_qrl_dir("wallet_ver0"):
wallet = Wallet()
self.assertEqual(wallet.version, 0)
wallet.version = 1
wallet.save()
wallet_reloaded = Wallet()
self.assertEqual(wallet_reloaded.version, 1)
def test_decrease_txn_count(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertEqual(state.get_txn_count(b'q1'), 0)
with self.assertRaises(ValueError):
state._decrease_txn_count(0, b'q1')
state._decrease_txn_count(5, b'q1')
self.assertEqual(state.get_txn_count(b'q1'), 4)
def test_increase_txn_count(self):
with set_qrl_dir('no_data'):
with State() as state:
self.assertEqual(state.get_txn_count(b'q1'), 0)
state._increase_txn_count(0, b'q1')
self.assertEqual(state.get_txn_count(b'q1'), 1)
state._increase_txn_count(5, b'q1')
self.assertEqual(state.get_txn_count(b'q1'), 6)
def test_put_paginated_data(self, mock_dev_config):
with set_qrl_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
for i in range(0, 10):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(
alice_address_state.get_counter_by_name(p.name), i + 1)
p.put_paginated_data(None)
self.assertEqual(alice_address_state.get_counter_by_name(p.name),
10)
for i in range(10, 25):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(
alice_address_state.get_counter_by_name(p.name), i + 1)
p.put_paginated_data(None)
self.assertEqual(alice_address_state.get_counter_by_name(p.name),
25)
self.assertEqual(len(p.key_value), 0)
pages_data = []
for i in range(0, (25 // config.dev.data_per_page) + 1):
data = p.get_paginated_data(
self.alice.address, (i + 1) * config.dev.data_per_page - 1)
pages_data.append(data)
self.assertEqual(len(pages_data), 3)
self.assertEqual(len(pages_data[0]), 10)
for i in range(0, 10):
self.assertEqual(
pages_data[0][i], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(len(pages_data[1]), 10)
for i in range(10, 20):
self.assertEqual(
pages_data[1][i - 10], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
self.assertEqual(len(pages_data[2]), 5)
for i in range(20, 25):
self.assertEqual(
pages_data[2][i - 20], b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
def test_get_mainchain_height(self):
with set_qrl_dir('no_data'):
with State() as state:
# Test Case: Check default value
self.assertEqual(state.get_mainchain_height(), -1)
state.update_mainchain_height(15, None)
self.assertEqual(state.get_mainchain_height(), 15)
state.update_mainchain_height(5, None)
self.assertEqual(state.get_mainchain_height(), 5)
