def test_getTotalBalance(self):
db_state = Mock(spec=State)
xmss1 = get_alice_xmss()
xmss2 = get_alice_xmss(4)
xmss3 = get_bob_xmss(4)
address_state1 = AddressState.create(address=xmss1.address,
nonce=25,
balance=1000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state2 = AddressState.create(address=xmss2.address,
nonce=25,
balance=2000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
address_state3 = AddressState.create(address=xmss3.address,
nonce=25,
balance=3000,
ots_bitfield=[b'\x00'] *
config.dev.ots_bitfield_size,
tokens=dict(),
slave_pks_access_type=dict(),
ots_counter=0)
m = MockFunction()
m.put(xmss1.address, address_state1)
m.put(xmss2.address, address_state2)
m.put(xmss3.address, address_state3)
db_state.get_address_state = m.get
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.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 test_getStakers(self):
db_state = Mock(spec=State)
db_state.stake_validators_tracker = Mock(spec=StakeValidatorsTracker)
db_state.stake_validators_tracker.sv_dict = dict()
p2p_factory = Mock(spec=P2PFactory)
buffered_chain = Mock(spec=BufferedChain)
buffered_chain.tx_pool = Mock()
buffered_chain.get_block = Mock()
buffered_chain._chain = Mock()
qrlnode = QRLNode(db_state)
qrlnode.set_p2pfactory(p2p_factory)
qrlnode.set_chain(buffered_chain)
service = PublicAPIService(qrlnode)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT,
offset=0,
quantity=3)
response = service.GetStakers(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertEqual(0, len(response.stakers))
# Add a few validators
stake_tx = StakeTransaction.create(1, get_alice_xmss(),
get_bob_xmss().pk(),
sha256(b'terminator'))
expected_address = bytes(get_alice_xmss().get_address().encode())
db_state.get_address = MagicMock(
return_value=AddressState.create(address=expected_address,
nonce=1,
balance=100,
pubhashes=[],
tokens=dict()))
db_state.get_address_tx_hashes = MagicMock(return_value=[])
validator1 = StakeValidator.create(100, stake_tx)
db_state.stake_validators_tracker.sv_dict[
validator1.address] = validator1
request = qrl_pb2.GetStakersReq(filter=qrl_pb2.GetStakersReq.CURRENT,
offset=0,
quantity=3)
response = service.GetStakers(request=request, context=context)
context.set_code.assert_not_called()
context.set_details.assert_not_called()
self.assertEqual(1, len(response.stakers))
self.assertEqual(expected_address,
response.stakers[0].address_state.address)
def test_validate_signature(self):
xmss = get_alice_xmss()
xmss2 = get_alice_xmss(8)
pk = xmss.pk
signature = xmss.sign(b"hello")
self.assertTrue(XMSS.validate_signature(signature, pk))
with self.assertRaises(ValueError):
XMSS.validate_signature(signature, None)
self.assertFalse(XMSS.validate_signature(signature, xmss2.pk))
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_relay_slave_txn(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
qaddress = walletd.add_new_address(height=4)
walletd.encrypt_wallet(self.passphrase)
walletd.unlock_wallet(self.passphrase)
alice_xmss = get_alice_xmss(4)
slave_pks = [alice_xmss.pk]
access_types = [0]
walletd._public_stub.PushTransaction = Mock(
return_value=qrl_pb2.PushTransactionResp(
error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
tx = walletd.relay_slave_txn(slave_pks=slave_pks,
access_types=access_types,
fee=100000000,
master_qaddress=None,
signer_address=qaddress,
ots_index=0)
self.assertIsNotNone(tx)
walletd.lock_wallet()
with self.assertRaises(ValueError):
walletd.relay_slave_txn(slave_pks=slave_pks,
access_types=access_types,
fee=100000000,
master_qaddress=None,
signer_address=qaddress,
ots_index=0)
def test_relay_transfer_token_txn(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
qaddress = walletd.add_new_address(height=4)
walletd.encrypt_wallet(self.passphrase)
walletd.unlock_wallet(self.passphrase)
alice_xmss = get_alice_xmss(4)
bob_xmss = get_bob_xmss(4)
qaddresses_to = [alice_xmss.qaddress, bob_xmss.qaddress]
amounts = [1000000000, 1000000000]
walletd._public_stub.PushTransaction = Mock(
return_value=qrl_pb2.PushTransactionResp(
error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
tx = walletd.relay_transfer_token_txn(qaddresses_to=qaddresses_to,
amounts=amounts,
token_txhash='',
fee=100000000,
master_qaddress=None,
signer_address=qaddress,
ots_index=0)
self.assertIsNotNone(tx)
walletd.lock_wallet()
with self.assertRaises(ValueError):
walletd.relay_transfer_token_txn(qaddresses_to=qaddresses_to,
amounts=amounts,
token_txhash='',
fee=100000000,
master_qaddress=None,
signer_address=qaddress,
ots_index=0)
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 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_relaySlaveTxn(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(),
context=None)
qaddress = resp.address
alice_xmss = get_alice_xmss(4)
slave_pks = [alice_xmss.pk]
access_types = [0]
walletd._public_stub.PushTransaction = Mock(
return_value=qrl_pb2.PushTransactionResp(
error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
resp = service.RelaySlaveTxn(qrlwallet_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_sync_state_change_synced(self):
chain_manager = Mock()
chain_manager.height = 0
chain_manager.get_block = MagicMock(return_value=GenesisBlock())
chain_manager.last_block = GenesisBlock()
chain_manager.tx_pool = Mock()
chain_manager.tx_pool.transaction_pool = []
get_block_metadata_response = Mock()
get_block_metadata_response.block_difficulty = StringToUInt256('2')
chain_manager.state.get_block_metadata = MagicMock(return_value=get_block_metadata_response)
alice_xmss = get_alice_xmss()
chain_manager.state.get_address = MagicMock(return_value=AddressState.get_default(alice_xmss.get_address()))
chain_manager.state.get_measurement = MagicMock(return_value=60)
p2p_factory = Mock()
sync_state = Mock()
time_provider = Mock()
node = POW(chain_manager=chain_manager,
p2p_factory=p2p_factory,
sync_state=sync_state,
time_provider=time_provider,
slaves=get_random_master())
self.assertIsNotNone(node)
node.update_node_state(ESyncState.synced)
def test_relayTokenTxn(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(),
context=None)
qaddress = resp.address
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=qrl_pb2.PushTransactionResp(
error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
resp = service.RelayTokenTxn(qrlwallet_pb2.RelayTokenTxnReq(
symbol=b'QRL',
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_prepare_address_list(self):
with set_qrl_dir('no_data'):
with State() as state:
block = Block.create(block_number=10,
prev_headerhash=b'',
prev_timestamp=10,
transactions=[],
miner_address=get_some_address(1))
# Test Case: without any transactions of block
self.assertEqual(state.prepare_address_list(block),
{config.dev.coinbase_address, get_some_address(1)})
alice_xmss = get_alice_xmss()
block = Block.create(block_number=10,
prev_headerhash=b'',
prev_timestamp=10,
transactions=[TransferTransaction.create(addrs_to=[get_some_address(2),
get_some_address(3)],
amounts=[100, 100],
fee=0,
xmss_pk=alice_xmss.pk)],
miner_address=get_some_address(1))
# Test Case, with one Transaction
self.assertEqual(state.prepare_address_list(block),
{config.dev.coinbase_address,
get_some_address(1),
get_some_address(2),
get_some_address(3),
alice_xmss.address})
def test_add_vote2(self):
validator_xmss1 = get_alice_xmss()
slave_xmss1 = XMSS(validator_xmss1.height, validator_xmss1.get_seed())
stake_amount1 = 101.5012
headerhash1 = b'ffff'
vote1 = Vote.create(addr_from=validator_xmss1.get_address().encode(),
blocknumber=0,
headerhash=headerhash1,
xmss=slave_xmss1)
vote1.sign(slave_xmss1)
vote_metadata = VoteMetadata()
vote_metadata.add_vote(vote=vote1, stake_amount=stake_amount1)
self.assertIn(vote1.txfrom, vote_metadata.stake_validator_vote)
validator_xmss2 = get_random_xmss()
slave_xmss2 = XMSS(validator_xmss2.height, validator_xmss2.get_seed())
stake_amount2 = 10000
headerhash2 = b'ffff'
vote2 = Vote.create(addr_from=validator_xmss2.get_address().encode(),
blocknumber=0,
headerhash=headerhash2,
xmss=slave_xmss2)
vote2.sign(slave_xmss2)
vote_metadata.add_vote(vote=vote2, stake_amount=stake_amount2)
self.assertIn(vote2.txfrom, vote_metadata.stake_validator_vote)
total_stake_amount = stake_amount1 + stake_amount2
self.assertEqual(total_stake_amount, vote_metadata.total_stake_amount)
def test_get_all_address_state(self):
with set_qrl_dir('no_data'):
with State() as state:
addresses_state = state.get_all_address_state()
self.assertEqual(len(addresses_state), 0)
alice_xmss = get_alice_xmss()
alice_address = alice_xmss.address
address_state = state.get_address_state(alice_address)
addresses_state = {
alice_address: address_state
}
self.assertTrue(isinstance(address_state.address, bytes))
state.put_addresses_state(addresses_state)
addresses_state = state.get_all_address_state()
self.assertEqual(len(addresses_state), 1)
bob_xmss = get_bob_xmss()
bob_address = bob_xmss.address
address_state = state.get_address_state(bob_address)
addresses_state = {
bob_address: address_state
}
self.assertTrue(isinstance(address_state.address, bytes))
state.put_addresses_state(addresses_state)
addresses_state = state.get_all_address_state()
self.assertEqual(len(addresses_state), 2)
def test_sync_state_change_synced(self):
chain_manager = Mock()
chain_manager.height = 0
chain_manager.get_block = MagicMock(return_value=GenesisBlock())
chain_manager.last_block = GenesisBlock()
chain_manager.tx_pool = Mock()
chain_manager.tx_pool.transaction_pool = []
get_block_metadata_response = Mock()
get_block_metadata_response.block_difficulty = StringToUInt256('2')
chain_manager.state.get_block_metadata = MagicMock(return_value=get_block_metadata_response)
alice_xmss = get_alice_xmss()
chain_manager.state.get_address = MagicMock(return_value=AddressState.get_default(alice_xmss.address))
chain_manager.state.get_measurement = MagicMock(return_value=60)
p2p_factory = Mock()
sync_state = Mock()
time_provider = Mock()
node = POW(chain_manager=chain_manager,
p2p_factory=p2p_factory,
sync_state=sync_state,
time_provider=time_provider,
slaves=get_random_master(),
mining_thread_count=0)
self.assertIsNotNone(node)
node.update_node_state(ESyncState.synced)
def test_relayTransferTokenTxn(self):
with set_qrl_dir("wallet_ver1"):
walletd = WalletD()
service = WalletAPIService(walletd)
resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(),
context=None)
qaddress = resp.address
alice_xmss = get_alice_xmss(4)
bob_xmss = get_bob_xmss(4)
qaddresses_to = [alice_xmss.qaddress, bob_xmss.qaddress]
amounts = [1000000000, 1000000000]
walletd._public_stub.PushTransaction = Mock(
return_value=qrl_pb2.PushTransactionResp(
error_code=qrl_pb2.PushTransactionResp.SUBMITTED))
resp = service.RelayTransferTokenTxn(
qrlwallet_pb2.RelayTransferTokenTxnReq(
addresses_to=qaddresses_to,
amounts=amounts,
token_txhash='',
fee=100000000,
master_address=None,
signer_address=qaddress,
ots_index=0),
context=None)
self.assertEqual(resp.code, 0)
self.assertIsNotNone(resp.tx)
def test_update_used_page_in_address_state4(self, mock_ots_bitfield_size, mock_ots_tracking_per_page):
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, self.state._db)
paginated_bitfield.update_used_page_in_address_state(address, addresses_state, 1)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
for i in range(2048, 3072):
paginated_bitfield.set_ots_key(addresses_state, address, i)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
for i in range(1024, 2048):
paginated_bitfield.set_ots_key(addresses_state, address, i)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
for i in range(0, 1024):
paginated_bitfield.set_ots_key(addresses_state, address, i)
if i + 1 == 1024:
self.assertEqual(address_state.ots_bitfield_used_page, 3)
for i in range(3072, 2 ** alice_xmss.height):
paginated_bitfield.set_ots_key(addresses_state, address, i)
if i + 1 == 2 ** alice_xmss.height:
self.assertEqual(address_state.ots_bitfield_used_page, 4)
else:
self.assertEqual(address_state.ots_bitfield_used_page, 3)
self.assertEqual(address_state.ots_bitfield_used_page, 4)
def test_update_used_page_in_address_state(self):
alice_xmss = get_alice_xmss(4)
address = alice_xmss.address
address_state = OptimizedAddressState.get_default(address)
addresses_state = {address: address_state}
paginated_bitfield = PaginatedBitfield(True, self.state._db)
key = paginated_bitfield.generate_bitfield_key(address, 1)
paginated_bitfield.update_used_page_in_address_state(address, addresses_state, 1)
self.assertEqual(address_state.ots_bitfield_used_page, 0)
for i in range(0, 16):
paginated_bitfield.set_ots_key(addresses_state, address, i)
if i != 15:
self.assertEqual(address_state.ots_bitfield_used_page, 0)
else:
self.assertEqual(address_state.ots_bitfield_used_page, 1)
for i in range(0, 16):
ots_bitfield = paginated_bitfield.key_value[key]
ots_key_index = i % config.dev.ots_tracking_per_page
offset = ots_key_index >> 3
relative = ots_key_index % 8
bitfield = bytearray(ots_bitfield[offset])
self.assertEqual(bytes([bitfield[0] >> relative & 1]), b'\x01')
self.assertEqual(address_state.ots_bitfield_used_page, 1)
def test_get_block_size_limit(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
self.assertEqual(state.get_block_size_limit(blocks[-1]),
1048576)
def test_ots_key_reuse(self, mock_ots_bitfield_size, mock_ots_tracking_per_page):
"""
Randomly using OTS key
:return:
"""
with set_qrl_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_set_ots_key2(self, mock_ots_bitfield_size, mock_ots_tracking_per_page):
"""
Randomly using OTS key
:return:
"""
with set_qrl_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 test_remove_transfer_token_metadata(self):
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_transaction = get_token_transaction(alice_xmss, bob_xmss)
TokenMetadata.create_token_metadata(self.state, token_transaction,
None)
transfer_token = TransferTokenTransaction.create(
token_txhash=token_transaction.txhash,
addrs_to=[alice_xmss.address],
amounts=[100000000],
fee=1,
xmss_pk=bob_xmss.pk)
transfer_token.sign(alice_xmss)
TokenMetadata.update_token_metadata(self.state, transfer_token, None)
token_metadata = TokenMetadata.get_token_metadata(
self.state, transfer_token.token_txhash)
self.assertIn(transfer_token.txhash,
token_metadata.transfer_token_tx_hashes)
TokenMetadata.remove_transfer_token_metadata(self.state,
transfer_token, None)
token_metadata = TokenMetadata.get_token_metadata(
self.state, transfer_token.token_txhash)
self.assertNotIn(transfer_token.txhash,
token_metadata.transfer_token_tx_hashes)
def test_remove_transfer_token_metadata(self):
with set_qrl_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_transaction = get_token_transaction(alice_xmss, bob_xmss)
state.create_token_metadata(token_transaction)
transfer_token = TransferTokenTransaction.create(token_txhash=token_transaction.txhash,
addrs_to=[alice_xmss.address],
amounts=[100000000],
fee=1,
xmss_pk=bob_xmss.pk)
transfer_token.sign(alice_xmss)
state.update_token_metadata(transfer_token)
token_metadata = state.get_token_metadata(transfer_token.token_txhash)
self.assertIn(transfer_token.txhash,
token_metadata.transfer_token_tx_hashes)
state.remove_transfer_token_metadata(transfer_token)
token_metadata = state.get_token_metadata(transfer_token.token_txhash)
self.assertNotIn(transfer_token.txhash,
token_metadata.transfer_token_tx_hashes)
def test_state_object(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
blocks = gen_blocks(20, state, alice_xmss.address)
self.assertEqual(state.state_objects.total_coin_supply(), 0)
self.assertEqual(state.state_objects.state_loaders, [])
state.state_objects.append_state_loader(StateLoader(b'current_', state._db))
self.assertIsNotNone(state.state_objects.get_state_loader_by_index(0))
state.state_objects.destroy_state_loader(0)
self.assertEqual(state.state_objects.state_loaders, [])
self.assertIsNone(state.state_objects.get(b'current'))
state.state_objects.push(blocks[-1].headerhash, None)
self.assertEqual(len(state.state_objects.state_loaders), 1)
loader = state.state_objects.state_loaders[0]
loader.increase_txn_count(state._db, b'', 0, alice_xmss.address)
self.assertEqual(loader.get_txn_count(state._db, b'', alice_xmss.address), 1)
self.assertEqual(loader.get_last_txs(state._db, b''), [])
loader.commit(StateLoader(b'current_', state._db))
loader.update_last_tx(blocks[-1], None)
loader.commit(StateLoader(b'current_', state._db))
state.state_objects.update_current_state({alice_xmss.address: state._get_address_state(alice_xmss.address)})
self.assertEqual(state.state_objects.get_txn_count(alice_xmss.address), 1)
state.state_objects.increase_txn_count(alice_xmss.address)
self.assertEqual(state.state_objects.get_last_txs(), [])
state.state_objects.update_last_tx(blocks[-1], None)
state.state_objects.update_tx_metadata(blocks[-1], None)
self.assertEqual(state.state_objects.get_last_txs(), [])
state.state_objects.destroy_fork_states(blocks[-1].block_number, blocks[-1].headerhash)
state.state_objects.destroy_current_state(None)
self.assertIsNone(state.state_objects.get(b'current'))
def test_validate_transaction_pool_reusing_ots_index(self, m_logger):
"""
Two different TransferTransactions. They are signed with the same OTS indexe, from the same public key.
Therefore they should conflict.
:return:
"""
tx = self.tx
tx2 = TransferTransaction.create(addrs_to=[self.bob.address],
amounts=[100],
message_data=None,
fee=5,
xmss_pk=self.alice.pk)
# alice_clone's OTS index is still at 10, while self.alice will be at 11 after signing.
alice_clone = get_alice_xmss()
alice_clone.set_ots_index(10)
tx.sign(self.alice)
tx2.sign(alice_clone)
tx_info = Mock(autospec=TransactionInfo, transaction=tx)
tx2_info = Mock(autospec=TransactionInfo, transaction=tx2)
transaction_pool = [(replacement_getTime(), tx_info),
(replacement_getTime(), tx2_info)]
result = tx.validate_transaction_pool(transaction_pool)
self.assertFalse(result)
def test_getTransactionsByAddress(self):
db_state = Mock(spec=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)
# Find a transaction
alice_xmss = get_alice_xmss()
db_state.get_address_state = MagicMock(
return_value=AddressState.get_default(alice_xmss.address))
db_state.address_used = MagicMock(return_value=False)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetTransactionsByAddressReq(
address=alice_xmss.address)
response = service.GetTransactionsByAddress(request=request,
context=context)
context.set_code.assert_not_called()
self.assertEqual(len(response.mini_transactions), 0)
self.assertEqual(response.balance, 0)
def __init__(self, *args, **kwargs):
super(TestMessageTransaction, self).__init__(*args, **kwargs)
self.alice = get_alice_xmss()
self.bob = get_bob_xmss()
self.alice.set_ots_index(10)
self.maxDiff = None
def test_create(self):
alice_xmss = get_alice_xmss()
slave_xmss = XMSS(alice_xmss.height, alice_xmss.get_seed())
staking_address = bytes(alice_xmss.get_address().encode())
h0 = sha256(b'hashchain_seed')
h1 = sha256(h0)
h2 = sha256(h1)
stake_transaction = StakeTransaction.create(activation_blocknumber=0,
xmss=alice_xmss,
slavePK=slave_xmss.pk(),
hashchain_terminator=h2)
sv = StakeValidator(100, stake_transaction)
self.assertEqual(staking_address, sv.address)
self.assertEqual(slave_xmss.pk(), sv.slave_public_key)
self.assertEqual(h2, sv.terminator_hash)
self.assertEqual(100, sv.balance)
self.assertEqual(0, sv.nonce)
self.assertFalse(sv.is_banned)
self.assertTrue(sv.is_active)
def test_getBlockByNumber(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)
alice_xmss = get_alice_xmss()
b = Block.create(block_number=1,
prev_headerhash=sha256(b'reveal'),
prev_timestamp=10,
transactions=[],
miner_address=alice_xmss.address)
db_state.get_block_by_number = MagicMock(return_value=b)
context = Mock(spec=ServicerContext)
request = qrl_pb2.GetBlockByNumberReq(block_number=b.block_number)
response = service.GetBlockByNumber(request=request, context=context)
context.set_code.assert_not_called()
self.assertEqual(1, response.block.header.block_number)
def test_getHeight(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)
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 test_get_address2(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
alice_address = alice_xmss.get_address()
address_state = state.get_address(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
state._save_address_state(address_state)
address_state = state.get_address(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
def test_create_token_metadata(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_transaction = get_token_transaction(alice_xmss, bob_xmss)
state.create_token_metadata(token_transaction)
token_metadata = state.get_token_metadata(token_transaction.txhash)
self.assertEqual(token_metadata.token_txhash, token_transaction.txhash)
self.assertEqual(token_metadata.transfer_token_tx_hashes[0], token_transaction.txhash)
def test_get_address(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
alice_address = alice_xmss.get_address()
address_state = state.get_address(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
alice_address = bytearray(alice_xmss.get_address())
with self.assertRaises(TypeError):
address_state = state.get_address(alice_address)
alice_address = alice_xmss.get_address()
address_state = state.get_address(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
state._save_address_state(address_state)
address_state = state.get_address(alice_address)
self.assertTrue(isinstance(address_state.address, bytes))
def test_update_token_metadata(self):
with set_data_dir('no_data'):
with State() as state:
alice_xmss = get_alice_xmss()
bob_xmss = get_bob_xmss()
token_transaction = get_token_transaction(alice_xmss, bob_xmss)
state.create_token_metadata(token_transaction)
transfer_token_transaction = TransferTokenTransaction.create(addr_from=bob_xmss.get_address(),
token_txhash=token_transaction.txhash,
addr_to=alice_xmss.get_address(),
amount=100000000,
fee=1,
xmss_pk=bob_xmss.pk(),
xmss_ots_index=bob_xmss.get_index())
state.update_token_metadata(transfer_token_transaction)
token_metadata = state.get_token_metadata(token_transaction.txhash)
self.assertEqual(len(token_metadata.transfer_token_tx_hashes), 2)
self.assertEqual(token_metadata.transfer_token_tx_hashes[0], token_transaction.txhash)
self.assertEqual(token_metadata.transfer_token_tx_hashes[1], transfer_token_transaction.txhash)
def test_orphan_block(self):
"""
Testing add_block logic in case of orphan_blocks
:return:
"""
with mock.patch('qrl.core.config.DevConfig') as devconfig:
devconfig.genesis_difficulty = 2
devconfig.minimum_minting_delay = 10
with set_data_dir('no_data'):
with State() as state: # FIXME: Move state to temporary directory
state.get_measurement = MagicMock(return_value=10000000)
genesis_block = GenesisBlock()
chain_manager = ChainManager(state)
chain_manager.load(genesis_block)
chain_manager._difficulty_tracker = Mock()
dt = DifficultyTracker()
tmp_difficulty = StringToUInt256('2')
tmp_boundary = dt.get_boundary(tmp_difficulty)
chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_boundary))
block = state.get_block(genesis_block.headerhash)
self.assertIsNotNone(block)
alice_xmss = get_alice_xmss()
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 # Very high to get an easy difficulty
block_1 = Block.create(mining_nonce=10,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
signing_xmss=alice_xmss,
master_address=alice_xmss.get_address(),
nonce=1)
block_1.set_mining_nonce(10)
while not chain_manager.validate_mining_nonce(block_1, False):
block_1.set_mining_nonce(block_1.mining_nonce + 1)
result = chain_manager.add_block(block_1)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
bob_xmss = get_bob_xmss()
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 2
block = Block.create(mining_nonce=18,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=1)
block.set_mining_nonce(18)
while not chain_manager.validate_mining_nonce(block, False):
block.set_mining_nonce(block.mining_nonce + 1)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 + devconfig.minimum_minting_delay * 3
block_2 = Block.create(mining_nonce=17,
block_number=2,
prevblock_headerhash=block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=2)
block_2.set_mining_nonce(17)
result = chain_manager.add_block(block_2)
self.assertTrue(result)
result = chain_manager.add_block(block)
self.assertTrue(result)
block = state.get_block(block.headerhash)
self.assertIsNotNone(block)
self.assertEqual(chain_manager.last_block.block_number, block_1.block_number)
self.assertEqual(chain_manager.last_block.headerhash, block_1.headerhash)
def test_add_block(self):
"""
Testing add_block, with fork logic
:return:
"""
with set_data_dir('no_data'):
with State() as state:
state.get_measurement = MagicMock(return_value=10000000)
alice_xmss = get_alice_xmss()
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_boundary = dt.get_boundary(tmp_difficulty)
chain_manager._difficulty_tracker.get = MagicMock(return_value=(tmp_difficulty, tmp_boundary))
block = state.get_block(genesis_block.headerhash)
self.assertIsNotNone(block)
slave_tx = SlaveTransaction.create(addr_from=alice_xmss.get_address(),
slave_pks=[bob_xmss.pk()],
access_types=[0],
fee=0,
xmss_pk=alice_xmss.pk(),
xmss_ots_index=alice_xmss.get_index())
slave_tx.sign(alice_xmss)
slave_tx._data.nonce = 2
self.assertTrue(slave_tx.validate())
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1615270948 # Very high to get an easy difficulty
block_1 = Block.create(mining_nonce=10,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[slave_tx],
signing_xmss=alice_xmss,
master_address=alice_xmss.get_address(),
nonce=1)
while not chain_manager.validate_mining_nonce(block_1, False):
block_1.set_mining_nonce(block_1.mining_nonce + 1)
result = chain_manager.add_block(block_1)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
alice_state = chain_manager.get_address(alice_xmss.get_address())
self.assertEqual(len(alice_state.slave_pks_access_type), 1)
self.assertTrue(str(bob_xmss.pk()) in alice_state.slave_pks_access_type)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1715270948 # Very high to get an easy difficulty
block = Block.create(mining_nonce=15,
block_number=1,
prevblock_headerhash=genesis_block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=1)
while not chain_manager.validate_mining_nonce(block, False):
block.set_mining_nonce(block.mining_nonce + 1)
result = chain_manager.add_block(block)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block, block_1)
block = state.get_block(block.headerhash)
self.assertIsNotNone(block)
with mock.patch('qrl.core.misc.ntp.getTime') as time_mock:
time_mock.return_value = 1815270948 # Very high to get an easy difficulty
block_2 = Block.create(mining_nonce=15,
block_number=2,
prevblock_headerhash=block.headerhash,
transactions=[],
signing_xmss=bob_xmss,
master_address=bob_xmss.get_address(),
nonce=2)
while not chain_manager.validate_mining_nonce(block_2, False):
block_2.set_mining_nonce(block_2.mining_nonce + 1)
result = chain_manager.add_block(block_2)
self.assertTrue(result)
self.assertEqual(chain_manager.last_block.block_number, block_2.block_number)
self.assertEqual(chain_manager.last_block.to_json(), block_2.to_json())
