def try_to_publish_public_key(self, current_block_number):
if self.epoch_private_keys:
return
epoch_hashes = self.epoch.get_epoch_hashes()
for _, epoch_hash in epoch_hashes.items():
allowed_round_validators = self.permissions.get_ordered_randomizers_pubkeys_for_round(
epoch_hash, Round.PUBLIC)
pubkey_publishers_pubkeys = [
validator.public_key for validator in allowed_round_validators
]
if self.node_pubkey in pubkey_publishers_pubkeys:
node_private = self.block_signer.private_key
pubkey_index = self.permissions.get_signer_index_from_public_key(
self.node_pubkey, epoch_hash)
generated_private = Private.generate()
tx = TransactionFactory.create_public_key_transaction(
generated_private=generated_private,
epoch_hash=epoch_hash,
validator_index=pubkey_index,
node_private=node_private)
if self.behaviour.malicious_wrong_signature:
tx.signature = b'0' + tx.signature[1:]
self.epoch_private_keys.append(generated_private)
self.logger.debug("Broadcasted public key")
self.logger.debug(Keys.to_visual_string(tx.generated_pubkey))
self.mempool.add_transaction(tx)
self.network.broadcast_transaction(self.node_id,
TransactionParser.pack(tx))
def form_split_random_transaction(self, top_hash, epoch_hash):
ordered_senders = self.permissions.get_ordered_randomizers_pubkeys_for_round(
epoch_hash, Round.PUBLIC)
published_pubkeys = self.epoch.get_public_keys_for_epoch(top_hash)
self.logger.info("Ordered pubkeys for secret sharing:")
sorted_published_pubkeys = []
for sender in ordered_senders:
raw_pubkey = Keys.to_bytes(sender.public_key)
raw_pubkey_index = self.permissions.get_signer_index_from_public_key(
raw_pubkey, epoch_hash)
if raw_pubkey_index in published_pubkeys:
generated_pubkey = published_pubkeys[raw_pubkey_index]
sorted_published_pubkeys.append(
Keys.from_bytes(generated_pubkey))
self.logger.info(Keys.to_visual_string(generated_pubkey))
else:
sorted_published_pubkeys.append(None)
self.logger.info("None")
tx = self.form_secret_sharing_transaction(sorted_published_pubkeys,
epoch_hash)
return tx
def __init__(self,
genesis_creation_time,
node_id,
network,
block_signer=BlockSigner(Private.generate()),
validators=Validators(),
behaviour=Behaviour(),
logger=DummyLogger()):
self.logger = logger
self.dag = Dag(genesis_creation_time)
self.epoch = Epoch(self.dag)
self.epoch.set_logger(self.logger)
self.permissions = Permissions(self.epoch, validators)
self.mempool = Mempool()
self.utxo = Utxo(self.logger)
self.conflict_watcher = ConflictWatcher(self.dag)
self.behaviour = behaviour
self.block_signer = block_signer
self.node_pubkey = Private.publickey(block_signer.private_key)
self.logger.info("Public key is %s",
Keys.to_visual_string(self.node_pubkey))
self.network = network
self.node_id = node_id
self.epoch_private_keys = [] # TODO make this single element
# self.epoch_private_keys where first element is era number, and second is key to reveal commited random
self.reveals_to_send = {}
self.sent_shares_epochs = [] # epoch hashes of secret shares
self.last_expected_timeslot = 0
self.last_signed_block_number = 0
self.tried_to_sign_current_block = False
self.owned_utxos = []
self.terminated = False
self.blocks_buffer = [
] # uses while receive block and do not have its ancestor in local dag (before verify)
