Create Personalized Blockchain in 60 Minutes
Tags: blockchain, node, python, cybersecurity
Published: 2022-01-14 17:03:08

Welcome. Without any further ado let us see how to create a blockchain with Python. Before that have a look at the basic terminologies of Blockchain.

**Blockchain**: Fixed and permanent record of transaction that is verified and thus appended ahead of each other.

**Block**: A single transaction that is appended to the blockchain.

**Genesis Block**: The initial most block that is hard coded into the block chain and has no previous hash is Genesis Block.

**Contents of Block**: A block consists of all the general information like Time of transaction, Hash Data Generated, Previous Hash and transaction data(sender/receiver information)

**Python Code-Along**
We will be using functions of datetime library and sha256 from hashlib that is famously used for password and in the case of Blockchain, for verifying transactions.

**Step 1:**_Import the libraries discussed and create a Block class that resembles the conceptual creation of Linked List in ths manner_

```
import datetime
from hashlib import sha256

class Block:
    def __init__(self, transactions, previous_hash):
        self.time_stamp = datetime.datetime.now()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = 0
        self.hash = self.generate_hash()

    def generate_hash(self):
         pass
      
    def print_contents(self):
         pass

```
We are done with creating the skeleton of our block, it is time to make it secure with our ultra-protected cipher.

**Step 2:**_Completing the incomplete functions in our code._


```
import datetime
from hashlib import sha256

class Block:
    def __init__(self, transactions, previous_hash):
        self.time_stamp = datetime.datetime.now()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = 0
        self.hash = self.generate_hash()

    def generate_hash(self):
        block_header = str(self.time_stamp) + str(self.transactions) +str(self.previous_hash) + str(self.nonce)
        block_hash = sha256(block_header.encode())
        return block_hash.hexdigest()

    def print_contents(self):
        print("timestamp:", self.time_stamp)
        print("transactions:", self.transactions)
        print("current hash:", self.generate_hash())
        print("previous hash:", self.previous_hash) 
```
Voila, you are done with creating your own block that will generate a cryptographic hash and store all the relevant details of a transaction.

**Step 3:** _We are in a new file altogether importing the block file in Blockchain file before hopping the endgame i.e main file. We will be doin git this way for better code reusability and optimization_

```
from block import Block

class Blockchain:
    def __init__(self):
        self.chain = []
        self.unconfirmed_transactions = []
        self.genesis_block()

    def genesis_block(self):
        transactions = []
        genesis_block = Block(transactions, "0")
        genesis_block.generate_hash()
        self.chain.append(genesis_block)

    def add_block(self, transactions):
        previous_hash = (self.chain[len(self.chain)-1]).hash
        new_block = Block(transactions, previous_hash)
        new_block.generate_hash()
        # proof = proof_of_work(block)
        self.chain.append(new_block)

    def print_blocks(self):
        for i in range(len(self.chain)):
            current_block = self.chain[i]
            print("Block {} {}".format(i, current_block))
            current_block.print_contents()
```
The unconfirmed transactions lie in the mempool until they are done so by participants in the blockchain. Participant is responsible for their proof of work to authorize the transaction.
In case you need to know more about proof of work, Internet has sources for you in one go. 

**Step 4:**
Creating the proof of work and validation of transaction method to make a fully-functioning blockchain.

```
from block import Block

class Blockchain:
    def __init__(self):
        self.chain = []
        self.unconfirmed_transactions = []
        self.genesis_block()

    def genesis_block(self):
        transactions = []
        genesis_block = Block(transactions, "0")
        genesis_block.generate_hash()
        self.chain.append(genesis_block)

    def add_block(self, transactions):
        previous_hash = (self.chain[len(self.chain)-1]).hash
        new_block = Block(transactions, previous_hash)
        new_block.generate_hash()
        # proof = proof_of_work(block)
        self.chain.append(new_block)

    def print_blocks(self):
        for i in range(len(self.chain)):
            current_block = self.chain[i]
            print("Block {} {}".format(i, current_block))
            current_block.print_contents()

    def validate_chain(self):
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i-1]
            if(current.hash != current.generate_hash()):
                print("Current hash does not equal generated hash")
                return False
            if(current.previous_hash != previous.generate_hash()):
                print("Previous block's hash got changed")
                return False
        return True
 
    def proof_of_work(self, block, difficulty=2):
        proof = block.generate_hash()
        while proof[:2] != "0"*difficulty:
            block.nonce += 1
            proof = block.generate_hash()
        block.nonce = 0
        return proof
      
```

The value in the generated hash will be starting with a character and go on until the length of nonce pipelined into the sha256 algorithm to check if a certain condition is met with verification done and that is the prototype on how proof of work works. 

Proof of work also avoid attacks which is the reason it was introduced in working of Bitcoin in 2009.
Moving onto the last step by actually creating and testing our Blockchain.

**Final Step**

```
from blockchain import Blockchain

block_one_transactions = {"sender":"Alice", "receiver": "Bob", "amount":"50"}
block_two_transactions = {"sender": "Bob", "receiver":"Cole", "amount":"25"}
block_three_transactions = {"sender":"Alice", "receiver":"Cole", "amount":"35"}
fake_transactions = {"sender": "Bob", "receiver":"Cole, Alice", "amount":"25"}

local_blockchain = Blockchain()
local_blockchain.print_blocks()

local_blockchain.add_block(block_one_transactions)
local_blockchain.add_block(block_two_transactions)
local_blockchain.add_block(block_three_transactions)
local_blockchain.print_blocks()
local_blockchain.chain[2].transactions = fake_transactions
local_blockchain.validate_chain()

```

**HERE IS THE OUTPUT OF OUR HARD WORK**
![Received Output](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ep9zxr6j2q7z8t1up53g.jpg)