def test_tx_validation_fails(self, m_TransferTransaction_validate,
m_TransferTransaction_validate_extended,
m_TransferTransaction_apply_state_changes,
m_CoinBase_apply_state_changes):
get_optimized_address_state = MockFunction()
get_optimized_address_state.put(self.coinbase_addrstate_attrs.address,
self.coinbase_addrstate_attrs)
get_optimized_address_state.put(self.bob_addrstate_attrs.address,
self.bob_addrstate_attrs)
get_optimized_address_state.put(self.alice_addrstate_attrs.address,
self.alice_addrstate_attrs)
get_optimized_address_state.put(self.slave_addrstate_attrs.address,
self.slave_addrstate_attrs)
block = Block.create(**self.block_attrs)
m_TransferTransaction_validate.return_value = False
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
m_TransferTransaction_validate.return_value = True
m_TransferTransaction_validate_extended.return_value = False
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
m_TransferTransaction_validate_extended.return_value = True
with patch('xrd.core.txs.CoinBase.CoinBase._validate_extended'
) as m_validate_extended:
m_validate_extended.return_value = False
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
def test_bad_nonce_or_ots_reused(self, m_TransferTransaction_validate,
m_TransferTransaction_validate_extended,
m_TransferTransaction_apply_state_changes,
m_CoinBase_apply_state_changes):
# If a TX was signed by a Slave XMSS, apply_state_changes() should check against the Slave's AddressState.nonce.
# In this case, tx.nonce = 3 but slave addrstate.nonce = 0
self.slave_addrstate_attrs.pbdata.nonce = 0
get_optimized_address_state = MockFunction()
get_optimized_address_state.put(self.coinbase_addrstate_attrs.address,
self.coinbase_addrstate_attrs)
get_optimized_address_state.put(self.bob_addrstate_attrs.address,
self.bob_addrstate_attrs)
get_optimized_address_state.put(self.alice_addrstate_attrs.address,
self.alice_addrstate_attrs)
get_optimized_address_state.put(self.slave_addrstate_attrs.address,
self.slave_addrstate_attrs)
block = Block.create(**self.block_attrs)
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
self.slave_addrstate_attrs.pbdata.nonce = 5
# Now we pretend that Alice's OTS key has been reused.
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
# Now we pretend that Slave's OTS key has been reused.
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
def test_check_stale_txn(self, m_is_full_transaction_pool, m_config):
"""
Stale Transactions are Transactions that were supposed to go into block 5, but for some reason didn't make it.
They languish in TransactionPool until check_stale_txn() checks the Pool and updates the tx_info to make them
go into a higher block.
For each stale transaction, P2PFactory.broadcast_tx() will be called.
"""
# Redefine at what point should txs be considered stale
m_config.user.stale_transaction_threshold = 2
bob_xmss = get_bob_xmss(4)
alice_xmss = get_alice_xmss(4)
tx1 = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[1000000],
message_data=None,
fee=1,
xmss_pk=alice_xmss.pk)
tx1.sign(alice_xmss)
tx2 = TransferTransaction.create(addrs_to=[bob_xmss.address],
amounts=[10000],
message_data=None,
fee=1,
xmss_pk=alice_xmss.pk)
tx2.sign(alice_xmss)
m_broadcast_tx = Mock(
name='Mock Broadcast TX function (in P2PFactory)')
self.txpool.add_tx_to_pool(tx1, 5)
self.txpool.add_tx_to_pool(tx2, 5)
self.txpool.set_broadcast_tx(m_broadcast_tx)
with set_qrl_dir('no_data'):
state = State()
chain_manager = ChainManager(state)
self.txpool.check_stale_txn(chain_manager.new_state_container,
chain_manager.update_state_container,
8)
self.assertEqual(m_broadcast_tx.call_count, 0)
m = MockFunction()
bob_address_state = OptimizedAddressState.get_default(
bob_xmss.address)
bob_address_state.pbdata.balance = 1000000000000
m.put(bob_xmss.address, bob_address_state)
chain_manager.get_optimized_address_state = m.get
tx3 = TransferTransaction.create(addrs_to=[alice_xmss.address],
amounts=[10000],
message_data=None,
fee=1,
xmss_pk=bob_xmss.pk)
tx3.sign(bob_xmss)
self.txpool.add_tx_to_pool(tx3, 5)
self.txpool.check_stale_txn(chain_manager.new_state_container,
chain_manager.update_state_container,
8)
self.assertEqual(m_broadcast_tx.call_count, 1)
def test_all_ok(self, m_TransferTransaction_validate,
m_TransferTransaction_validate_extended,
m_TransferTransaction_apply_state_changes,
m_CoinBase_apply_state_changes):
get_optimized_address_state = MockFunction()
get_optimized_address_state.put(self.coinbase_addrstate_attrs.address,
self.coinbase_addrstate_attrs)
get_optimized_address_state.put(self.bob_addrstate_attrs.address,
self.bob_addrstate_attrs)
get_optimized_address_state.put(self.alice_addrstate_attrs.address,
self.alice_addrstate_attrs)
get_optimized_address_state.put(self.slave_addrstate_attrs.address,
self.slave_addrstate_attrs)
self.chain_manager.get_optimized_address_state = get_optimized_address_state.get
block = Block.create(**self.block_attrs)
result = self.chain_manager._apply_state_changes(block, None)
self.assertTrue(result)
def test_extra_coinbase_tx(self, m_TransferTransaction_validate,
m_TransferTransaction_validate_extended,
m_TransferTransaction_apply_state_changes,
m_CoinBase_apply_state_changes):
get_optimized_address_state = MockFunction()
get_optimized_address_state.put(self.coinbase_addrstate_attrs.address,
self.coinbase_addrstate_attrs)
get_optimized_address_state.put(self.bob_addrstate_attrs.address,
self.bob_addrstate_attrs)
get_optimized_address_state.put(self.alice_addrstate_attrs.address,
self.alice_addrstate_attrs)
get_optimized_address_state.put(self.slave_addrstate_attrs.address,
self.slave_addrstate_attrs)
coinbase_extra = CoinBase.create(config.dev, 500, self.alice.address,
5)
self.block_attrs["transactions"] = [self.tx1, coinbase_extra, self.tx2]
block = Block.create(**self.block_attrs)
result = self.chain_manager._apply_state_changes(block, None)
self.assertFalse(result)
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)