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 create_positive_gossip_transaction(block_hash, node_private): tx = PositiveGossipTransaction() tx.timestamp = Time.get_current_time() tx.block_hash = block_hash tx.pubkey = Private.publickey(node_private) tx.signature = Private.sign(tx.get_hash(), node_private) return tx
def create_payment_transaction(from_tx, amount, to, node_private): tx = PaymentTransaction() tx.from_tx = from_tx tx.amount = amount tx.to = to tx.pubkey = Private.publickey(node_private) tx.signature = Private.sign(tx.get_hash(), node_private) return tx
def create_commit_reveal_pair(node_private, random_bytes, pubkey_index, epoch_hash): private = Private.generate() encoded = Private.encrypt(random_bytes, private) commit = TransactionFactory.create_commit_random_transaction( encoded, pubkey_index, epoch_hash, node_private) reveal = TransactionFactory.create_reveal_random_transaction( commit.get_hash(), private) return commit, reveal
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 create_split_random_transaction(encoded_splits, pubkey_index, epoch_hash, node_private): tx = SplitRandomTransaction() tx.pieces = encoded_splits tx.pubkey_index = pubkey_index tx.signature = Private.sign(tx.get_signing_hash(epoch_hash), node_private) return tx
def get_payment_transactions_for_signing(self, block_number): node_public = Private.publickey(self.block_signer.private_key) pseudo_address = sha256(node_public).digest() block_reward = TransactionFactory.create_block_reward( pseudo_address, block_number) block_reward_hash = block_reward.get_hash() self.owned_utxos.append(block_reward_hash) payment_txs = [block_reward] + self.mempool.pop_payment_transactions() return payment_txs
def test_encryption_and_decryption(self): private_keys = [] public_keys = [] for i in range(0, 5): private = Private.generate() private_keys.append(private) public_keys.append(Private.publickey(private)) raw_private_keys = Keys.list_to_bytes(private_keys) decoded_private_keys = Keys.list_from_bytes(raw_private_keys) random_bytes = os.urandom(32) random_value = int.from_bytes(random_bytes, byteorder='big') splits = split_secret(random_bytes, 3, 5) encoded_splits = encode_splits(splits, public_keys) decoded_random = decode_random(encoded_splits, decoded_private_keys) self.assertEqual(random_value, decoded_random)