def test_getBlock(self):
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)
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 = xrd_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 rollback_tx_metadata(state: State, block, batch):
fee_reward = 0
for protobuf_txn in block.transactions:
txn = Transaction.from_pbdata(protobuf_txn)
fee_reward += txn.fee
TransactionMetadata.remove_tx_metadata(state, txn, batch)
txn = Transaction.from_pbdata(
block.transactions[0]) # Coinbase Transaction
state._update_total_coin_supply(fee_reward - txn.amount, batch)
LastTransactions._remove_last_tx(state, block, batch)
def state_migration_step_1(self, state: State) -> bool:
"""
Migration Step from State Version 0 to 1
:return:
"""
if state.is_older_state_version():
db_dir_v1 = os.path.join(config.user.data_dir,
config.dev.db_name + '2')
self._tmp_state = State(state._db) # DB Pointing to Older State
state._db = db.DB(db_dir_v1) # DB Pointing to Newer State
return True
return False
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.chain_manager = ChainManager(self.state)
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.slave = get_slave_xmss()
self.tx1 = TransferTransaction.create(addrs_to=[self.bob.address],
amounts=[10],
message_data=None,
fee=1,
xmss_pk=self.alice.pk)
self.tx2 = TransferTransaction.create(addrs_to=[self.bob.address],
amounts=[10],
message_data=None,
fee=1,
xmss_pk=self.slave.pk,
master_addr=self.alice.address)
self.tx1._data.nonce = 3
self.tx2._data.nonce = 6
self.tx1.sign(self.alice)
self.tx2.sign(self.slave)
self.block_attrs = {
"dev_config": config.dev,
"block_number": 5,
"prev_headerhash": bytes(sha2_256(b'test')),
"prev_timestamp": 10,
"transactions": [self.tx1, self.tx2],
"miner_address": self.alice.address,
"seed_height": 0,
"seed_hash": None,
}
self.coinbase_addrstate_attrs = OptimizedAddressState.get_default(
config.dev.coinbase_address)
self.coinbase_addrstate_attrs.update_balance(
None,
int(config.dev.coin_remaining_at_genesis *
config.dev.shor_per_quanta))
self.bob_addrstate_attrs = OptimizedAddressState.get_default(
self.bob.address)
self.bob_addrstate_attrs.update_balance(None, 20)
self.alice_addrstate_attrs = OptimizedAddressState.get_default(
self.alice.address)
self.alice_addrstate_attrs.update_balance(None, 100)
self.alice_addrstate_attrs.pbdata.nonce = 2
self.slave_addrstate_attrs = OptimizedAddressState.get_default(
self.slave.address)
self.slave_addrstate_attrs.pbdata.nonce = 5
def test_insert(self):
with set_xrd_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
p.insert(OptimizedAddressState.get_default(b'a'), b'10')
self.assertEqual(p.get_value(b'a', 0), [b'10'])
def update_tx_metadata(state: State, block, batch) -> bool:
fee_reward = 0
for protobuf_txn in block.transactions:
txn = Transaction.from_pbdata(protobuf_txn)
fee_reward += txn.fee
if not TransactionMetadata.put_tx_metadata(
state, txn, block.block_number, block.timestamp, batch):
return False
txn = Transaction.from_pbdata(
block.transactions[0]) # Coinbase Transaction
state._update_total_coin_supply(txn.amount - fee_reward, batch)
LastTransactions._update_last_tx(state, block, batch)
return True
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
alice_address_state = OptimizedAddressState.get_default(
self.alice.address)
alice_address_state.pbdata.balance = 100
self.addresses_state = {
self.alice.address: alice_address_state,
self.bob.address:
OptimizedAddressState.get_default(self.bob.address)
}
self.params = {
"token_txhash": b'I declare the TEST token',
"addrs_to": [self.bob.address],
"amounts": [100],
"fee": 1,
"xmss_pk": self.alice.pk
}
self.unused_chain_manager_mock = Mock(autospec=ChainManager,
name='unused ChainManager')
def setUp(self):
# You have to set_xrd_dir to an empty one, otherwise State will have some Transactions from disk
with set_xrd_dir('no_data'):
self.db_state = State()
self.chainmanager = ChainManager(self.db_state)
self.xrdnode = xrdNode(mining_address=b'')
self.xrdnode.set_chain_manager(self.chainmanager)
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
alice_address_state = OptimizedAddressState.get_default(
self.alice.address)
alice_address_state.pbdata.balance = 100
self.addresses_state = {
self.alice.address: alice_address_state,
self.bob.address:
OptimizedAddressState.get_default(self.bob.address)
}
self.params = {
"symbol": b'xrd',
"name": b'Quantum Resistant Ledger',
"owner": self.alice.address,
"decimals": 15,
"initial_balances": [],
"fee": 1,
"xmss_pk": self.alice.pk
}
self.unused_chain_manager_mock = Mock(autospec=ChainManager,
name='unused ChainManager')
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_revert_paginated_data2(self, mock_dev_config):
with set_xrd_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, 25):
p.insert(
alice_address_state, b'p_tx_hash_' +
i.to_bytes(8, byteorder='big', signed=False))
p.put_paginated_data(None)
full_hash = []
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)
full_hash.extend(data)
for tx_hash in full_hash[-1::-1]:
p.remove(alice_address_state, tx_hash)
p.put_paginated_data(None)
self.assertEqual(
alice_address_state.get_counter_by_name(b'p_tx_hash'), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 22)), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 12)), 0)
self.assertEqual(
len(p.get_paginated_data(alice_address_state.address, 2)), 0)
def test_ots_key_reuse(self, mock_ots_bitfield_size,
mock_ots_tracking_per_page):
"""
Randomly using OTS key
:return:
"""
with set_xrd_dir('no_data'):
state = State()
mock_ots_bitfield_size.return_value = ceil(
config.dev.ots_tracking_per_page / 8)
paginated_bitfield = PaginatedBitfield(True, state._db)
alice_xmss = get_alice_xmss(12)
address = alice_xmss.address
address_state = OptimizedAddressState.get_default(address)
addresses_state = {address: address_state}
bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
self.assertFalse(paginated_bitfield.ots_key_reuse(
bitfield_data, 0))
paginated_bitfield.set_ots_key(addresses_state, address, 0)
bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
# False, as bitfield has been set but has not been written to state.
self.assertFalse(paginated_bitfield.ots_key_reuse(
bitfield_data, 0))
# Writing bitfield to the state.
paginated_bitfield.put_addresses_bitfield(None)
bitfield_data = paginated_bitfield.get_paginated_data(address, 1)
self.assertTrue(paginated_bitfield.ots_key_reuse(bitfield_data, 0))
def test_get_value(self):
with set_xrd_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
storage_key = p.generate_key(b'a', 0)
p.key_value[storage_key] = [10]
self.assertEqual(p.get_value(b'a', 0), [10])
def test_get_paginated_data(self, mock_dev_config):
with set_xrd_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
alice_address_state = OptimizedAddressState.get_default(
address=self.alice.address)
total_hashes = 25
expected_full_hash = []
for i in range(0, total_hashes):
tx_hash = b'p_tx_hash_' + i.to_bytes(
8, byteorder='big', signed=False)
p.insert(alice_address_state, tx_hash)
expected_full_hash.append(tx_hash)
p.put_paginated_data(None)
found_full_hash = []
expected_data_count = [10, 10, 5]
for i in range(0, (total_hashes // config.dev.data_per_page) + 1):
data = p.get_paginated_data(
self.alice.address, (i + 1) * config.dev.data_per_page - 1)
self.assertEqual(len(data), expected_data_count[i])
found_full_hash.extend(data)
self.assertEqual(expected_full_hash, found_full_hash)
def test_set_ots_key2(self, mock_ots_bitfield_size,
mock_ots_tracking_per_page):
"""
Randomly using OTS key
:return:
"""
with set_xrd_dir('no_data'):
state = State()
mock_ots_bitfield_size.return_value = ceil(
config.dev.ots_tracking_per_page / 8)
alice_xmss = get_alice_xmss(12)
address = alice_xmss.address
address_state = OptimizedAddressState.get_default(address)
addresses_state = {address: address_state}
paginated_bitfield = PaginatedBitfield(True, state._db)
paginated_bitfield.update_used_page_in_address_state(
address, addresses_state, 1)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
ots_indexes = list(range(0, 2**alice_xmss.height))
random.shuffle(ots_indexes)
for i in ots_indexes:
paginated_bitfield.set_ots_key(addresses_state, address, i)
if i == ots_indexes[-1]:
self.assertEqual(address_state.ots_bitfield_used_page, 4)
self.assertEqual(address_state.ots_bitfield_used_page, 4)
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.alice.set_ots_index(10)
self.maxDiff = None
def test_put(self, mock_dev_config):
with set_xrd_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 __init__(self, *args, **kwargs):
super(TestTokenTransaction, self).__init__(*args, **kwargs)
with set_xrd_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_generate_bitfield_key(self):
with set_xrd_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_put_paginated_data(self, mock_dev_config):
with set_xrd_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_reset_key_value(self):
with set_xrd_dir('no_data'):
state = State()
p = PaginatedData(b'p_tx_hash', True, state._db)
self.assertEqual(len(p.key_value), 0)
p.key_value[b'a'] = [10]
self.assertEqual(len(p.key_value), 1)
p.reset_key_value()
self.assertEqual(len(p.key_value), 0)
def test_transferCoins_push_unsigned(self):
with set_xrd_dir('wallet_ver1'):
with State() as db_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)
context = Mock(spec=ServicerContext)
alice = get_alice_xmss()
bob = get_bob_xmss()
request = xrd_pb2.TransferCoinsReq(
addresses_to=[bob.address],
amounts=[101],
fee=12,
xmss_pk=alice.pk
)
response = service.TransferCoins(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertIsNotNone(response)
self.assertIsNotNone(response.extended_transaction_unsigned)
self.assertEqual('transfer', response.extended_transaction_unsigned.tx.WhichOneof('transactionType'))
self.assertEqual(12, response.extended_transaction_unsigned.tx.fee)
self.assertEqual(alice.pk, response.extended_transaction_unsigned.tx.public_key)
self.assertEqual(0, response.extended_transaction_unsigned.tx.nonce)
self.assertEqual(b'', response.extended_transaction_unsigned.tx.signature)
self.assertEqual(b'', response.extended_transaction_unsigned.tx.transaction_hash)
self.assertEqual(bob.address, response.extended_transaction_unsigned.tx.transfer.addrs_to[0])
self.assertEqual(101, response.extended_transaction_unsigned.tx.transfer.amounts[0])
req_push = xrd_pb2.PushTransactionReq(transaction_signed=response.extended_transaction_unsigned.tx)
resp_push = service.PushTransaction(req_push, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertIsNotNone(resp_push)
self.assertEqual(xrd_pb2.PushTransactionResp.VALIDATION_FAILED,
resp_push.error_code)
def test_check_mock(self):
with set_xrd_dir('no_data'):
with State() as state:
self.assertIsNotNone(state) # to avoid warning (unused variable)
state.get_block = Mock()
state.get_block.side_effect = self.get_block_list_example1()
block = state.get_block(b'0')
self.assertEqual(10, block.timestamp)
self.assertEqual(0, block.block_number)
self.assertEqual(b'0', block.headerhash)
def __init__(self, *args, **kwargs):
super(TestMultiSigSpend, self).__init__(*args, **kwargs)
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.random = get_alice_xmss(4)
self.random_signer = get_bob_xmss(4)
self.signatories = [
self.alice.address, self.bob.address, self.random.address
]
self.weights = [20, 30, 10]
self.threshold = 30
def test_measurement_1(self, mock_get_block):
with set_xrd_dir('no_data'):
with State() as state:
self.assertIsNotNone(state) # to avoid warning (unused variable)
chain_manager = ChainManager(state)
mock_get_block.side_effect = TestStateMeasurement.get_block_example1
parent_metadata = Mock()
parent_metadata.last_N_headerhashes = [b'0']
measurement = chain_manager.get_measurement(config.dev, 210, b'1', parent_metadata)
self.assertEqual(55, measurement)
measurement = chain_manager.get_measurement(config.dev, 250, b'1', parent_metadata)
self.assertEqual(75, measurement)
def test_unset_ots_key3(self, mock_ots_bitfield_size,
mock_ots_tracking_per_page):
"""
Features Tested
- Sequentially marking OTS indexes as used
- Sequentially marking OTS indexes as unused
- ots_bitfield_used_page value with each OTS index being used
Expectation
- The ots_bitfield_used_page must increase by 1 for every sequential 1024 (ots_tracking_per_page) ots indexes
marked as used
:param mock_ots_bitfield_size:
:param mock_ots_tracking_per_page:
:return:
"""
with set_xrd_dir('no_data'):
state = State()
mock_ots_bitfield_size.return_value = ceil(
config.dev.ots_tracking_per_page / 8)
alice_xmss = get_alice_xmss(12)
address = alice_xmss.address
address_state = OptimizedAddressState.get_default(address)
addresses_state = {address: address_state}
paginated_bitfield = PaginatedBitfield(True, state._db)
paginated_bitfield.update_used_page_in_address_state(
address, addresses_state, 1)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
total_ots = 2**alice_xmss.height
for i in range(0, total_ots + 1):
paginated_bitfield.set_ots_key(addresses_state, address, i)
self.assertEqual(address_state.ots_bitfield_used_page,
(i + 1) // config.dev.ots_tracking_per_page)
self.assertEqual(address_state.ots_bitfield_used_page,
total_ots // config.dev.ots_tracking_per_page)
self.assertEqual(total_ots // config.dev.ots_tracking_per_page, 4)
paginated_bitfield.unset_ots_key(addresses_state, address,
total_ots - 1)
self.assertEqual(address_state.ots_bitfield_used_page, 3)
for i in range(total_ots - 2, -1, -1):
paginated_bitfield.unset_ots_key(addresses_state, address, i)
self.assertEqual(address_state.ots_bitfield_used_page,
i // config.dev.ots_tracking_per_page)
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
self.params = {
"message_hash": b'Test Message',
"addr_to": None,
"fee": 1,
"xmss_pk": self.alice.pk
}
self.m_addr_state = Mock(autospec=OptimizedAddressState,
name='addr_state',
balance=200)
self.m_addr_from_pk_state = Mock(autospec=OptimizedAddressState,
name='addr_from_pk_state')
def test_load_bitfield_and_ots_key_reuse(self):
with set_xrd_dir('no_data'):
state = State()
alice_xmss = get_alice_xmss(4)
paginated_bitfield = PaginatedBitfield(True, state._db)
self.assertFalse(
paginated_bitfield.load_bitfield_and_ots_key_reuse(
alice_xmss.address, 0))
addresses_state = {
alice_xmss.address:
OptimizedAddressState.get_default(alice_xmss.address)
}
paginated_bitfield.set_ots_key(addresses_state, alice_xmss.address,
0)
self.assertTrue(
paginated_bitfield.load_bitfield_and_ots_key_reuse(
alice_xmss.address, 0))
def state_migration_step_2(self, state: State):
"""
Migration Step from State Version 0 to 1
:return:
"""
del self._tmp_state
self._tmp_state = None
del state._db
tmp_db_dir = os.path.join(config.user.data_dir,
config.dev.db_name + "3")
db_dir = os.path.join(config.user.data_dir, config.dev.db_name)
shutil.move(db_dir, tmp_db_dir)
tmp_db_dir = os.path.join(config.user.data_dir,
config.dev.db_name + "2")
shutil.move(tmp_db_dir, db_dir)
state._db = db.DB()
logger.warning("State Migration Finished")
def setUp(self):
with set_xrd_dir('no_data'):
self.state = State()
self.alice = get_alice_xmss()
alice_address_state = OptimizedAddressState.get_default(
self.alice.address)
alice_address_state.pbdata.balance = 100
self.addresses_state = {self.alice.address: alice_address_state}
self.params = {
"message_hash": b'Test Message',
"addr_to": None,
"fee": 1,
"xmss_pk": self.alice.pk
}
self.unused_chain_manager_mock = Mock(autospec=ChainManager,
name='unused ChainManager')
