def filter_out_skipped_public_keys(private_keys, public_keys):
filtered_private_keys = []
for private_key in private_keys:
if private_key == None:
filtered_private_keys.append(None)
else:
expected_public = Private.publickey(
Keys.from_bytes(private_key))
if Keys.to_bytes(expected_public) in public_keys.values():
filtered_private_keys.append(private_key)
return filtered_private_keys
def is_signature_valid_for_at_least_one_epoch(self, transaction):
if hasattr(transaction, "pubkey"):
public_key = Keys.from_bytes(transaction.pubkey)
signature_valid_for_at_least_one_epoch = False
epoch_hashes = self.epoch.get_epoch_hashes()
for _top, epoch_hash in epoch_hashes.items():
if Acceptor.check_transaction_signature(transaction, public_key, epoch_hash):
signature_valid_for_at_least_one_epoch = True
break
if not signature_valid_for_at_least_one_epoch:
raise AcceptionException("Signature is not valid for any epoch!")
def reveal_commited_random(self, block_hash):
if block_hash == self.dag.genesis_block().get_hash():
return 0
seed = 0
commits = self.get_commits_for_epoch(block_hash)
reveals = self.get_reveals_for_epoch(block_hash)
randoms_list = []
for reveal in reveals:
if reveal.commit_hash in commits:
commit = commits[reveal.commit_hash]
key = Keys.from_bytes(reveal.key)
revealed_data = Private.decrypt(commit.rand, key)
randoms_list.append(
int.from_bytes(revealed_data, byteorder='big'))
seed = sum_random(randoms_list)
return seed
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 test_commit_reveal(self):
dag = Dag(0)
epoch = Epoch(dag)
private = Private.generate()
prev_hash = ChainGenerator.fill_with_dummies(
dag,
dag.genesis_block().get_hash(),
Epoch.get_round_range(1, Round.PUBLIC))
randoms_list = []
for i in Epoch.get_round_range(1, Round.COMMIT):
random_value = int.from_bytes(os.urandom(32), byteorder='big')
randoms_list.append(random_value)
expected_seed = sum_random(randoms_list)
reveals = []
epoch_hash = dag.genesis_block().get_hash()
for i in Epoch.get_round_range(1, Round.COMMIT):
rand = randoms_list.pop()
random_bytes = rand.to_bytes(32, byteorder='big')
commit, reveal = TestEpoch.create_dummy_commit_reveal(
random_bytes, epoch_hash)
commit_block = BlockFactory.create_block_with_timestamp(
[prev_hash], i * BLOCK_TIME)
commit_block.system_txs = [commit]
signed_block = BlockFactory.sign_block(commit_block, private)
dag.add_signed_block(i, signed_block)
prev_hash = commit_block.get_hash()
reveals.append(reveal)
revealing_key = Keys.from_bytes(reveal.key)
encrypted_bytes = Public.encrypt(random_bytes,
Private.publickey(revealing_key))
decrypted_bytes = Private.decrypt(encrypted_bytes, revealing_key)
# TODO check if encryption decryption can work million times in a row
self.assertEqual(decrypted_bytes, random_bytes)
revealed_value = Private.decrypt(commit.rand, revealing_key)
self.assertEqual(revealed_value, random_bytes)
# self.assertEqual(len(reveals), ROUND_DURATION)
prev_hash = ChainGenerator.fill_with_dummies(
dag, prev_hash, Epoch.get_round_range(1, Round.SECRETSHARE))
for i in Epoch.get_round_range(1, Round.REVEAL):
reveal_block = BlockFactory.create_block_with_timestamp(
[prev_hash], i * BLOCK_TIME)
reveal_block.system_txs = [reveals.pop()]
signed_block = BlockFactory.sign_block(reveal_block, private)
dag.add_signed_block(i, signed_block)
prev_hash = reveal_block.get_hash()
prev_hash = ChainGenerator.fill_with_dummies(
dag, prev_hash, Epoch.get_round_range(1, Round.PRIVATE))
prev_hash = ChainGenerator.fill_with_dummies(
dag, prev_hash, Epoch.get_round_range(1, Round.FINAL))
seed = epoch.reveal_commited_random(prev_hash)
self.assertEqual(expected_seed, seed)
def release_stake(validators, pubkey):
for i in range(len(validators)):
if validators[i].public_key == Keys.from_bytes(pubkey):
del validators[i]
break
def hold_stake(validators, pubkey, stake):
validators.append(Validator(Keys.from_bytes(pubkey), stake))