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))