CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn to build a blockchain from scratch in Python

Build your own Mini-Blockchain!

Now let's think of a way to represent a block in Python. We could create a bigger dictionary and store our data inside this dictionary. But since blocks can be represented as objects, let's create a Block Class which we can easily use to create new blocks.

Recall that a Block contains the following properties:
- Timestamp
- Transaction
- Hash
- Previous Hash
- Nonce

In this exercise, we will be creating the default constructor for the Block class in our Mini-Blockchain.

Creating Blocks

Let's review the concepts of nonce and proof of work. In this exercise, we will implement an example that demonstrates the difficulty of the math problem that helps protect the blockchain from potential attackers.

Nonce and Proof-of-Work

Hashing helps to maintain the integrity of the blockchain. In this exercise, we will see this in action. Let’s write a `.validate_chain()` method that checks to see if blocks are linked to each other properly.

In order to validate the entire blockchain, we must loop through each of the blocks stored inside the blockchain itself. Then, we will check through each of the blocks to ensure that the previous hash value matches with the hash value inside our previous block.


Checking for a Broken Chain

Before we create a more dynamic blockchain, let’s learn how to use a hash function in Python. Specifically, we will be using the <a href="https://docs.python.org/2/library/hashlib.html" target="_blank" rel="noopener noreferrer">SHA-256 hash function</a> which can be easily imported in Python. 

We will use the SHA-256 as a regular function that takes in a random string as its argument. To properly use this function in Python 3, our string must be encoded before being passed as an argument. To encode the string, we use the `.encode()` method.

Hashing and SHA-256

Now that we’ve seen a simple example of Proof-of-Work, let’s integrate it into our blockchain! Complete the `proof_of_work()` method inside the Blockchain class. 


Implementing Proof-of-Work

Now that we have implemented our Proof-of-Work method, we can now work on adding new blocks securely.

Adding Blocks to the Chain Securely

Each computer participant has their own copy of the blockchain. Ideally, each copy of the blockchain should have the same properties and functionality to add and validate blocks. 

We can represent the blockchain as an object. We are using objects for our implementation, because they offer the flexibility to create specific attributes and methods. Representing it as an object also allows us to create blockchain instances for each computer participant. 

To review, our blockchain contains the following:
* **Chain:** A list that holds all the blocks inside the blockchain.
* **Unverified Transactions:** A list that represents all the unverified transactions before being passed into a block.
* **Genesis Block:** A block automatically generated when the blockchain is initialized.


Creating the Blockchain Class

Now we can use the code in our previous exercise to spot a broken link. Let’s try tampering with the contents of the block and see how that creates a mismatch between hash values.


Hacking the Chain

Congratulations! You have completed all the steps required to build a basic blockchain! In this exercise, we will bring the key parts together to review what we have built so far.

**Note: ** The blockchain we have built only exists on a local machine. It is important to know that actual blockchain applications operate on multiple computers in a decentralized manner.

Blockchain Summary

Block hashes are used to uniquely identify and maintain the integrity of each block. The SHA-256 algorithm is used to generate the hash of the block using the timestamp, data, and previous hash — the three properties of our Block class!

Let’s create the `.generate_hash()` method for the Block class.

Generating Block Hashes

Now that we have everything in place, let’s begin adding blocks to the blockchain.


Adding Blocks to the Blockchain

In this lesson, you'll build a small blockchain of your own in Python! This lesson assumes a familiarity with Python syntax, functions, loops, importing libraries, and constructing classes, but there are some hints along the way to help out. If you've never used Python before, you might want to <a href="https://www.codecademy.com/learn/learn-python" target="_blank" rel="noopener noreferrer">learn some with Codecademy</a>.

The blockchain is a new way of storing and moving data securely. The data mostly consists of transactions which include messages exchanged between two parties. Before we start creating our blockchain, let's think of a way to store a transaction like the one shown below:

``` 
amount: 30
sender: Alice
receiver: Bob
```

In this example, Alice is trying to transfer 30 units of some currency to Bob. Can you think of a Python data type to best represent the above transaction?

This transaction is best represented in the form of a Python _dictionary_, with keys for the required fields and values specific to the transaction.

These transactions are all stored inside the _mempool_,  a pool of transactions that miners reference when selecting the set of transactions they want to verify.