def add_transaction(self, transaction: SignedRawTransaction, is_receiving: bool = False) -> int: """ Creates a new transaction to go into the next mined Block :param transaction: <SignedRawTransaction> A single Transaction :param is_receiving: Optional <bool> Use to determine if the transaction was created by this node or another on the network :return: <int> The index of the Block that will hold this transaction """ if Verification.verify_transaction(transaction, self.get_balance, self.get_last_tx_nonce): final_tx = FinalTransaction( transaction_hash=Verification.hash_transaction(transaction), transaction_id=Verification.hash_transaction(transaction), signed_transaction=transaction, ) self.__open_transactions.append(final_tx) self.save_data() if not is_receiving: self.__broadcast_transaction(transaction, "open") else: raise ValueError( "The sender does not have enough coin to make this " "transaction. We may want to change this to not raise " "an exception later, but for now, we should break.") return self.last_block.index + 1
def broadcast_transaction(): # pylint: disable=unused-variable """ Broadcasts a new transaction to all the nodes Returns a status message Methods ----- POST Parameters ----- transaction : SignedRawTransaction as hex Returns application/json ----- Return code : 201, 400, 500 Response : message : str transaction : optional Transaction as Dict """ values = request.get_json() if not values: response = {"message": "No data found."} return jsonify(response), 400 required = ["transaction", "type"] if not all(key in values for key in required): response = {"message": "Some data is missing."} return jsonify(response), 400 t = SignedRawTransaction.ParseFromHex(values["transaction"]) try: if values["type"] == "mining" or values["type"] == "confirmed": tx = FinalTransaction( transaction_hash=Verification.hash_transaction(t), transaction_id=Verification.hash_transaction(t), signed_transaction=t, ) FinalTransaction.SaveTransaction(blockchain.data_location, tx, values["type"]) response = { "message": f"Successfully saved {values['type']} transaction.", "transaction": values["transaction"], } return jsonify(response), 201 block_index = blockchain.add_transaction(t, is_receiving=True) response = { "message": "Successfully added transaction.", "transaction": values["transaction"], "block": block_index, } return jsonify(response), 201 except ValueError as e: response = { "message": "Creating a transaction failed.", "error": str(e) } return jsonify(response), 500
def test_mining_block_with_open_transactions(): timestamp = datetime.utcfromtimestamp(0) node_id = uuid4() w1 = Wallet(test=True) w2 = Wallet(test=True) chain = Blockchain(w1.address, node_id, difficulty=1, is_test=True) tx_details_1 = Details( sender=w1.address, recipient=w2.address, nonce=0, amount=0.5, timestamp=timestamp, public_key=w1.public_key.hex(), ) transaction_1 = w1.sign_transaction(tx_details_1) tx_details_2 = Details( sender=w2.address, recipient=w1.address, nonce=0, amount=0.5, timestamp=timestamp, public_key=w2.public_key.hex(), ) transaction_2 = w2.sign_transaction(tx_details_2) assert Verification.verify_chain(chain.chain) # Need to give the w1 at least 1.0 coin in their balance chain.mine_block() assert Verification.verify_chain(chain.chain) chain.add_transaction(transaction_1, is_receiving=True) chain.mine_block() assert Verification.verify_chain(chain.chain) chain_transactions = [] for block in chain.chain: for tx in block.transactions: chain_transactions.append(tx) assert Verification.hash_transaction(transaction_1) in chain_transactions chain.add_transaction(transaction_2, is_receiving=True) chain.mine_block() chain_transactions = [] for block in chain.chain: for tx in block.transactions: chain_transactions.append(tx) assert Verification.hash_transaction(transaction_2) in chain_transactions
def test_correct_nonce(): timestamp = datetime.utcfromtimestamp(0) block_one = Block( index=0, block_hash="", size=0, header=Header( timestamp=timestamp, transaction_merkle_root="", nonce=100, previous_hash="", difficulty=4, version=1, ), transaction_count=0, transactions=[], ) previous_hash = Verification.hash_block_header(block_one.header) open_transactions = [ SignedRawTransaction( details=Details( sender="test2", recipient="test", amount=2.5, nonce=0, timestamp=timestamp, public_key="pub_key", ), signature="sig", ) ] block_header = Header( version=1, difficulty=4, timestamp=datetime.utcfromtimestamp(1), transaction_merkle_root=get_merkle_root(open_transactions), previous_hash=previous_hash, nonce=0, ) block_header = Verification.proof_of_work(block_header) block_two = Block( index=1, block_hash="", size=0, header=block_header, transaction_count=len(open_transactions), transactions=[ Verification.hash_transaction(t) for t in open_transactions ], ) assert Verification.valid_nonce(block_two.header)
def test_block_hash_mutliple_transaction_field_order_doesnt_matter(): timestamp = datetime.utcfromtimestamp(0) transactions = [ SignedRawTransaction( details=Details( sender="test", recipient="test2", amount=5.0, nonce=0, timestamp=timestamp, public_key="pub_key", ), signature="sig", ), SignedRawTransaction( details=Details( sender="test2", recipient="test", amount=2.5, nonce=0, timestamp=timestamp, public_key="pub_key", ), signature="sig", ), ] tx_merkle_root = get_merkle_root(transactions) block = Block( index=0, block_hash="", size=0, header=Header( timestamp=timestamp, transaction_merkle_root=tx_merkle_root, nonce=100, previous_hash="", difficulty=4, version=1, ), transaction_count=2, transactions=[Verification.hash_transaction(t) for t in transactions], ) first_hash = Verification.hash_block_header(block.header) block = Block( index=0, block_hash="", size=0, header=Header( timestamp=timestamp, transaction_merkle_root=tx_merkle_root, nonce=100, previous_hash="", difficulty=4, version=1, ), transaction_count=2, transactions=[Verification.hash_transaction(t) for t in transactions], ) second_hash = Verification.hash_block_header(block.header) assert first_hash == second_hash
def mine_block( self, address: Optional[str] = None, difficulty: Optional[int] = None, version: Optional[int] = None, ) -> Optional[Block]: """ The current node runs the mining protocol, and depending on the difficulty, this could take a lot of processing power. Once the nonce is discovered, or "mined", the reward transaction is created. Then all of the open transactions are validated and verified, ensuring that the senders in all of the transactions have enough coin to conduct the transaction. Once the transactions are validated, the reward block is added to the list of open transactions. This is because Mining transactions do not need to be validated since they are created by the node itself. The block is then added directy to the node's chain and the open_transactions is cleared and ready for a new block to be mined Finally, the new block is broadcasted to all connected nodes. """ if not address: address = self.address if not address: return None difficulty = difficulty if difficulty is not None else self.difficulty version = version if version is not None else self.version last_block = self.last_block transaction_merkle_root = get_merkle_root( [tx.signed_transaction for tx in self.get_open_transactions]) previous_hash = Verification.hash_block_header(last_block.header) block_header = Header( version=version, difficulty=difficulty, timestamp=datetime.utcnow(), transaction_merkle_root=transaction_merkle_root, previous_hash=previous_hash, nonce=0, ) # We run the PoW algorithm to get the next nonce and return an updated block_header block_header = Verification.proof_of_work(block_header) # Create the transaction that will be rewarded to the miners for their work # The sender is "0" or "Mining" to signify that this node has mined a new coin. reward_signed = SignedRawTransaction( details=Details( sender="0", recipient=address, nonce=0, amount=MINING_REWARD, timestamp=datetime.utcnow(), public_key="coinbase", ), signature="coinbase", ) reward_transaction = FinalTransaction( transaction_hash=Verification.hash_transaction(reward_signed), transaction_id=Verification.hash_transaction(reward_signed), signed_transaction=reward_signed, ) # Copy transactions instead of manipulating the original open_transactions list # This ensures that if for some reason the mining should fail, # we don't have the reward transaction stored in the pending transactions copied_open_transactions = self.get_open_transactions for tx in copied_open_transactions: if not Wallet.verify_transaction(tx.signed_transaction, self.get_last_tx_nonce, exclude_from_open=True): return None FinalTransaction.SaveTransaction(self.data_location, reward_transaction, "mining") self.__broadcast_transaction(reward_transaction.signed_transaction, "mining") for t in copied_open_transactions: self.__broadcast_transaction(t.signed_transaction, "confirmed") copied_open_transactions.append(reward_transaction) block = Block( index=self.next_index, header=block_header, block_hash=Verification.hash_block_header(block_header), size=len(str(block_header)), transaction_count=len(copied_open_transactions), transactions=[ t.transaction_hash for t in copied_open_transactions ], ) # Add the block to the node's chain self.add_block_to_chain(block) # Reset the open list of transactions logger.info("Moving open transaction to confirmed storage at %s", self.data_location) FinalTransaction.MoveOpenTransactions(self.data_location) self.__open_transactions = [] self.save_data() self.__broadcast_block(block) return block