def test_voided_token_creation(self):
tx1 = create_tokens(self.manager,
self.address_b58,
mint_amount=500,
use_genesis=False)
token_uid = tx1.tokens[0]
# check tokens index
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
token_uid)
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertEqual(1, len(mint))
self.assertEqual(1, len(melt))
# add simple tx that will void the token created above
tx2 = add_new_double_spending(self.manager,
tx=tx1,
weight=(tx1.weight + 3),
use_same_parents=True)
self.assertFalse(bool(tx2.get_metadata().voided_by))
self.assertTrue(bool(tx1.get_metadata().voided_by))
mint = list(tokens_index.iter_mint_utxos())
melt = list(tokens_index.iter_melt_utxos())
self.assertEqual(0, len(mint))
self.assertEqual(0, len(melt))
with self.assertRaises(KeyError):
tokens_index = self.manager.tx_storage.indexes.tokens.get_token_info(
token_uid)
print(tokens_index)
def test_dont_revert_block_high_weight_transaction_verify_other(self):
""" A conflict transaction will be propagated and voided. But this transaction
verifies its conflicting transaction. So, its accumulated weight will always be smaller
than the others and it will never be executed.
"""
self.assertEqual(len(self.genesis_blocks), 1)
manager = self.create_peer('testnet', tx_storage=self.tx_storage)
# Mine a few blocks in a row with no transaction but the genesis
blocks = add_new_blocks(manager, 3, advance_clock=15)
add_blocks_unlock_reward(manager)
# Add some transactions between blocks
add_new_transactions(manager, 5, advance_clock=15)
# Create a double spending transaction.
conflicting_tx = add_new_double_spending(manager)
meta = conflicting_tx.get_metadata()
self.assertEqual(len(meta.conflict_with), 1)
self.assertIn(list(meta.conflict_with)[0], conflicting_tx.parents)
# Add a few transactions.
add_new_transactions(manager, 10, advance_clock=15)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
# These blocks will be voided later.
blocks2 = add_new_blocks(manager, 2, advance_clock=15)
# This block verifies the conflicting transaction and has a high weight.
b0 = manager.generate_mining_block()
b0.parents = [
blocks[-1].hash, conflicting_tx.hash, conflicting_tx.parents[0]
]
# b0.parents = [b0.parents[0], conflicting_tx.hash, conflicting_tx.parents[0]]
b0.weight = 10
b0.resolve()
b0.verify()
manager.propagate_tx(b0, fails_silently=False)
b1 = add_new_block(manager, advance_clock=15)
b2 = add_new_block(manager, advance_clock=15)
# dot = GraphvizVisualizer(manager.tx_storage, include_verifications=True, include_funds=True).dot()
# dot.render('dot2')
self.assertNotEqual(b1.parents[0], b0.hash)
self.assertEqual(b2.parents[0], b1.hash)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
for block in blocks2:
meta = block.get_metadata()
self.assertIsNone(meta.voided_by)
self.assertConsensusValid(manager)
def test_dont_revert_block_low_weight(self):
""" A conflict transaction will be propagated and voided.
A new block with low weight will verify it, which won't be enough to flip to executed.
So, it will remain voided.
"""
self.assertEqual(len(self.genesis_blocks), 1)
manager = self.create_peer('testnet', tx_storage=self.tx_storage)
# Mine a few blocks in a row with no transaction but the genesis
blocks = add_new_blocks(manager, 3, advance_clock=15)
add_blocks_unlock_reward(manager)
# Add some transactions between blocks
add_new_transactions(manager, 5, advance_clock=15)
# Create a double spending transaction.
conflicting_tx = add_new_double_spending(manager,
use_same_parents=True)
# Add a few transactions.
add_new_transactions(manager, 10, advance_clock=15)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
for parent_hash in conflicting_tx.parents:
self.assertNotIn(parent_hash, meta.conflict_with)
# These blocks will be voided later.
add_new_blocks(manager, 2, advance_clock=15)
# This block verifies the conflicting transaction and has a low weight.
# So, it is not enough to revert and this block will be voided as well.
b0 = manager.generate_mining_block()
b0.parents = [
blocks[-1].hash, conflicting_tx.hash, conflicting_tx.parents[0]
]
b0.resolve()
b0.verify()
manager.propagate_tx(b0, fails_silently=False)
b1 = add_new_block(manager, advance_clock=15)
b2 = add_new_block(manager, advance_clock=15)
# dot = GraphvizVisualizer(manager.tx_storage, include_verifications=True, include_funds=True).dot()
# dot.render('dot1')
self.assertNotEqual(b1.parents[0], b0.hash)
self.assertEqual(b2.parents[0], b1.hash)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
b0_meta = b0.get_metadata()
self.assertEqual(b0_meta.voided_by, {b0.hash, conflicting_tx.hash})
self.assertConsensusValid(manager)
def test_dont_revert_block_high_weight_verify_both(self):
""" A conflicting transaction will be propagated and voided. But the block with high weight
verifies both the conflicting transactions, so this block will always be voided.
"""
self.assertEqual(len(self.genesis_blocks), 1)
manager = self.create_peer('testnet', tx_storage=self.tx_storage)
# Mine a few blocks in a row with no transaction but the genesis
add_new_blocks(manager, 3, advance_clock=15)
add_blocks_unlock_reward(manager)
# Add some transactions between blocks
add_new_transactions(manager, 5, advance_clock=15)
# Create a double spending transaction.
conflicting_tx = add_new_double_spending(manager,
use_same_parents=True)
# Add a few transactions.
add_new_transactions(manager, 10, advance_clock=15)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
for parent_hash in conflicting_tx.parents:
self.assertNotIn(parent_hash, meta.conflict_with)
# Add two blocks.
blocks2 = add_new_blocks(manager, 2, advance_clock=15)
# This block verifies the conflicting transaction and has a high weight.
b0 = manager.generate_mining_block()
b0.parents = [
b0.parents[0], conflicting_tx.hash, conflicting_tx.parents[0]
]
b0.weight = 10
b0.resolve()
b0.verify()
manager.propagate_tx(b0, fails_silently=False)
b1 = add_new_block(manager, advance_clock=15)
b2 = add_new_block(manager, advance_clock=15)
# dot = GraphvizVisualizer(manager.tx_storage, include_verifications=True, include_funds=True).dot()
# dot.render('dot3')
self.assertNotEqual(b1.parents[0], b0.hash)
self.assertEqual(b2.parents[0], b1.hash)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
for block in blocks2:
meta = block.get_metadata()
self.assertIsNone(meta.voided_by)
self.assertConsensusValid(manager)
def test_tips_back(self):
add_new_block(self.manager, advance_clock=1)
add_blocks_unlock_reward(self.manager)
self.assertEqual(
len(self.manager.tx_storage.indexes.mempool_tips.get()), 0)
tx = add_new_transactions(self.manager, 1, advance_clock=1)[0]
# tx will be the tip
self.assertCountEqual(
self.manager.tx_storage.indexes.mempool_tips.get(), set([tx.hash]))
tx2 = add_new_transactions(self.manager, 1, advance_clock=1)[0]
# tx2 will be the tip now
self.assertCountEqual(
self.manager.tx_storage.indexes.mempool_tips.get(),
set([tx2.hash]))
# with a double spending tx2 must continue being the tip
add_new_double_spending(self.manager)
self.assertCountEqual(
self.manager.tx_storage.indexes.mempool_tips.get(),
set([tx2.hash]))
def test_init_not_voided_tips(self):
# add a bunch of blocks and transactions
for i in range(30):
add_new_block(self.manager, advance_clock=15)
add_new_transactions(self.manager, 5, advance_clock=15)
# add a bunch of conflicting transactions, these will all become voided
for i in range(50):
add_new_double_spending(self.manager)
# finish up with another bunch of blocks and transactions
for i in range(30):
add_new_block(self.manager, advance_clock=15)
add_new_transactions(self.manager, 5, advance_clock=15)
# not the point of this test, but just a sanity check
self.assertConsensusValid(self.manager)
# make sure we have the right number of voided transactions
self.assertEqual(
50,
sum(
bool(tx.get_metadata().voided_by)
for tx in self.tx_storage.get_all_transactions()))
# create a new manager (which will initialize in the self.create_peer call)
self.tx_storage._reset_cache()
self.manager.stop()
manager = self.create_peer(self.network,
tx_storage=self.tx_storage,
full_verification=False)
# make sure none of its tx tips are voided
all_tips = manager.generate_parent_txs(None).get_all_tips()
iter_tips_meta = map(manager.tx_storage.get_metadata, all_tips)
self.assertFalse(any(tx_meta.voided_by for tx_meta in iter_tips_meta))
def test_split_brain(self):
debug_pdf = False
manager1 = self.create_peer(self.network, unlock_wallet=True)
manager1.avg_time_between_blocks = 3
manager2 = self.create_peer(self.network, unlock_wallet=True)
manager2.avg_time_between_blocks = 3
for _ in range(10):
add_new_block(manager1, advance_clock=1)
add_blocks_unlock_reward(manager1)
add_new_block(manager2, advance_clock=1)
add_blocks_unlock_reward(manager2)
self.clock.advance(10)
for _ in range(random.randint(3, 10)):
add_new_transactions(manager1, random.randint(2, 4))
add_new_transactions(manager2, random.randint(3, 7))
add_new_double_spending(manager1)
add_new_double_spending(manager2)
self.clock.advance(10)
self.clock.advance(20)
self.assertTipsNotEqual(manager1, manager2)
self.assertConsensusValid(manager1)
self.assertConsensusValid(manager2)
if debug_pdf:
dot1 = GraphvizVisualizer(manager1.tx_storage,
include_verifications=True).dot()
dot1.render('dot1-pre')
conn = FakeConnection(manager1, manager2)
conn.run_one_step() # HELLO
conn.run_one_step() # PEER-ID
empty_counter = 0
for i in range(1000):
if conn.is_empty():
empty_counter += 1
if empty_counter > 10:
break
else:
empty_counter = 0
conn.run_one_step()
self.clock.advance(0.2)
if debug_pdf:
dot1 = GraphvizVisualizer(manager1.tx_storage,
include_verifications=True).dot()
dot1.render('dot1-post')
dot2 = GraphvizVisualizer(manager2.tx_storage,
include_verifications=True).dot()
dot2.render('dot2-post')
node_sync = conn.proto1.state.get_sync_plugin()
self.assertEqual(node_sync.synced_timestamp, node_sync.peer_timestamp)
self.assertTipsEqual(manager1, manager2)
self.assertConsensusEqual(manager1, manager2)
# self.assertConsensusValid(manager1)
self.assertConsensusValid(manager2)
def test_revert_block_high_weight(self):
""" A conflict transaction will be propagated. At first, it will be voided.
But, a new block with high weight will verify it, which will flip it to executed.
"""
self.assertEqual(len(self.genesis_blocks), 1)
manager = self.create_peer('testnet', tx_storage=self.tx_storage)
# Mine a few blocks in a row with no transaction but the genesis
blocks = add_new_blocks(manager, 3, advance_clock=15)
add_blocks_unlock_reward(manager)
# Add some transactions between blocks
add_new_transactions(manager, 5, advance_clock=15)
# Create a double spending transaction.
conflicting_tx = add_new_double_spending(manager, use_same_parents=True)
# Add a few transactions.
add_new_transactions(manager, 10, advance_clock=15)
meta = conflicting_tx.get_metadata()
self.assertEqual(meta.voided_by, {conflicting_tx.hash})
for parent_hash in conflicting_tx.parents:
self.assertNotIn(parent_hash, meta.conflict_with)
# These blocks will be voided later.
blocks2 = add_new_blocks(manager, 2, advance_clock=15)
# This block verifies the conflicting transaction and has a high weight.
# So, it will be executed and previous blocks and transactions will be voided.
tb0 = manager.make_custom_block_template(blocks[-1].hash, [conflicting_tx.hash, conflicting_tx.parents[0]])
b0 = tb0.generate_mining_block(storage=manager.tx_storage)
b0.weight = 10
b0.resolve()
b0.verify()
manager.propagate_tx(b0, fails_silently=False)
b1 = add_new_block(manager, advance_clock=15)
b2 = add_new_block(manager, advance_clock=15)
# from hathor.graphviz import GraphvizVisualizer
# dot = GraphvizVisualizer(manager.tx_storage, include_verifications=True, include_funds=True).dot()
# dot.render('dot0')
self.assertEqual(b1.parents[0], b0.hash)
self.assertEqual(b2.parents[0], b1.hash)
meta = conflicting_tx.get_metadata()
self.assertIsNone(meta.voided_by)
# Find the other transaction voiding the blocks.
tmp_tx = manager.tx_storage.get_transaction(blocks2[0].parents[1])
tmp_tx_meta = tmp_tx.get_metadata()
self.assertEqual(len(tmp_tx_meta.voided_by), 1)
other_tx_hash = list(tmp_tx_meta.voided_by)[0]
for block in blocks2:
meta = block.get_metadata()
self.assertEqual(meta.voided_by, {other_tx_hash, block.hash})
self.assertConsensusValid(manager)
def test_twin_tx(self):
add_new_blocks(self.manager, 5, advance_clock=15)
add_blocks_unlock_reward(self.manager)
address = self.get_address(0)
value1 = 100
value2 = 101
value3 = 102
outputs = [
WalletOutputInfo(address=decode_address(address),
value=int(value1),
timelock=None),
WalletOutputInfo(address=decode_address(address),
value=int(value2),
timelock=None)
]
outputs2 = [
WalletOutputInfo(address=decode_address(address),
value=int(value1),
timelock=None),
WalletOutputInfo(address=decode_address(address),
value=int(value3),
timelock=None)
]
tx1 = self.manager.wallet.prepare_transaction_compute_inputs(
Transaction, outputs, self.manager.tx_storage)
tx1.weight = 10
tx1.parents = self.manager.get_new_tx_parents()
tx1.timestamp = int(self.clock.seconds())
tx1.resolve()
# Change of parents only, so it's a twin
tx2 = Transaction.create_from_struct(tx1.get_struct())
tx2.parents = [tx1.parents[1], tx1.parents[0]]
tx2.resolve()
self.assertNotEqual(tx1.hash, tx2.hash)
# The same as tx1 but with one input different, so it's not a twin
tx3 = self.manager.wallet.prepare_transaction_compute_inputs(
Transaction, outputs2, self.manager.tx_storage)
tx3.inputs = tx1.inputs
tx3.weight = tx1.weight
tx3.parents = tx1.parents
tx3.timestamp = tx1.timestamp
tx3.resolve()
self.manager.propagate_tx(tx1)
meta1 = tx1.get_metadata()
self.assertEqual(meta1.conflict_with, None)
self.assertEqual(meta1.voided_by, None)
self.assertEqual(meta1.twins, [])
# Propagate a conflicting twin transaction
self.manager.propagate_tx(tx2)
meta1 = tx1.get_metadata(force_reload=True)
self.assertEqual(meta1.conflict_with, [tx2.hash])
self.assertEqual(meta1.voided_by, {tx1.hash})
self.assertEqual(meta1.twins, [tx2.hash])
meta2 = tx2.get_metadata()
self.assertEqual(meta2.conflict_with, [tx1.hash])
self.assertEqual(meta2.voided_by, {tx2.hash})
self.assertEqual(meta2.twins, [tx1.hash])
# The same as tx1 but with one output different, so it's not a twin
tx3 = add_new_double_spending(self.manager, tx=tx1)
meta1 = tx1.get_metadata()
self.assertEqual(meta1.twins, [tx2.hash])
meta3 = tx3.get_metadata()
self.assertEqual(meta3.twins, [])
self.assertEqual(meta3.conflict_with, [tx1.hash, tx2.hash])
self.assertConsensusValid(self.manager)
