Create Your Own Cryptocurrency in Private Consortium Network Ethereum Azure Blockchain

Introduction

The words Blockchain and Cryptocurrency have been successful in disrupting the market for such a long time now, the effects they have made in the industry are massive. It looks like it has its own future, so I thought of writing something about it. In this article, we will create our own cryptocurrency and our own private consortium network in Azure. We will be using Ethereum proof of work consortium solution from Azure. Sounds interesting? If yes, let’s just skip the introduction and jump in. I hope you will like this article.

Background

We will be splitting this article into three parts:

1. Introduction to Blockchain and Cryptocurrency
2. Create your Own Private Consortium Network in Azure
3. Create your Own Private Cryptocurrency

What are Blockchain and Cryptocurrency

Blockchain

We can summarize blockchain as the following points:

1. It is a growing chain/list of blocks with records in it.
2. These blocks are linked or chained with Cryptography.
3. Each block will have its own unique cryptography hash.
4. Each block will be having a “Previous Hash” property which is the hash of the previous block.
5. The first block of the chain is known as Genesis block, only this block will not have the property “Previous Hash”.
6. Hash, Previous Hash, Data, Timestamp are the minimum contents of a block.
7. Here, the Data can be anything, for example, it can be the Transaction details like “Amount Transferred”, “Sender”, “Receiver”, etc.

Why Blockchain is Resistant to Data Modification?

By design, the Blockchain is resistant to modification of the data. Why? Each block in Blockchain will have its own unique cryptographic hash and previous hash property. Let’s say the Hash will be regenerated each time when there is a modification of data, timestamp. So, if you do any modification in any blocks, the hash property will be changed to a different one, and the previous hash property of the next block will be invalid, and so on. So, the entire network will have to undergo the update process, which is technically impossible.

Whenever there is an update, a new block will be generated and the same will be chained to the network by taking the hash property of the last block, as its previous hash property.

Real-Time Scenarios Where Blockchain Can Be Used?

The feasibility of Blockchain is almost everywhere, you can think about the scenarios where the same can be applied. I will share a few places where it can be used.

1. What if all of our Government documents are considered as a block? The forgery in documents will become an impossible task. Isn’t it?
2. With the help of Smart Contract, we can use Blockchain even for some business scenarios, where the real-time validations are required, where each stage can be treated as a block.

Cryptocurrency

A Cryptocurrency is a digital currency, which uses strong Cryptographic security, unlike the physical currencies like notes, coins, it doesn’t have any physical form. All the transactions of Cryptocurrency are verified through the network nodes and everything will be recorded in a Blockchain.

The most famous Cryptocurrency in the world is Bitcoin, which was invented by an unknown person or a bunch of people, known as Satoshi Nakamoto, this is the same person who was invented Blockchain.

We all send and receive money to our accounts, but use someone as a mediator, that is Bank. Now, what if we remove that mediator and replace it with a Blockchain? That’s where the Cryptocurrency stands. With the help of Cryptocurrency and Blockchain, we don’t need to worry about the security, high transaction costs which we are charged by the bank. I personally feel that there will a time coming where there will be no physical currency anymore.

Create Your Own Cryptocurrency

We are one step away from creating our own Cryptocurrency. Before we do that, we should create a private Consortium Network where we can add Blockchain. There are two things you must consider in your mind:

1. Coin
2. Token

A Coin is a Cryptocurrency where it uses its own Blockchain, whereas a Token is a Cryptocurrency which uses the existing Blockchain. For example, the Bitcoin uses its own Blockchain. We are going to use an existing Blockchain, which is nothing but Ethereum.

Let’s create an Ethereum account.

Creating an Ethereum Account

To work with Ethereum Blockchain, we need an Ethereum account, in this step, we will see how we can create one. There are many ways we can do this, one of them is using an existing tool called MetaMask. You can consider it a Wallet/Bank where you can create new accounts and do the transactions. You can install MetaMask via a Google Chrome extension, where you can create the Ethereum account and get registered in the network. To install the same, go to the Chrom web store and search for MetaMask, and click on Add to Chrome.

Once you have installed the extension, you will be redirected to a welcome page, you can also go to the page manually by clicking on the new extension icon. Continue the process until the page “Secret Backup Phrase”, this is where you will get your backup phrase, which can be used to restore your accounts in case, you forget the password. So please make a copy of the same. Once you have completed all the steps, an account will be generated for you in the Main Network.

As you can see, it has already generated a public cryptography id for your account, now consider this is your account id. You can always change the network you wish, as there are many other networks available, but we will be adding our own private network later using the custom option. For now, please remember to change it to any test network.

Create Smart Contract

Luckily, to develop our own Token, we don’t need to download any IDE, as Ethereum provides its own online IDE, which is the remix. Go to the IDE, that’s where we are going to develop our own Cryptocurrency. The language used to program here is Solidity, it is a high-level object-oriented programming language used for creating smart contracts.

To create the token, we need to write some codes in Solidity, let’s do that now. Copy the codes below and paste it in the Remix editor, here I have named my Token as SibiCoin. You can use anything you wish.

pragma solidity >=0.4.22 <0.6.0;

contract owned {
    address public owner;

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address newOwner) onlyOwner public {
        owner = newOwner;
    }
}

interface tokenRecipient { function receiveApproval
(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }

contract TokenERC20 {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    // 18 decimals is the strongly suggested default, avoid changing it
    uint256 public totalSupply;

    // This creates an array with all balances
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    // This generates a public event on the blockchain that will notify clients
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    // This notifies clients about the amount burnt
    event Burn(address indexed from, uint256 value);

    /**
     * Constrctor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    constructor(
        uint256 initialSupply,
        string memory tokenName,
        string memory tokenSymbol
    ) public {
        totalSupply = 
        initialSupply * 10 ** uint256(decimals);  // Update total supply 
                                                  // with the decimal amount
        balanceOf[msg.sender] = totalSupply;      // Give the creator all initial tokens
        name = tokenName;                         // Set the name for display purposes
        symbol = tokenSymbol;                     // Set the symbol for display purposes
    }

    /**
     * Internal transfer, only can be called by this contract
     */
    function _transfer(address _from, address _to, uint _value) internal {
        // Prevent transfer to 0x0 address. Use burn() instead
        require(_to != address(0x0));
        // Check if the sender has enough
        require(balanceOf[_from] >= _value);
        // Check for overflows
        require(balanceOf[_to] + _value > balanceOf[_to]);
        // Save this for an assertion in the future
        uint previousBalances = balanceOf[_from] + balanceOf[_to];
        // Subtract from the sender
        balanceOf[_from] -= _value;
        // Add the same to the recipient
        balanceOf[_to] += _value;
        emit Transfer(_from, _to, _value);
        // Asserts are used to use static analysis to find bugs in your code. 
        // They should never fail.
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    }

    /**
     * Transfer tokens
     *
     * Send `_value` tokens to `_to` from your account
     *
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transfer(address _to, uint256 _value) public returns (bool success) {
        _transfer(msg.sender, _to, _value);
        return true;
    }

    /**
     * Transfer tokens from other address
     *
     * Send `_value` tokens to `_to` in behalf of `_from`
     *
     * @param _from The address of the sender
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transferFrom(address _from, address _to, uint256 _value) 
     public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);     // Check allowance
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    /**
     * Set allowance for other address
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     */
    function approve(address _spender, uint256 _value) public
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }

    /**
     * Set allowance for other address and notify
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf, 
     * and then ping the contract about it
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     * @param _extraData some extra information to send to the approved contract
     */
    function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
        public
        returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, address(this), _extraData);
            return true;
        }
    }

    /**
     * Destroy tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount of money to burn
     */
    function burn(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
        balanceOf[msg.sender] -= _value;            // Subtract from the sender
        totalSupply -= _value;                      // Updates totalSupply
        emit Burn(msg.sender, _value);
        return true;
    }

    /**
     * Destroy tokens from other account
     *
     * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
     *
     * @param _from the address of the sender
     * @param _value the amount of money to burn
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {
        require(balanceOf[_from] >= _value);                // Check if the targeted 
                                                            // balance is enough
        require(_value <= allowance[_from][msg.sender]);    // Check allowance
        balanceOf[_from] -= _value;                         // Subtract from the 
                                                            // targeted balance
        allowance[_from][msg.sender] -= _value;             // Subtract from the 
                                                            // sender's allowance
        totalSupply -= _value;                              // Update totalSupply
        emit Burn(_from, _value);
        return true;
    }
}

/******************************************/
/*       ADVANCED TOKEN STARTS HERE       */
/******************************************/

contract SibiCoin is owned, TokenERC20 {

    uint256 public sellPrice;
    uint256 public buyPrice;

    mapping (address => bool) public frozenAccount;

    /* This generates a public event on the blockchain that will notify clients */
    event FrozenFunds(address target, bool frozen);

    /* Initializes contract with initial supply tokens to the creator of the contract */
    constructor(
        uint256 initialSupply,
        string memory tokenName,
        string memory tokenSymbol
    ) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}

    /* Internal transfer, only can be called by this contract */
    function _transfer(address _from, address _to, uint _value) internal {
        require (_to != address(0x0)); // Prevent transfer to 0x0 address. 
                  Use burn() instead
        require (balanceOf[_from] >= _value);                // Check if the 
                                                             // sender has enough
        require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
        require(!frozenAccount[_from]);               // Check if sender is frozen
        require(!frozenAccount[_to]);                 // Check if recipient is frozen
        balanceOf[_from] -= _value;                   // Subtract from the sender
        balanceOf[_to] += _value;                     // Add the same to the recipient
        emit Transfer(_from, _to, _value);
    }

    /// @notice Create `mintedAmount` tokens and send it to `target`
    /// @param target Address to receive the tokens
    /// @param mintedAmount the amount of tokens it will receive
    function mintToken(address target, uint256 mintedAmount) onlyOwner public {
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;
        emit Transfer(address(0), address(this), mintedAmount);
        emit Transfer(address(this), target, mintedAmount);
    }

    /// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
    /// @param target Address to be frozen
    /// @param freeze either to freeze it or not
    function freezeAccount(address target, bool freeze) onlyOwner public {
        frozenAccount[target] = freeze;
        emit FrozenFunds(target, freeze);
    }

    /// @notice Allow users to buy tokens for `newBuyPrice` 
    /// eth and sell tokens for `newSellPrice` eth
    /// @param newSellPrice Price the users can sell to the contract
    /// @param newBuyPrice Price users can buy from the contract
    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }

    /// @notice Buy tokens from contract by sending ether
    function buy() payable public {
        uint amount = msg.value / buyPrice;                 // calculates the amount
        _transfer(address(this), msg.sender, amount);       // makes the transfers
    }

    /// @notice Sell `amount` tokens to contract
    /// @param amount amount of tokens to be sold
    function sell(uint256 amount) public {
        address myAddress = address(this);
        require(myAddress.balance >= amount * sellPrice);   // checks if the 
                                                 // contract has enough ether to buy
        _transfer(msg.sender, address(this), amount);       // makes the transfers
        msg.sender.transfer(amount * sellPrice);            // sends ether to the seller. 
        // It's important to do this last to avoid recursion attacks
    }
}

The first step of the solidity program will start with defining the compiler.

pragma solidity >=0.4.22 <0.6.0;

Once you had edited the token code, you can navigate to the compile tab and compile your code. You can also check the Auto Compile option which will enable the auto-compilation of the code whenever you make any changes.

Once the compilation is successful, you can go to the Run tab. As you can see, the account you had created in MetaMask has already been populated for you.

Now, it is time to deploy our coin in the network, but when you do that, you will get an error as “ALERT: Insufficient funds”. This is because you have only 0 ETH in your account, but no worries, we will find a way to make you rich. Let’s create our own private consortium network now so that we can send money to your account. Are you ready to become rich?

Create Your Own Private Consortium Network

Creating the Network

Login to your Azure portal, and search for “Ethereum Proof-of-Work Consortium”. This is a super handy solution created by Microsoft for the Blockchain enthusiastic people. It deploys an Ethereum network, consisting of a set of transaction nodes and a set of mining nodes to record transactions. It may take between 30 minutes to do all the provision. I would create a separate resource group for this.

Once everything is created, you should be able to go to the resource group and see all the resources created.

Now, click on the resource with the type Public IP address, and copy the DNS name and open in the browser. You should be able to see a page as below.

Here the nodes start with “tx-” are the transaction nodes and the nodes start with “mn-” are the mining nodes. Mining is the process of validating and approving the transactions happening and registering them in the ledger or Blockchain.

Send Ethereum to Accounts

As our Private network is ready, we can potentially change the MetaMask account network from the Test network to the network we have created. Click on the Network and then Custom RPC, in the new Network text box, you can give the DNS name we have generated earlier. Please remember that the default port is 8545.

As we have already connected the MetaMask to our own private network, now we can easily send the Ethereum to this account from our Network. Go to the network and paste the MetaMask account public cryptography key and click submit.

If everything goes well, you should get a message as “Ether sent!”. You should also see that the new blocks are getting generated in both Transaction nodes and Mining nodes. Now we can check our MetaMask account. I can’t wait to see that, I become rich.

Wow!. Now I feel like I have a currency printer. Now we can go and create the smart contract.

Deploy the Smart Contract to Private Network

Now let’s just go to the Remix IDE and compile our smart contract and deploy the Token.

Here, you can see that our account is showing as 2000 ether. Before you deploy the Token/Coin, you should give the value for initialSupply, which is the maximum supply available for this contract, and the tokenName, which is the name of the coin, in this case, it is SibiCoin, and tokenSymbol, which is the symbol of your token. Once you have filled everything, you can click on the Transact button.

A MetaMask pop-up will be generated, click on the Confirm button. If you don’t see the pop-up, please click on the MetaMask Chrome extension button.

If everything goes well, you should be able to see an alert as the transaction is confirmed.

You should also see a deployed contract under the Deployed Contracts section, copy the token and add it to your existing MetaMask.

Add Custom Token to MetaMask Account

To add, go to the MetaMask account details and click on Add Token, and provide the token address.

If you want to change the Decimal Precision, you should edit the same in your custom Solidity code. Once you have added the same, you should be able to see 50000 sc (SibiCoin) in your account.

Sending Custom Coin from One to Another Account

To send our SibiCoins from our account “SibiAccount”, we should create a new account, for now, I will call it “SibiAccount 2”. Now let’s just copy the address of the second account and send some coins, yes, of course for free. Please make sure that you have added the Smart Contract Token in the second account as well.

Once the transaction is approved, you will get a notification and the coins should be reflected in your second account.

Conclusion

Wow! Now we have learned:

• What is Blockchain?
• What is Cryptocurrency?
• What are Ethereum and MetaMask?
• How to create our own Cryptocurrency?
• How to use Azure Ethereum proof of work Blockchain solution?
• What is Smart Contract?
• How to use Remix tool and deploy custom Tokens?
• How to transfer custom cryptocurrency within accounts?

You can always use the monitoring tools available in Azure, I will leave that to you.

Your Turn. What Do You Think?

Thanks a lot for reading. Did I miss anything that you think is needed in this article? Did you find this post useful? Kindly do not forget to share your feedback by leaving a comment below.

History

• 7^th February, 2019: Initial version