def parse(raw_data):
deserializer = Deserializer(raw_data)
tx_type = deserializer.parse_u8()
if tx_type == Type.PUBLIC:
tx = PublicKeyTransaction()
elif tx_type == Type.RANDOM:
tx = SplitRandomTransaction()
elif tx_type == Type.PRIVATE:
tx = PrivateKeyTransaction()
elif tx_type == Type.COMMIT:
tx = CommitRandomTransaction()
elif tx_type == Type.REVEAL:
tx = RevealRandomTransaction()
elif tx_type == Type.STAKEHOLD:
tx = StakeHoldTransaction()
elif tx_type == Type.STAKERELEASE:
tx = StakeReleaseTransaction()
elif tx_type == Type.PENALTY:
tx = PenaltyTransaction()
elif tx_type == Type.NEGATIVE_GOSSIP:
tx = NegativeGossipTransaction()
elif tx_type == Type.POSITIVE_GOSSIP:
tx = PositiveGossipTransaction()
elif tx_type == Type.PENALTY_GOSSIP:
tx = PenaltyGossipTransaction()
elif tx_type == Type.PAYMENT:
tx = PaymentTransaction()
else:
assert False, "Cannot parse unknown transaction type"
tx.parse(deserializer.data)
return tx
def create_negative_gossip_transaction(number_of_block, node_private):
tx = NegativeGossipTransaction()
tx.timestamp = Time.get_current_time()
tx.number_of_block = number_of_block
tx.pubkey = Private.publickey(node_private)
tx.signature = Private.sign(tx.get_hash(), node_private)
return tx
def get_negative_gossips_by_block(self, block_number):
"""
Method return all gossips in current mempool by gossip tx type negative for block_number
:param block_number: gossip tx_type for filtering gossip list
:return: typed gossip list by block number
"""
result = []
typed_gossips = self.get_gossips_by_type(NegativeGossipTransaction())
for gossip in typed_gossips:
if gossip.number_of_block == block_number:
result.append(gossip)
return result
def test_pack_parse_penalty_gossip_transaction(self):
private = Private.generate()
original = PenaltyGossipTransaction()
original.timestamp = Time.get_current_time()
block = BlockFactory.create_block_with_timestamp(
[], timestamp=original.timestamp)
gossip_positive_tx = PositiveGossipTransaction()
gossip_positive_tx.pubkey = Private.publickey(private)
gossip_positive_tx.timestamp = Time.get_current_time()
gossip_positive_tx.block_hash = BlockFactory.sign_block(
block, private).get_hash()
gossip_positive_tx.signature = Private.sign(original.get_hash(),
private)
gossip_negative_tx = NegativeGossipTransaction()
gossip_negative_tx.pubkey = Private.publickey(private)
gossip_negative_tx.timestamp = Time.get_current_time()
gossip_negative_tx.number_of_block = 47
gossip_negative_tx.signature = Private.sign(original.get_hash(),
private)
original.conflicts = [
gossip_positive_tx.get_hash(),
gossip_negative_tx.get_hash()
]
original.signature = Private.sign(original.get_hash(), private)
original.block_hash = BlockFactory.sign_block(block,
private).get_hash()
raw = original.pack()
restored = PenaltyGossipTransaction()
restored.parse(raw)
self.assertEqual(original.get_hash(), restored.get_hash())
def test_parse_pack_gossip_negative(self):
private = Private.generate()
original = NegativeGossipTransaction()
original.pubkey = Private.publickey(private)
original.timestamp = Time.get_current_time()
original.number_of_block = 47
original.signature = Private.sign(original.get_hash(), private)
raw = original.pack()
restored = NegativeGossipTransaction()
restored.parse(raw)
self.assertEqual(original.get_hash(), restored.get_hash())
def test_remove_from_validators_by_penalty_gossip(self):
# base initialization
dag = Dag(0)
epoch = Epoch(dag)
permissions = Permissions(epoch)
node_private = Private.generate()
initial_validators = Validators.read_genesis_validators_from_file()
genesis_hash = dag.genesis_block().get_hash()
prev_hash = genesis_hash
for i in range(1, 9):
block = BlockFactory.create_block_with_timestamp([prev_hash],
BLOCK_TIME * i)
signed_block = BlockFactory.sign_block(block, node_private)
dag.add_signed_block(i, signed_block)
prev_hash = block.get_hash()
# get one of validators
genesis_validator_private = Private.generate()
genesis_validator_public = initial_validators[9].public_key
# put to 10 block gossip+ AND gossip- by one node
block = BlockFactory.create_block_with_timestamp([prev_hash],
BLOCK_TIME * 10)
gossip_negative_tx = NegativeGossipTransaction()
gossip_negative_tx.pubkey = genesis_validator_public
gossip_negative_tx.timestamp = Time.get_current_time()
gossip_negative_tx.number_of_block = 5
gossip_negative_tx.signature = Private.sign(
gossip_negative_tx.get_hash(), genesis_validator_private)
# create and add to block negative gossip
block.system_txs.append(gossip_negative_tx)
gossip_positive_tx = PositiveGossipTransaction()
gossip_positive_tx.pubkey = genesis_validator_public
gossip_positive_tx.timestamp = Time.get_current_time()
gossip_positive_tx.block_hash = dag.blocks_by_number[5][0].get_hash()
gossip_positive_tx.signature = Private.sign(
gossip_positive_tx.get_hash(), genesis_validator_private)
# create and add to block positive gossip for same number 5 block
block.system_txs.append(gossip_positive_tx)
signed_block = BlockFactory.sign_block(block,
genesis_validator_private)
dag.add_signed_block(10, signed_block)
prev_hash = block.get_hash()
# --------------------------------------------------
# put to 11 block penalty gossip
block = BlockFactory.create_block_with_timestamp([prev_hash],
BLOCK_TIME * 11)
penalty_gossip_tx = PenaltyGossipTransaction()
penalty_gossip_tx.timestamp = Time.get_current_time()
penalty_gossip_tx.conflicts = [
gossip_positive_tx.get_hash(),
gossip_negative_tx.get_hash()
]
# set genesis validator for sign penalty gossip
penalty_gossip_tx.signature = Private.sign(
penalty_gossip_tx.get_hash(), genesis_validator_private)
block.system_txs.append(penalty_gossip_tx)
signed_block = BlockFactory.sign_block(block,
genesis_validator_private)
dag.add_signed_block(11, signed_block)
prev_hash = block.get_hash()
# --------------------------------------------------
# verify that genesis node is steel in validators list
current_epoch_hash = epoch.get_epoch_hashes()
# for now we DO NOT NEED to recalculate validators (send genesis block hash)
resulting_validators = permissions.get_validators(
current_epoch_hash.get(prev_hash))
pub_keys = []
for validator in resulting_validators:
pub_keys.append(validator.public_key)
self.assertIn(genesis_validator_public, pub_keys)
# produce epoch till end
from chain.params import ROUND_DURATION
for i in range(12, (ROUND_DURATION * 6 + 4)):
block = BlockFactory.create_block_with_timestamp([prev_hash],
BLOCK_TIME * i)
signed_block = BlockFactory.sign_block(block, node_private)
dag.add_signed_block(i, signed_block)
prev_hash = block.get_hash()
# check for new epoch
self.assertTrue(epoch.is_new_epoch_upcoming(i))
self.assertTrue(epoch.current_epoch == 2)
# recalculate validators for last block hash
resulting_validators = permissions.get_validators(prev_hash)
pub_keys = []
for validator in resulting_validators:
pub_keys.append(validator.public_key)
self.assertNotIn(genesis_validator_public, pub_keys)
def get_all_negative_gossips(self):
"""
Method for get all negatives
:return: all currnt negatives from mempool
"""
return self.get_gossips_by_type(NegativeGossipTransaction())
def get_negative_gossips(self):
return self.get_txs_by_type(NegativeGossipTransaction())