Forem: FreakCdev

Build a p2p network and release your cryptocurrency

FreakCdev — Thu, 16 Dec 2021 18:25:06 +0000

Hi all, in the previous article, I have covered how to create a simple transaction system for our blockchain. So today, I will build the core component of our cryptocurrency - the peer-to-peer (p2p) network. It's not only required for a blockchain to work, but after building it, we can really release our coins! Yes, we are at that stage already.

I have also created a tutorial on Youtube, check it our for better understanding.

What is a p2p network?

First, we have to understand what is a peer-to-peer network. In the last parts, I have talked about it a few times, but it's not really ideal yet, so I will dig deeper about it in this article.

Before we get on to that, we need to understand the client-server model first. In our life, pretty much everything we use currently follows the client-server model. The network works by having a server, and every machines will connect to that server. You can send requests to the server, and the server can send back responses. Think of the system as a company, and the boss is the server. The boss is the one who makes decisions and controls every action of the application.

But in a distributed peer-to-peer model, machines (called nodes) can send messages to each other without having any 3rd-party system involved. Think of it as a group of friends working together. People can work independently, and decisions will be made by the majority.

In a cryptocurrency's network, people should be able to at least send transactions and suggest new blocks.

Without futher ado, let's code!

What and how we are trying to achieve

We would need a network where nodes can connect with and send messages to each other in a peer to peer fashion. After that, we will add functionalities like broadcasting transactions, suggesting new blocks, send the chain and chain's information.

I will be using WebSocket - a TCP-based protocol, please learn about it to have a better understanding with what I will be doing.

Also, please read the comments in the code, I use them to explain individual functionalities.

Setup

I will use a light package called ws just to stay simple in this article.

Simply install it using npm:

npm install ws

Basic concepts of `ws`

// Import the package
const WS = require("ws");
// Create a server
const server = new WS.Server({ port: "SOME PORT" });
// Listens for connections
server.on("connection", async (socket, req) => {
    // This event handler will be triggered every time somebody send us connections
});
// Get the socket from an address
const socket = new WS("SOME ADDRESS");
// Open a connection
socket.on("open", () => {
    // This event handler will be triggered when a connection is opened
})
// Close a connection
socket.on("close", () => {
    // This event handler will be triggered when the connection is closed
})
// Listens for messages
socket.on("message", message => {
    // "message" is message, yes
})

A basic node

Create a new file, call it anything you want.

Basically, we will have the basic variables for PORT, the list of peers we are connecting (PEERS), our address (MY_ADDRESS).

I use process.env.abcxyz so that you can configure the node easily through command line.

// BTW, I will import the required stuff too
const crypto = require("crypto"), SHA256 = message => crypto.createHash("sha256").update(message).digest("hex");
const { Block, Transaction, JeChain } = require("./jechain");
const EC = require("elliptic").ec, ec = new EC("secp256k1");

const MINT_PRIVATE_ADDRESS = "0700a1ad28a20e5b2a517c00242d3e25a88d84bf54dce9e1733e6096e6d6495e";
const MINT_KEY_PAIR = ec.keyFromPrivate(MINT_PRIVATE_ADDRESS, "hex");
const MINT_PUBLIC_ADDRESS = MINT_KEY_PAIR.getPublic("hex");

// Your key pair
const privateKey = process.env.PRIVATE_KEY || "62d101759086c306848a0c1020922a78e8402e1330981afe9404d0ecc0a4be3d";
const keyPair = ec.keyFromPrivate(privateKey, "hex");
const publicKey = keyPair.getPublic("hex");

// The real new code
const WS = require("ws");

const PORT = process.env.PORT || 3000;
const PEERS = process.env.PEERS ? process.env.PEERS.split(",") : [];
const MY_ADDRESS = process.env.MY_ADDRESS || "ws://localhost:3000";
const server = new WS.Server({ port: PORT });

console.log("Listening on PORT", PORT);

// I will add this one line for error handling:
process.on("uncaughtException", err => console.log(err));

The MINTING address should never be changed, and we are going to change the old genesis block too:

const initalCoinRelease = new Transaction(MINT_PUBLIC_ADDRESS, "04719af634ece3e9bf00bfd7c58163b2caf2b8acd1a437a3e99a093c8dd7b1485c20d8a4c9f6621557f1d583e0fcff99f3234dd1bb365596d1d67909c270c16d64", 100000000);

We are releasing coins and send it to a guy with the address above, which is basically just from this private key: 62d101759086c306848a0c1020922a78e8402e1330981afe9404d0ecc0a4be3d

Remember to replace the old mint key pair with the new one too.

Now, let's have a way to connect to other nodes, as well as listen to other nodes' connections.

To implement this system, we need a function to connect, and use server.on("connection") for listening to connections.

The connect function should be able to connect to an address, then send it our address, then, the connection handler of that address will connect to our address using the message given.

A message is a string, in this case, a JSON, which have a form like this:

{
    "type": "...",
    "data": "..."
}

What we need in this case is:

{
    "type": "TYPE_HANDSHAKE",
    "data": ["Our address and our connected nodes' address", "address x", "address y"]
}

I will create a function to generate messages for convenience:

function produceMessage(type, data) {
    return { type, data }
}

Now, let's implement the main system:

// THE CONNECTION LISTENER
server.on("connection", async(socket, req) => {
    // Listens for messages
    socket.on("message", message => {
        // Parse the message from a JSON into an object 
        const _message = JSON.parse(message);

        switch(_message.type) {
            case "TYPE_HANDSHAKE":
                const nodes = _message.data;

                nodes.forEach(node => connect(node))

            // We will need to handle more types of messages in the future, so I have used a switch-case.
        }
    })
});

// THE CONNECT FUNCTION
async function connect(address) {
    // Get the socket from address
    const socket = new WS(address);

    // Connect to the socket using the "open" event
    socket.on("open", () => {
        // Send our address to the target 
        socket.send(JSON.stringify(produceMessage("TYPE_HANDSHAKE", [MY_ADDRESS])));
    });
}

To actually do stuff in the future, we would want to store connected sockets and addresses into one array. Also, by doing this, we can send other nodes the address of the node that has just been connected to us.

let opened = [], connected = [];
// I will use "opened" for holding both sockets and addresses, "connected" is for addresses only.

async function connect(address) {
    // We will only connect to the node if we haven't, and we should not be able to connect to ourself
    if (!connected.find(peerAddress => peerAddress === address) && address !== MY_ADDRESS) {
        const socket = new WS(address);

        socket.on("open", () => {
            // I will use the spread operator to include our connected nodes' addresses into the message's body and send it.
            socket.send(JSON.stringify(produceMessage("TYPE_HANDSHAKE", [MY_ADDRESS, ...connected])));

            // We should give other nodes' this one's address and ask them to connect.
            opened.forEach(node => node.socket.send(JSON.stringify(produceMessage("TYPE_HANDSHAKE", [address]))));

            // If "opened" already contained the address, we will not push.
            if (!opened.find(peer => peer.address === address) && address !== MY_ADDRESS) {
                opened.push({ socket, address });
            }

            // If "connected" already contained the address, we will not push.
            if (!connected.find(peerAddress => peerAddress === address) && address !== MY_ADDRESS) {
                connected.push(address);
            }

            // Two upper if statements exist because of the problem of asynchronous codes. Since they are running
            // concurrently, the first if statement can be passed easily, so there will be duplications.
        });

        // When they disconnect, we must remove them from our connected list.
        socket.on("close", () => {
            opened.splice(connected.indexOf(address), 1);
            connected.splice(connected.indexOf(address), 1);
        });
    }
}

To connect to all prefixed peers, you can add this line in:

PEERS.forEach(peer => connect(peer));

Integrate our blockchain into the network.

What do we need to do?

Alright, now that we have our node running, let's start diving into the real deal part of the article - cryptocurrency. To create a cryptocurrency, we would need to be able to broadcast transactions, suggest newly mined blocks. New nodes should be able to ask other nodes for their chains too.

0. Adding necessary stuff

Because when we send messages, we are effectively parsing objects to JSON, meaning that the methods of an object (in this case, they are the transactions, blocks, blockchains) will disappear. We can solve this problem by making our methods static, so we can re-use them without having to touch the real objects themselves.

And in the previous article, the validation methods of blocks and transactions are not really ideal, so let's update them while we are turning everything static.

    static hasValidTransactions(block, chain) {
        let gas = 0, reward = 0;

        block.data.forEach(transaction => {
            if (transaction.from !== MINT_PUBLIC_ADDRESS) {
                gas += transaction.gas;
            } else {
                reward = transaction.amount;
            }
        });

        return (
            reward - gas === chain.reward &&
            block.data.every(transaction => Transaction.isValid(transaction, chain)) && 
            block.data.filter(transaction => transaction.from === MINT_PUBLIC_ADDRESS).length === 1
        );
    }

    static isValid(blockchain) {
        for (let i = 1; i < blockchain.chain.length; i++) {
            const currentBlock = blockchain.chain[i];
            const prevBlock = blockchain.chain[i-1];

            if (
                currentBlock.hash !== Block.getHash(currentBlock) || 
                prevBlock.hash !== currentBlock.prevHash || 
                !Block.hasValidTransactions(currentBlock, blockchain)
            ) {
                return false;
            }
        }

        return true;
    }

    static isValid(tx, chain) {
        return ( 
            tx.from && 
            tx.to && 
            tx.amount && 
            (chain.getBalance(tx.from) >= tx.amount + tx.gas || tx.from === MINT_PUBLIC_ADDRESS) && 
            ec.keyFromPublic(tx.from, "hex").verify(SHA256(tx.from + tx.to + tx.amount + tx.gas), tx.signature)
        )
    }

    static getHash(block) {
        return SHA256(block.prevHash + block.timestamp + JSON.stringify(block.data) + block.nonce);
    }

Related methods

    constructor(timestamp = Date.now().toString(), data = []) {
        this.timestamp = timestamp;
        this.data = data;
        this.prevHash = "";
        this.hash = Block.getHash(this);
        this.nonce = 0;
    }

    mine(difficulty) {
        while (!this.hash.startsWith(Array(difficulty + 1).join("0"))) {
            this.nonce++;
            this.hash = Block.getHash(this);
        }
    }

    addBlock(block) {
        block.prevHash = this.getLastBlock().hash;
        block.hash = Block.getHash(block);
        block.mine(this.difficulty);
        this.chain.push(Object.freeze(block));

        this.difficulty += Date.now() - parseInt(this.getLastBlock().timestamp) < this.blockTime ? 1 : -1;
    }

    addTransaction(transaction) {
        if (Transaction.isValid(transaction, this)) {
            this.transactions.push(transaction);
        }
    }

1. Transactions

First, I will create a handy-dandy sendMessage function to send messages to nodes easier.

function sendMessage(message) {
    opened.forEach(node => {
        node.socket.send(JSON.stringify(message));
    });
}

Now, let's handle the messages!

A message for broadcasting transactions will look like this:

{
    "type": "TYPE_CREATE_TRANSACTION",
    "data": "the transaction object goes here"
}

In our message handler, we will create a new case which simply uses the handy-dandy addTransactions method we have created in the last part.

        switch(_message.type) {
            ...
            case "TYPE_CREATE_TRANSACTION":
                const transaction = _message.data;

                JeChain.addTransaction(transaction);

                break;
        }

And you can send a transaction like this:

sendMessage(produceMessage("TYPE_CREATE_TRANSACTION", someTransaction));
// You must also add the transaction to your pool:
JeChain.addTransaction(someTransaction);

2. Mining and sending new blocks

Now, let's handle the new block's suggestion messages.

This is by far the hardest, most bulky part to implement, so let's get going shall we?

The message will look like this:

{
    "type": "TYPE_REPLACE_CHAIN",
    "data": [
        "new block",
        "new difficulty"
    ]
}

How would we handle this message? The simplest thing we would do first is to check if the block is valid or not, then we will add it to the chain and update the difficulty. The block is valid when:

It has valid transactions (the transactions are in our transaction pool, the transactions are valid according to our old methods).
It has a valid hash (matches with the block's information (also called "block header")).
It has a valid difficulty (it can't be greater or less than difficulty plus/minus 1).
It has a valid timestamp (must not be greater than the time they sent us and less than the previous block's timestamp). This is not really a fulfill way to adjust difficulty, but at least it shouldn't create too much damage.

        switch(_message.type) {
            ...
            case "TYPE_REPLACE_CHAIN":
                const [ newBlock, newDiff ] = _message.data;

                // We are checking if the transactions exist in the pool by removing elements from transactions of the block if they exist in the pool. 
                // Then, we simply use `theirTx.length === 0` to check if the all elements are removed, meaning all transactions are in the pool.
                const ourTx = [...JeChain.transactions.map(tx => JSON.stringify(tx))];
                const theirTx = [...newBlock.data.filter(tx => tx.from !== MINT_PUBLIC_ADDRESS).map(tx => JSON.stringify(tx))];
                const n = theirTx.length;

                if (newBlock.prevHash !== JeChain.getLastBlock().prevHash) {
                    for (let i = 0; i < n; i++) {
                        const index = ourTx.indexOf(theirTx[0]);

                        if (index === -1) break;

                        ourTx.splice(index, 1);
                        theirTx.splice(0, 1);
                    }

                    if (
                        theirTx.length === 0 &&
                        SHA256(JeChain.getLastBlock().hash + newBlock.timestamp + JSON.stringify(newBlock.data) + newBlock.nonce) === newBlock.hash &&
                        newBlock.hash.startsWith(Array(JeChain.difficulty + 1).join("0")) &&
                        Block.hasValidTransactions(newBlock, JeChain) &&
                        (parseInt(newBlock.timestamp) > parseInt(JeChain.getLastBlock().timestamp) || JeChain.getLastBlock().timestamp === "") &&
                        parseInt(newBlock.timestamp) < Date.now() &&
                        JeChain.getLastBlock().hash === newBlock.prevHash &&
                        (newDiff + 1 === JeChain.difficulty || newDiff - 1 === JeChain.difficulty)
                    ) {
                        JeChain.chain.push(newBlock);
                        JeChain.difficulty = newDiff;
                        JeChain.transactions = [...ourTx.map(tx => JSON.parse(tx))];
                    }
                }

                break;
        }

But turns out, there's one really dangerous problem. If one miner mines a block, he wouldn't really know if his block came first or the other one sent to him came first. Yes, this does happen due to many impacts, one of them is internet problem. Imagine if someone mined a block before you, and he had sent the block to other nodes already, but due to some internet problem, you can manage to finish mining the block after the message is received, so the block sent will be invalid, but it's in fact valid and you will be left behind.

There are many approaches to this, but I have coined out a really simple system which leverages the use of majority's support.

We can affectively implement this functionality using a boolean variable called checking and setTimeout. Basically, the idea is that if the block's prevHash is equal to the latest block's prevHash, then it's probably a block that needs checking for replacement. We will set checking to true to indicates that we are checking, then, we will request other nodes for their latest block. We will wait for a period of time (which I have set to 5s) using setTimeout, then we will set checking to false, cancelling the process, and the block that appeared the most is likely the block we need. I will also implement a system to skip on all similar blocks after we have had the correct answer.

let check = [];
let checked = [];
let checking = false;

...

                if (newBlock.prevHash !== JeChain.getLastBlock().prevHash) {
                    ...
                  // If this case was found once, simply just dismiss it
                } else if (!checked.includes(JSON.stringify([newBlock.prevHash, JeChain.chain[JeChain.chain.length-2].timestamp || ""]))) {
                    checked.push(JSON.stringify([JeChain.getLastBlock().prevHash, JeChain.chain[JeChain.chain.length-2].timestamp || ""]));

                    const position = JeChain.chain.length - 1;

                    checking = true;

                    sendMessage(produceMessage("TYPE_REQUEST_CHECK", MY_ADDRESS));

                    setTimeout(() => {
                        checking = false;

                        let mostAppeared = check[0];

                        check.forEach(group => {
                            if (check.filter(_group => _group === group).length > check.filter(_group => _group === mostAppeared).length) {
                                mostAppeared = group;
                            }
                        })

                        const group = JSON.parse(mostAppeared)

                        JeChain.chain[position] = group[0];
                        JeChain.transactions = [...group[1]];
                        JeChain.difficulty = group[2];

                        check.splice(0, check.length);
                    }, 5000);
                }

Note that the upper code is more of a proof-of-concept, we often would like to check if the block is valid or not just to be safer. There are faster, cleaner, more secure ways than this, but this should do our job.

Let's create a way to handle TYPE_REQUEST_CHECK. We will send back TYPE_SEND_CHECK, so let's make one for that as well.

The message will look like this:

{
    "type": "TYPE_REQUEST_CHECK",
    "data": "address to send back"
}

{
    "type": "TYPE_SEND_CHECK",
    "data": ["block", "transaction pool", "difficulty"]
}

The handler:

            case "TYPE_REQUEST_CHECK":
                // Find the address and send back necessary data.
                opened.filter(node => node.address === _message.data)[0].socket.send(
                    JSON.stringify(produceMessage(
                        "TYPE_SEND_CHECK",
                        JSON.stringify([JeChain.getLastBlock(), JeChain.transactions, JeChain.difficulty])
                    ))
                );

                break;

            case "TYPE_SEND_CHECK":
                // Only push to check if checking is enabled
                if (checking) check.push(_message.data);

                break;

So the handler is finally done!

You can mine blocks like this:

if (JeChain.transactions.length !== 0) {
    // Note that technically you can choose your own transactions to mine, but I would like to mine all transactions at once.
    JeChain.mineTransactions(publicKey);

    sendMessage(produceMessage("TYPE_REPLACE_CHAIN", [
        JeChain.getLastBlock(),
        JeChain.difficulty
    ]));
}

3. Sending chains

For new nodes that have just joined the network, there are 2 ways to get the latest chain. You can either get a chain from a trust-worthy source, or you can ask for the chain in the network. Note that the size of a message is limited, so we won't be able to send the whole chain, we will send its blocks and information one by one.

We can implement the second solution like this:

let tempChain = new Blockchain();
...

            case "TYPE_SEND_CHAIN":
                const { block, finished } = _message.data;

                if (!finished) {
                    tempChain.chain.push(block);
                } else {
                    tempChain.chain.push(block);
                    if (Blockchain.isValid(tempChain)) {
                        JeChain.chain = tempChain.chain;
                    }
                    tempChain = new Blockchain();
                }

                break;


            case "TYPE_REQUEST_CHAIN":
                const socket = opened.filter(node => node.address === _message.data)[0].socket;

                // We will send the blocks continously. 
                for (let i = 1; i < JeChain.chain.length; i++) {
                    socket.send(JSON.stringify(produceMessage(
                        "TYPE_SEND_CHAIN",
                        {
                            block: JeChain.chain[i],
                            finished: i === JeChain.chain.length - 1
                        }
                    )));
                }

                break;

            case "TYPE_REQUEST_INFO":
                opened.filter(node => node.address === _message.data)[0].socket.send(
                    "TYPE_SEND_INFO",
                    [JeChain.difficulty, JeChain.transactions]
                );

                break;

            case "TYPE_SEND_INFO":
                [ JeChain.difficulty, JeChain.transactions ] = _message.data;

                break;

Note that you can send request chain to a trust-worthy node, or base on the majority.

Testing in localhost

To test, I will start 2 new consoles with different PORT, MY_ADDRESS, and PRIVATE_KEY. For the first one, I will set our peers to be empty, and the key to be what the initial coin release points to. For the other one, I will set the peer list to be the first node to test if our "handshake" functionality work. Then, I'm going to create a transaction in the first node and mine in the second node. After 10 seconds, we will print out the opened array and the chain.

First node:

setTimeout(() => {
    const transaction = new Transaction(publicKey, "046856ec283a5ecbd040cd71383a5e6f6ed90ed2d7e8e599dbb5891c13dff26f2941229d9b7301edf19c5aec052177fac4231bb2515cb59b1b34aea5c06acdef43", 200, 10);

    transaction.sign(keyPair);

    sendMessage(produceMessage("TYPE_CREATE_TRANSACTION", transaction));

    JeChain.addTransaction(transaction);
}, 5000);

setTimeout(() => {
    console.log(opened);
    console.log(JeChain);
}, 10000);

Second node:

setTimeout(() => {
        if (JeChain.transactions.length !== 0) {
            JeChain.mineTransactions(publicKey);

            sendMessage(produceMessage("TYPE_REPLACE_CHAIN", [
                JeChain.getLastBlock(),
                JeChain.difficulty
            ]));
        }
}, 6500);

setTimeout(() => {
    console.log(opened);
    console.log(JeChain);
}, 10000);

It should look like this:

Nodes have connected to each others, the block is mined, the chain is synced!

Releasing our coin (testing publicly)

Simply host a node publicly (by using port forwarding, also, for each router, you would have a different way to do port forwarding, just simply look up online to see what suits your model), using your PC or a VPS hosting service.

I have tested with my friend here:

My node which is the first node:

His node which is the second node:

We have done some port forwarding and connected to each others' public IP address.

Note that this network is not meant to be production-ready, but this network should be fine for now.

Source code

The full source code used in this article can be found in this Github repo. Or here with JeChain.

Shoutouts

I want to give appreciation to my friend Apple who have contributed to the code used in the article, and Trey - a really cool guy who enlightens me in constructing the network.

Check out Apple's Github account.
Check out Trey's website.

Contacts

I have also created a tutorial on Youtube, check it our for better understanding.

Creating a cryptocurrency - Creating transactions, mining rewards, mint and gas fee

FreakCdev — Fri, 26 Nov 2021 10:16:38 +0000

Hi all, in the previous article, I have covered how to create a simple Blockchain in just 60 lines of code. So today, I will start working on the second part of the series - transactions.

Please read the previous article first if you haven't known anything about blockchains yet.

Also, if this is already too familiar for you, consider checking out the third article about how to create a p2p network and release your cryptocurrency.

Also, you should definitely check out this tutorial on my new videos on Youtube for detailed information:

What we are trying to achieve

Basically, we need to have a representation of a transaction that includes the sender's wallet address, the receiver's wallet address and the amount we are sending. We will add it to a transaction pool, and when we create a new block, we will move all pending transactions to that block's data.

To prevent faulty transactions, we will use a signing mechanism along with a key pair. That key pair will include 2 keys: a private key, and a public key. The public key can be shown to others as a wallet address, the private key is used for signing transactions. Because only you hold the private key, only you can sign your account's transactions, ensuring safety.

We will talk about some other stuff like minting, initial coin release and gas fee.

No more saying, let's start coding!

The transaction class

So we will have a basic class like this:

class Transaction {
    constructor(from, to, amount) {
        this.from = from;
        this.to = to;
        this.amount = amount;
    }
}

Mining transactions

Moving back to the Blockchain class, first of all, we need a transactions pool which holds all the pending transactions.

    this.transactions = [];

Now, we will have a method to create a transaction:

    addTransaction(transaction) {
        this.transactions.push(transaction);
    }

Mining the transactions:

    mineTransactions() {
        this.addBlock(new Block(Date.now().toString(), this.transactions));

        this.transactions = [];
    }

We just basically pass in the pending transactions and then clear the current pending transactions pool.

Mining reward

No one would like to lose their computational power to mine transactions for you for free, so you need to have some form of reward for the miners/validators.

First, we will have a mining reward property, you can set it to whatever you like, I'll set it to 297 for no real reason.

    this.reward = 297;

Now, we shall create a transaction that transfers the reward to the miner.

    mineTransactions(rewardAddress) {
        this.addBlock(new Block(Date.now().toString(), [new Transaction(CREATE_REWARD_ADDRESS, rewardAddress, this.reward), ...this.transactions]));

        // Right now, we are just going assume the "from" address is something like this,
        // we will get back to this later in the next part of the article.
        this.transactions = [];
    }

Minting

This is a well-known term in blockchain development, it simply refers to the act of adding more coins, or printing more money to be simple. When the chain gives miners reward, it is actually minting coins in the mean time.

Signing

We can't miss the signing mechanism, it's ESSENTIAL!

Before we proceed, it's important to do some research about signing first, it's a popular mechanism in cryptography.

I will use an algorithm used by Bitcoin and Ethereum - secp256k1 for generating key pairs.

Since we are staying simple, we wouldn't want to implement the algorithm on our own since it's terribly long and can even be longer than this article.

We are using a package called elliptic, note that elliptic also supports Curve25519 and other algorithms.

Install it through npm:

npm i elliptic

Generate a keypair

This is an example of generating a key pair:

const EC = require("elliptic").ec, ec = new EC("secp256k1");

const keyPair = ec.genKeyPair();
// public key: keyPair.getPublic("hex")
// private key: keyPair.getPrivate("hex")

Signing transactions

Create a sign method in the Transaction class:

    sign(keyPair) {
        // Check if the public key matches the "from" address of the transaction
        if (keyPair.getPublic("hex") === this.from) {
            // Sign the transaction
            this.signature = keyPair.sign(SHA256(this.from + this.to + this.amount), "base64").toDER("hex");
        }
    }

Validation

The chain is valid when all blocks have valid transactions, transactions are valid only when:

From, to, amount are not empty.
Sender's address has more money than the amount sent.
The signature matches with the data of the transaction.

First, we will create a method in the Blockchain class to get an address's balance for convenience.

We can implement a method to get an address's balance based on the transaction history of the chain:

    getBalance(address) {
        let balance = 0;

        this.chain.forEach(block => {
            block.data.forEach(transaction => {
                // Because if you are the sender, you are sending money away, so your balance will be decremented.
                if (transaction.from === address) {
                    balance -= transaction.amount;
                }

                // But if you are the receiver, you are receiving money, so your balance will be incremented.
                if (transaction.to === address) {
                    balance += transaction.amount;
                }
            })
        });

        return balance;
    }

So we will have a method like this in our Transaction class:

    isValid(tx, chain) {
        return (
            tx.from &&
            tx.to &&
            tx.amount &&
            chain.getBalance(tx.from) >= tx.amount &&
            ec.keyFromPublic(tx.from, "hex").verify(SHA256(tx.from + tx.to + tx.amount + tx.gas), tx.signature)
        );
    }

Inside the Block class, create a method to check if it has valid transactions or not.

    hasValidTransactions(chain) {
        return this.data.every(transaction => transaction.isValid(transaction, chain));
    }

Update the isValid method of the Blockchain class:

    if (
        currentBlock.hash !== currentBlock.getHash() || 
        prevBlock.hash !== currentBlock.prevHash || 
        !currentBlock.hasValidTransactions(blockchain)
    ) {
        return false;
    }

Now, we also need to check if a transaction is valid before pushing it to the pool:

    addTransaction(transaction) {
        if (transaction.isValid(transaction, this)) {
            this.transactions.push(transaction);
        }
    }

Now, let's get back to minting as I have promised. First, I'll create an address just for minting.

const MINT_KEY_PAIR = ec.genKeyPair();
const MINT_PUBLIC_ADDRESS = MINT_KEY_PAIR.getPublic("hex");

New method:

    mineTransactions(rewardAddress) {
        // Create a mint transaction for reward.
        const rewardTransaction = new Transaction(MINT_PUBLIC_ADDRESS, rewardAddress, this.reward);
        rewardTransaction.sign(MINT_KEY_PAIR);

        // We will add the reward transaction into the pool.
        this.addBlock(new Block(Date.now().toString(), [rewardTransaction, ...this.transactions]));

        this.transactions = [];
    }

Chain's address will have an exception: Its balance will not be checked since we are printing money, so we need to update Transaction.isValid as well. Also, its amount must be the exact same as the defined reward.

    isValid(tx, chain) {
        return (
            tx.from &&
            tx.to &&
            tx.amount &&
            (chain.getBalance(tx.from) >= tx.amount || tx.from === MINT_PUBLIC_ADDRESS) &&
            ec.keyFromPublic(tx.from, "hex").verify(SHA256(tx.from + tx.to + tx.amount), tx.signature)
        );
    }

Releasing the first few coins ever

Going back to the Blockchain class, we will make some changes to our genesis block. We will mint some coins for one address (creating a max diluted marketcap). If anyone wants to buy our currency, they will lend us some money, and we will send them coins. This is also called a contract.

Create the keyPair first

const holderKeyPair = ec.genKeyPair();

In the genesis block, simply create a transaction for inital coin release.

    // We will release 100000 coin
    const initalCoinRelease = new Transaction(MINT_PUBLIC_ADDRESS, holderKeyPair.getPublic("hex"), 100000);
    this.chain = [new Block(Date.now().toString(), [initalCoinRelease])];

The problem with minting

If you are wondering if anyone can access the minting address, can't we print out a lot and a lot faulty money? You would be right, but we are going to handle all of our problems with a peer-to-peer network, which I'm going to make in the next article.

The peer-to-peer network handles this problem by simply dismissing the chain of which block:

Has more or less than 1 transaction for minting.
Has lower than 1 transaction other than the mint transaction, it basically means that he's constantly minting blocks without actually producing some real transactions.

Gas fees

There is also a kind of miner's reward called gas fee, but it's a little different. It's basically user's reward for miners. This makes mining more appealing to miners, and it also pays for the energy used for mining, and people would have to pay a higher gas fee to be picked by miners quicker.

We are adding the gas property into our Transaction class.

    class Transaction {
        // Gas will be set to 0 because we are making it optional
        constructor(from, to, amount, gas = 0) {
            this.from = from;
            this.to = to;
            this.amount = amount;
            this.gas = gas;
        }

        sign(keyPair) {
            if (keyPair.getPublic("hex") === this.from) {
                // Add gas
                this.signature = keyPair.sign(SHA256(this.from + this.to + this.amount + this.gas), "base64").toDER("hex");
            }
        }

        isValid(tx, chain) {
            return (
                tx.from &&
                tx.to &&
                tx.amount &&
                // Add gas
                (chain.getBalance(tx.from) >= tx.amount + tx.gas || tx.from === MINT_PUBLIC_ADDRESS) &&
                ec.keyFromPublic(tx.from, "hex").verify(SHA256(tx.from + tx.to + tx.amount + tx.gas), tx.signature)
            );
        }
    }

We will update the getBalance method too:

    getBalance(address) {
        let balance = 0;

        this.chain.forEach(block => {
            block.data.forEach(transaction => {
                if (transaction.from === address) {
                    balance -= transaction.amount;
                    balance -= transaction.gas
                }

                if (transaction.to === address) {
                    balance += transaction.amount;
                }
            })
        });

        return balance;
    }

Now, we should give the gas fee to the miner:

    mineTransactions(rewardAddress) {
        let gas = 0;

        this.transactions.forEach(transaction => {
            gas += transaction.gas;
        });

        const rewardTransaction = new Transaction(MINT_PUBLIC_ADDRESS, rewardAddress, this.reward + gas);
        rewardTransaction.sign(MINT_KEY_PAIR);

        // Prevent people from minting coins and mine the minting transaction.
        if (this.transactions.length !== 0) this.addBlock(new Block(Date.now().toString(), [rewardTransaction, ...this.transactions]));

        this.transactions = [];
    }

Our validation method for the block must also be changed:

    hasValidTransactions(chain) {
        let gas = 0, reward = 0;

        this.data.forEach(transaction => {
            if (transaction.from !== MINT_PUBLIC_ADDRESS) {
                gas += transaction.gas;
            } else {
                reward = transaction.amount;
            }
        });

        return (
            reward - gas === chain.reward &&
            this.data.every(transaction => transaction.isValid(transaction, chain)) && 
            this.data.filter(transaction => transaction.from === MINT_PUBLIC_ADDRESS).length === 1
        );
    }

Testing

// Your original balance is 100000

const girlfriendWallet = ec.genKeyPair();

// Create a transaction
const transaction = new Transaction(holderKeyPair.getPublic("hex"), girlfriendWallet.getPublic("hex"), 100, 10);
// Sign the transaction
transaction.sign(holderKeyPair);
// Add transaction to pool
JeChain.addTransaction(transaction);
// Mine transaction
JeChain.mineTransactions(holderKeyPair.getPublic("hex"));

// Prints out balance of both address
console.log("Your balance:", JeChain.getBalance(holderKeyPair.getPublic("hex")));
console.log("Your girlfriend's balance:", JeChain.getBalance(girlfriendWallet.getPublic("hex")));

It should look like this:

So, that's it! Here's the full source code if you want:

Honourable mention

The code from this video was made by me and my friend, whose name is Apple.
You can check his Github account in here: https://github.com/apple096/

Resources

Find me on:

Check out the Youtube version of this article:

Creating Transaction, Mining reward, Mint and Gas fee on the Blockchain in Javascript.

Creating a blockchain in 60 lines of Javascript

FreakCdev — Fri, 29 Oct 2021 02:27:47 +0000

In recent years, cryptocurrencies and blockchains are two uprising fields, so today, I will share my way of creating a blockchain in Javascript in just 60 lines of codes.

There's also my full tutorial on Youtube. You can check it out for more details.

Also, my new article is released, check it out! It's about creating transactions for our blockchain, basically the first step of building a cryptocurrency.

If two of those are already too familiar for you, consider checking out the third article about how to create a p2p network and release your cryptocurrency. Consider checking it out!

What is a blockchain?

Before we do any coding, we need to understand what a blockchain is. Technically, a blockchain at its bare minimum is just a list containing objects that have some basic information on it like timestamp, transactions, hash,... Its data must be immutable and unhackable. Modern platforms like Ethereum, Cardano, Polkadot,... have way more complex stuff, but we are staying simple in this article.

Setup

We are using Node.js for this project, so be sure to install it if you haven't.

Throughout the article, I will be using the object-oriented programming style, so I expect you to know basic knowledge about it.

Creating a block

As I have said, a block is just an object that has some information on it, so we should have a Block class like this:

class Block {
    constructor(timestamp = "", data = []) {
        this.timestamp = timestamp;
        // this.data should contain information like transactions.
        this.data = data;
    }
}

So we have our timestamp and data, but a blockchain needs immutability. We can gain that effect by using a hashing function that hashes all of our properties in the block. I suggest reading about hasing on wikipedia, it plays an essential role in a blockchain. Basically, it takes in a message and outputs a "hashed" one with fixed length, a slight change to the message will make the output completely different.

I'm using the sha256 algorithm. To implement its hashing function, I'll just going to use the Nodejs' built-in crypto package:

const crypto = require("crypto"), SHA256 = message => crypto.createHash("sha256").update(message).digest("hex");

The code above should give us what we wanted, but if you want to know how it works, check out Node.js's official doc about the hash class.

We should have something like this:

// Get the sha256 hash function.
const crypto = require("crypto"), SHA256 = message => crypto.createHash("sha256").update(message).digest("hex");

class Block {
    constructor(timestamp = "", data = []) {
        this.timestamp = timestamp;
        this.data = data;
        this.hash = this.getHash();
        this.prevHash = ""; // previous block's hash
    }

    // Our hash function.
    getHash() {
        return SHA256(this.prevHash + this.timestamp + JSON.stringify(this.data));
    }
}

Because every time anything is changed, SHA256 will throw out something completely different, so that can some what ensures the immutability.

The prevHash property also plays a big role in immutability, it ensures that the blocks will stay unchanged along the blockchain's lifespan. It contains the hash of the previous block, so you can assure the immutability of that previous block since a slight change will make the current block's getHash be different. You can see that it's empty, but we will do something with it later in this article.

The blockchain

Let's move over to the blockchain class.

Like I have said, a blockchain is a list with blocks, so we can have a basic form like this:

class Blockchain {
    constructor() {
        // This property will contain all the blocks.
        this.chain = [];
    }
}

You must have a genesis block, which is technically just the first block:

class Blockchain {
    constructor() {
        // Create our genesis block
        this.chain = [new Block(Date.now().toString())];
    }
}

Just for convenience, I'll create a function to get the latest block:

    getLastBlock() {
        return this.chain[this.chain.length - 1];
    }

Now, we should have a way to add a block to the blockchain.

    addBlock(block) {
        // Since we are adding a new block, prevHash will be the hash of the old latest block
        block.prevHash = this.getLastBlock().hash;
        // Since now prevHash has a value, we must reset the block's hash
        block.hash = block.getHash();

        // Object.freeze ensures immutability in our code
        this.chain.push(Object.freeze(block));
    }

Validation

We need to know whether the chain is still valid or not, so we need a method to check validation. The chain is valid if a block's hash is equal to what its hashing method returns, and a block's prevHash property should be equal to the previous block's hash.

    isValid(blockchain = this) {
        // Iterate over the chain, we need to set i to 1 because there are nothing before the genesis block, so we start at the second block.
        for (let i = 1; i < blockchain.chain.length; i++) {
            const currentBlock = blockchain.chain[i];
            const prevBlock = blockchain.chain[i-1];

            // Check validation
            if (currentBlock.hash !== currentBlock.getHash() || prevBlock.hash !== currentBlock.prevHash) {
                return false;
            }
        }

        return true;
    }

This method will play a really important role when our blockchain is ran on a p2p network.

Proof-of-work

In a peer-to-peer network, where there are no 3rd party system to approve people's action, without any consensus mechanism, nodes (people to be simple) will agree with the majority, but people can start being attackers and take control of the majority, so we need a consensus mechanism. A consensus mechanism exist not entirely to stop attacks, they exist to make people not be attackers. Proof-of-work is one of them.

Before we go more on to that, the system works by making you increase a value called nonce to get the hash which starts with a number of zeros equals/relates to the difficulty.

PoW can help with 2 things: It prevents attackers because it's near impossible to catch up with other nodes alone, and it provides mining rewards so people would try to be neutral rather than being attackers. We will implement mining rewards in the next article when we have a transaction system.

We can implement the PoW system by adding a mine method and a nonce property to our block:

class Block {
    constructor(timestamp = "", data = []) {
        this.timestamp = timestamp;
        this.data = data;
        this.hash = this.getHash();
        this.prevHash = ""; // previous block's hash
        this.nonce = 0;
    }

    // Our hash function.
    getHash() {
        return SHA256(this.prevHash + this.timestamp + JSON.stringify(this.data) + this.nonce);
    }

    mine(difficulty) {
        // Basically, it loops until our hash starts with 
        // the string 0...000 with length of <difficulty>.
        while (!this.hash.startsWith(Array(difficulty + 1).join("0"))) {
            // We increases our nonce so that we can get a whole different hash.
            this.nonce++;
            // Update our new hash with the new nonce value.
            this.hash = this.getHash();
        }
    }
}

Because when we change a small detail in our block, the hash will be completely different, so we are just incrementing nonce over and over again until the hash matches the one we need.

(Note that Bitcoin and others normally use a different way to check difficulty, but we are staying simple)

Moving over to the Blockchain class, we should create a difficulty property:

    this.difficulty = 1;

I will set it to 1, the difficulty should update based on how many blocks mined.

We must update the addBlock method from the Blockchain too:

    addBlock(block) {
        block.prevHash = this.getLastBlock().hash;
        block.hash = block.getHash();
        block.mine(this.difficulty);
        this.chain.push(Object.freeze(block));
    }

Now, all blocks need to be mined before being added to the chain.

Quick note

Because we are staying simple, so I used the proof-of-work system for this blockchain. Note that most modern blockchains use a way better system called proof-of-stake (or many of its upgraded variations).

Testing out the chain!

Create a new file, that file will be the entry file.

Let's use our freshly created blockchain! I'll call it JeChain for now.

Export the needed classes first:

module.exports = { Block, Blockchain };

const { Block, Blockchain } = require("./your-blockchain-file.js");

const JeChain = new Blockchain();
// Add a new block
JeChain.addBlock(new Block(Date.now().toString(), { from: "John", to: "Bob", amount: 100 }));
// (This is just a fun example, real cryptocurrencies often have some more steps to implement).

// Prints out the updated chain
console.log(JeChain.chain);

It should look like this:

The first block is our genesis block, the second block is the added block.

Updated bonus: Difficulty and block time

Block time

Block time is a constant value that resembles estimated time for a block to be added to the chain. Platforms like Bitcoin has block time of 10 minutes, while Ethereum has block time of 13 seconds.

Bitcoin's difficulty formula

With Bitcoin, its difficulty is updated every 2016 blocks were mined. It uses this formula to calculate its new difficulty:

old difficulty * (2016 blocks * 10 minutes) / mining time for the previous 2016 blocks

Now, let's code!

First, we must have our block time first, I'll just set it to 30 seconds, which is equal to 30000ms. I'm using millisecond because it works better with Date.now().

    this.blockTime = 30000;

(Note that we are coding in the Blockchain class here).

Just as an example, I'll create my own system: the difficulty will be incremented by 1 if block time is less than the actual time the block's mined, it will be decremented otherwise.

    addBlock(block) {
        block.prevHash = this.getLastBlock().hash;
        block.hash = block.getHash();
        block.mine(this.difficulty);
        this.chain.push(Object.freeze(block));

        this.difficulty += Date.now() - parseInt(this.getLastBlock().timestamp) < this.blockTime ? 1 : -1;
    }

Important note!!!

Because of how we checked difficulty earlier, this should work fine. However, it is better to check difficulty using log16(difficulty) rather than the difficulty itself, and by doing that, you can now use the Bitcoin's difficulty formula.

You can come up with your own formula though. You should consider what is the best for security while still having good performance.

Source code

You can get the full source code at this repo:

nguyenphuminh / JeChain

JeChain decentralized application platform and smart contract blockchain network

Honorable mention

I have learnt a lot about blockchains from Simply Explained. This article might never exist without help from their videos. Please check them out on Youtube, they have really good blockchain tutorial series.

I also grabbed some info on this article too. Check them out!

Off-topic

Should I continue the series? And if yes, what should I write about? Proof-of-stake? Full cryptocurrency? Smart contracts? Please let me know in the comment section.

Forem: FreakCdev

Build a p2p network and release your cryptocurrency

What is a p2p network?

What and how we are trying to achieve

Setup

Basic concepts of ws

A basic node

Integrate our blockchain into the network.

What do we need to do?

0. Adding necessary stuff

Related methods

1. Transactions

2. Mining and sending new blocks

3. Sending chains

Testing in localhost

Releasing our coin (testing publicly)

Source code

Shoutouts

Contacts

Creating a cryptocurrency - Creating transactions, mining rewards, mint and gas fee

What we are trying to achieve

The transaction class

Mining transactions

Mining reward

Minting

Signing

Generate a keypair

Signing transactions

Validation

Releasing the first few coins ever

The problem with minting

Gas fees

Testing

Honourable mention

Resources

Creating a blockchain in 60 lines of Javascript

What is a blockchain?

Setup

Creating a block

The blockchain

Validation

Proof-of-work

Quick note

Testing out the chain!

Updated bonus: Difficulty and block time

Block time

Bitcoin's difficulty formula

Important note!!!

Source code

nguyenphuminh / JeChain

JeChain decentralized application platform and smart contract blockchain network

Honorable mention

Off-topic

Contacts

Basic concepts of `ws`