How to create YOUR own Cryptocurrency!!!

Part - 2: Building blocks and chaining it up (blockchain)

Photo by Launchpresso on Unsplash

Welcome back everyone Lets create a simple blockchain. Hoping everyone read my previous blog else please go through it so that you can understand this one. Those who had missed out click here to have some basic knowledge about blockchain.

In this blog, we will be discussing about creating blocks and chaining it up together to create a simple blockchain. Whoever wondered about blockchain the simple definition is a chain of blocks (seems an answer for an unknown question by a student😂😂).

Chain of blocks (source)

A block may have anything like that of developer’s wish, usually, a block will have previous hash(hash value of the previous block), data and self hash. Now, what is meant by hash here 🤔🤔?? A hash is a function that converts an input of characters and numbers into the encrypted text of fixed length. There are a lot of hash functions, here I am using SHA256 as my hash function. If anybody wants to get an idea about hash function or SHA256 kindly mention in comments I will do a separate blog about that.

I hope we are clear about the technical part for this blog let give work to our keyboard. I am gonna use python language to code.

Let’s code a simple block having data, hash and previous hash

class Block():
    """A Block in BlockChain"""
    data = None
    hash = None
    nonce = 0
    previous_hash = "0" * 64

Here everything was initialized to zero while the previous hash is initialized with 64 digits of zero because the output of SHA256 is 64 digits and the first block will not have any previous hash. Did you find anything odd in the above code? If not please take a look over nonce any idea about what is it?

A nonce is an abbreviation for “number only used once,” which is a number added to a hashed/encrypted block in a blockchain that, when rehashed, meets the difficulty level restrictions.

def __init__(self,data,number=0):
        self.data = data
        self.number = number

The above code snippet is known as the constructor for the block which will initialize the data and the block number respectively. That’s all we have successfully created a block lets go for hashing.

def hash(self):
        return updateHash(
            self.previous_hash,
            self.number,
            self.data,
            self.nonce
        )

I have defined another method hash for the class block which will return the hash of that block. Looking inside it calls updateHash function:

def updateHash(*args):
    hashing_text = ""
    h = sha256()
    for arg in args:
        hashing_text += str(arg)
    h.update(hashing_text.encode('utf-8'))
    return h.hexdigest()

updateHash function accepts n number of arguments which will be appended to a single string which consists of previous block’s hash, block number, data in it and number only used once naming it as hashing_text. As I told earlier I am using SHA256 hash so creating an instance for it and updating hashing_text as encoded utf-8. Now the hexdigest() function will provide the hash for that block.

Now for printing purpose, I am overriding __str__ method as:

def __str__(self):
        return str(
        "Block#: %s\nHash: %s\nPrevious: %s\nData: %s\nNonce: %s\n" %(
            self.number,
            self.hash(),
            self.previous_hash,
            self.data,
            self.nonce
            )
        )

Well done we have created blocks using python!!!..

Let’s code a simple blockchain, the blockchain will usually have a difficulty which is a simple number providing criteria that hash should have that many zeroes at the start of it. The more the difficulty the more time it takes to create a hash.

class BlockChain(object):
    """Chain of Blocks"""
    difficulty = 4

Now I am creating a constructor for the above class which initializes the chain of block:

def __init__(self,chain=[]):
        self.chain = chain

If we have a block with all the field initialized we can go for adding that block into a blockchain:

def add(self,block):
        self.chain.append({
                'Block Number' : block.number,
                'Hash':block.hash(),
                'Previous Hash' : block.previous_hash,
                'Data' : block.data,
                'nonce' : block.nonce
            })

Else if we have only data then we have to mine it to have all the fields to be initialized:

def mine(self, block):
        try:
            block.previous_hash = self.chain[-1].get('hash')
        except IndexError:
            pass
        while True:
            if block.hash()[:self.difficulty] == "0" * self.difficulty:
                self.add(block)
                break
            else:
                block.nonce +=1

Above we are initializing the previous_hash of a block then we are hashing the block until the difficulty is met.

Good Job guys, we have done our coding part!!

Photo by Alasdair Elmes on Unsplash

Let's see how this is working

def main():
    blockchain = BlockChain()
    database = ["data 1", "data 2", "data 3"]
    num = 0
    for data in database:
        num += 1
        blockchain.mine(Block(data,num))
    print("BlockChain : ")
    print(blockchain.chain)
for block in blockchain.chain:
        print("Block :")
        print(block)
if __name__ == '__main__':
    main()

Above I have created an instance for BlockChain class and we have 3 data which differs in only one digit. ‘num’ refers to the block number which will be incremented on adding blocks.

Save this code as <filename>.py to execute it go to the location where it is located and type python <filename>.py

So the output looks like

Sorry for the blurry image please right click and select view image to view this image clearly.

To be noticed in the output:

1. BlockChain: shows how the blocks are linked together with data in it.
2. Blocks: The first block previous hash will be 64 digits of zero. The second block previous hash will be the previous block’s hash
3. MOST IMPORTANT: we have modified only the last digit of data but the hash of each block has many differences.

For those who need source code can view it here

Thank you so much for spending your valuable time in my blog. Please support me by doing claps at the rate of 1–50 by the way you feel it worth. If you have any doubts regarding this blog or suggestion to improve it please do comment below and share it to those who want to know about blockchain.

You can find the next part link here. I will get you things as simple as you could understand😉😉.

Have a good day😊😊

Also, Read

• The Best Crypto Trading Bot
• Crypto Copy Trading Platforms
• The Best Crypto Tax Software
• Best Crypto Trading Platforms
• Best Crypto Lending Platforms
• Best Blockchain Analysis Tools
• Crypto arbitrage guide: How to make money as a beginner
• Best Crypto Charting Tool
• Ledger vs Trezor
• What are the best books to learn about Bitcoin?
• 3Commas Review
• AAX Exchange Review | Referral Code, Trading Fee, Pros and Cons
• Deribit Review | Options, Fees, APIs and Testnet
• FTX Crypto Exchange Review
• NGRAVE ZERO review
• Bybit Exchange Review
• 3Commas vs Cryptohopper
• The Best Bitcoin Hardware wallet
• Best monero wallet
• ledger nano s vs x
• Bitsgap vs 3Commas vs Quadency
• Ledger Nano S vs Trezor one vs Trezor T vs Ledger Nano X
• BlockFi vs Celsius vs Hodlnaut
• Bitsgap review — A Crypto Trading Bot That Makes Easy Money
• Quadency Review- A Crypto Trading Bot Made For Professionals
• PrimeXBT Review | Leverage Trading, Fee and Covesting
• Ellipal Titan Review
• SecuX Stone Review
• BlockFi Review | Earn up to 8.6% interests on your Crypto