Learn Blockchains by Building One in Python — 2. Turning our Blockchain into an API

This story follows the Python Blockchain series. You can find the other stories here:

There’s also a GitHub repo associated with this series, find it here: Python Blockchain Series.

In the last story, we’ve built a simple blockchain we can run from our computer. For now, no one can interact with it as what we do with our blockchain is hard-coded. The purpose is now to turn our blockchain into an API, so it allows us and other users to interact with it dynamically.

Endpoints

Before starting, it’s good to think about the endpoints we’ll need. First, we need an endpoint to mine, else we can’t create blocks. We also need an endpoint to add a transaction, else our blockchain is useless. And we finally need an endpoint to retrieve our blockchain, because a blockchain is transparent and anyone can access it and see the transactions and the blocks.

Flask

To turn our blockchain into an API, we need to build a web application. The most known Python frameworks for doing this are Django and Flask. Django is a bit over-complicated for what we want to do, so we’ll use Flask.

Flask allows you to build a web app in a few lines of code:

1. We create a Flask app.
2. We add the “/ route (the root).
3. We run our app.

We can now create the routes we’ll need in a file called app.py:

Nodes

In the blockchain, people validating the transactions and creating new blocks are known as “miners”. But they can also be called “nodes”. They ensure the blockchain is valid.

Nodes are what allow the blockchain to be so decentralized, as anyone can become a node from his computer and contribute.

When a node has found a valid proof, it creates a new block that is then verified by the entire network. If the block is valid, the node receives a coin.

Each node has an address. Let’s create our own. We can put the following code at the top of app.py .

from uuid import uuid4

node_identifier = str(uuid4()).replace('-', '')

Transactions Endpoint

A transaction is composed of a sender, a receiver, and an amount. If one of these values is missing, we can’t continue and should return an error. Else, we just create a new transaction in the blockchain, and we return a successful response.

We must return responses as text or JSON, so we use jsonify . The first returned value is the response’s content, and the second returned value is the status code (400 means error and 201 success).

Mine Endpoint

This endpoint is used to add new blocks to the blockchain. It has to calculate the Proof of Work, reward the miner, and add the new block to the chain.

Interacting with the Blockchain

Now, your app.py file should look like this:

We can run this file to run the app on our computer.

Now, open your favorite HTTP requests tool. I like Postman, but you can also use the Command Prompt and curl if you want.

Let’s try to mine a new block. If you want to use your Command Prompt, open it, and type:

curl http://127.0.0.1:5000/mine

You should get a response like this:

{
    "index": 5,
    "message": "New Block Forged",
    "previous_hash": "ca3ed0a811c05532631522a2abaa3594661f2e4767a907e97206c8b11f387bb2",
    "proof": 84,
    "transactions": [
        {
            "amount": 1,
            "recipient": "9bcd725631e3478b80842440d709730a",
            "sender": "0"
        }
    ]
}

As you can see, we’ve successfully mined a new block. If you want to experience this like if you were mining on a real blockchain, you can increase the Proof of Work difficulty, and the block won’t be mined so quickly.

We can also create transactions. You can do it with curl:

C:\Users\esteb>curl -X POST -H "Content-Type: application/json" -d "{\"sender\": \"me\", \"recipient\": \"you\", \"amount\": 10}" "http://localhost:5000/transactions/new"

Finally, let’s display our chain:

curl http://127.0.0.1:5000/chain

Response:

{
    "chain": [
        {
            "index": 1,
            "previous_hash": 1,
            "proof": 100,
            "timestamp": 1664510156.648992,
            "transactions": []
        },
        {
            "index": 2,
            "previous_hash": "4b08fb19a834a2fd3a8d18fb2130e0826f154989915b23757caed705aad263de",
            "proof": 6016,
            "timestamp": 1664510249.7857747,
            "transactions": [
                {
                    "amount": 1,
                    "recipient": "c9d99fb894464745a66b7daefa2bce3d",
                    "sender": "0"
                }
            ]
        },
        {
            "index": 3,
            "previous_hash": "8fea198f692c059eaf377d752e67437762f1e533487c25c46d75ae5a49e42ba2",
            "proof": 3136,
            "timestamp": 1664510320.2460153,
            "transactions": [
                {
                    "amount": 10,
                    "recipient": "you",
                    "sender": "me"
                },
                {
                    "amount": 1,
                    "recipient": "c9d99fb894464745a66b7daefa2bce3d",
                    "sender": "0"
                }
            ]
        }
    ],
    "length": 3
}

Final Note

Now, you can play with your blockchain and create transactions as it is interactive. But it’s not finished yet, our blockchain still lacks a big feature: the Consensus algorithm. More about that in the next story!

If you don’t want to miss it, be sure to follow me!

You can find the other stories of this series here:

To explore more of my Python stories, click here! You can also access all my content by checking this page.

If you liked the story, don’t forget to clap, comment, and maybe follow me if you want to explore more of my content :)

You can also subscribe to me via email to be notified every time I publish a new story, just click here!

If you’re not subscribed to medium yet and wish to support me or get access to all my stories, you can use my link: