Getting Started with Ethereum Blockchain Development Part 1

March 4, 2018March 5, 2018 ~ Ajith Vallath Prabhakar ~ Leave a comment

We will walk through the process of setting up a Blockchain development environment in this blog.

In this exercise, we will do the following

Setup a minimal Private Ethereum Blockchain Network with one mining node and one transaction node in Microsoft Azure
Setup the basic smart contract development environment on your local computer
Write and deploy a simple sample contract in the local machine
Deploy the same in the Private Ethereum Blockchain Network

We have a lot to do, so let’s get started …

If you choose to skip the Private Ethereum Blockchain creation and wanted to just test in your local environment you can skip the Step 1 of this Excercise.

Step 1: Setting up a Private Ethereum Blockchain in Microsoft Azure

Setting up your Azure account is beyond the scope of this exercise, it is free to sign up, and you receive a 100$ credit when you set up your Azure account which will be more than enough for you to complete this tutorial

Go to https://portal.azure.com and click on Create a Resource and select Blockchain, from the Featured, choose Eethereum Consortium Blockchain option
In the Basics page Enter the following and Click OK
- - - Resource prefix
      Put a String that will be used as a base for naming all the resources that will be created for this tutorial
    - VM username
      Leave the default which is “gethadmin“
    - Authentication type
      Let’s make it simple by selecting Password option
    - Password
      Type in a password that you will remember
    - Resource Group
      Create a new Resource group and name it
    - Location
      Select an Azure location of your choice
In the Network Size and Performance Page Enter the following and Click OK
- Number of Consortium members: 2
  This means the number of members of this blockchain. Each of this participants gets a mining node.
- Mining Nodes: 1
  This means you will have 1 mining node per participants in this Blockchain. This node will be responsible for mining blocks in your blockchain
- Mining Node Storage Performance: Standard
  Selecting the default and cheapest option
- Mining node Storage replication: LRS
  Select the default value
- Mining node virtual machine size: 2X Standard D1 V2
  We do not want a very powerful machine for this tutorial so let’s get a small one
- Transaction Nodes: 1
  This node will be submitting its transactions this Blockchain
- Transaction Node Storage Performance: Standard
  Selecting the default and cheapest option
- Transaction Node Storage replication: LRS
  Select the default value
- Transaction Node virtual machine size: 1X Standard D1 V2
  We do not want a very powerful machine for this tutorial so let’s get a small one
In the Ethereum Settings Options enter the following and Click OK
- Network ID: 111222333
  This id is used to name this private Blockchain network, Only the nodes with the same id can peer with each other.
- Custom Genesis Block: No
  Custom Genesis Block can be provided as a JSON if you are creating a Blockchain for a specific use. Since its the basic tutorial lets allow the mining node to create our Genesis Block.
- Ethereum Account Password: <Enter a password of your choice>
  This will be the password of default ethereum account. Note this password down; we will use this later
- Ethereum private key passphrase:
  This passphrase will be used to create the private key of the default ethereum account
View the Summary on the next page, Click Ok
Accept the Terms and Conditions and Click OK
Let Azure do its job and wait for approximately 10 mins to see your Blockchain Network Completely in the Azure Portal
Click on the Name of the Resource Group that you created -> Deployment and select Microsoft-azure-blockchain.azure-blockchain–XXXXXXXXX to look at the details of your blockchain
Note down the following information from the Details page
- Admin Site URL
- ETHEREUM-RPC-ENDPOINT
- SSH-TO-FIRST -TX-NODE
Copy paste the URL of admin site into your browser, and you should see something similar to the below image
Our Blockchain Network is up and running. However, we need to we need to unlock the default account of this Blockchain to make any modifications to it. To unlock the default account, we have to SSH into the Transaction node.
Open the Terminal on your Mac or Linux system or use Powershell in windows to SSH. Use the SSH-TO-FIRST -TX-NODE value that we copied from our previous step to Open an SSH Connection.
Ignore the warning that you will receive when you first SSH to the transaction node about the authenticity of this host.Use the password that we provided for Ethereum Account Password: in the previous step
Type in the Following Command to connect to Geth in the Transaction node.
```
$ geth attach
```
Geth is a javascript runtime environment (JSRE) provided by Ethereum to interact with Ethereum. You can find more details about Geth here
In the Geth Console type in the following command to unlock the default account.
```
personal.unlockAccount(eth.coinbase)
```
eth in this context is a shortcut for web3.eth
This will ask for the Passphrase, Provide the passphrase we created in the previous step. You should get a response “true” if the passphrase is correct

That’s it your Ethereum Private Blockchain is ready to roll

Step 2: Setting up your Local Development Environment with Ethereum Essentials

Lets now set up your local development environment with the essentials. We will need to do the following.

Download and install Visual Studio Code from https://code.visualstudio.com
Install the following plugins for Visual Studio Code
Download and install NPM (Node Package Manager)
Go to https://nodejs.org/en/ and download the latest LTS Version of Node. At the time of writing this blog 8.9.4 is the current version, so we are going with that.
Install the following Node packages using NPM (For opening npm use console in mac and Linux or use Powershell with option Run as Administrator in Windows)
1. windows-build-tools (Only on Windows)
  Windows-build-tools are used to compile native node modules in windows. you can find more information about windows-build-tools at https://www.npmjs.com/package/windows-build-tools
```
npm install --global --production windows-build-tools
```
2. truffle
  Truffle is a development environment for ethereum; We will use this to create and compile our smart contract. you can find information about truffle at https://www.npmjs.com/package/truffle
  Use the following command for windows
```
npm install -g truffle
```
  and this one for Mac or Linux
```
sudo npm install -g truffle
```
3. Ethereum-testrpc
  testrpc is an Ethereum client used for testing and development. More information about testrpc can be found at https://www.npmjs.com/package/ethereumjs-testrpc
  Use the following command for windows
```
npm install -g ethereumjs-testrpc
```
  and this one for Mac or Linux
```
sudo npm install -g ethereumjs-testrpc
```

Step 3: Create your first Smart Contract

In this step, we will create a smart contract, test it locally in testrpc and deploy it to your newly created Blockchain network and run it.
We will be writing this contract using Solidity. Learn more about Solidity and its syntax at https://solidity.readthedocs.io/en/develop/index.html

The Smart Contract that we are going to just print HelloWorld. We will use Truffle to do the following

Initialize the project
Add a Smart Contract
Compile the contract
Deploy the contract to local testrpc server and to the Private blockchain

Setting up the Project
1. Create a new folder called “HelloWorld” on your local machine and open the PowerShell or terminal window pointing to HelloWorld folder
2. Initiate the Project by calling the unbox command.
```
$ truffle unbox
```
  Truffle Boxes are boilerplates that you can use for kickstarting your development. You can read more about truffle boxes from http://truffleframework.com/boxes/
  unbox command without any arguments creates a default MetaCoin contract.
  Since we are not dealing with MetaCoin in this exercise, we will clean this project up in a later step. Open the folder using the Visual Studio Code, and you should see a structure similar to this.
Create a new Smart contract

You can either create a contract manually, or you can use truffle to create a new contract. We are going to use truffle to create the new contract.
Type in the following command in the terminal / PowerShell
```
$ truffle create contract HelloWorld
```
If you look in the contracts folder of your project, you can see that Truffle had created a new Solidity file HelloWorld.sol Another Option is to create a new file manually in contracts folder with the name HelloWorld.sol

Your Contract name must match with the Solidity file that you create for that contract.
Write the Logic of our Smart Contract

Truffle “create contract” has created a basic skeleton for our contract. Since the logic of our smart contract is very simple to copy paste the following code to the HelloWorld.sol
```
pragma solidity ^0.4.4;

contract HelloWorld {
  function HelloWorld() {
    // constructor
  }

  function sayHello() public returns (string) {
        return ("Hello World!!!");
  }

}
```
Before we compile our contract, Let’s clean up our project. Delete the following files from the contacts folder.
1. ConvertLib.sol
2. MetaCoin.sol
Compile our Smart Contract

Since we are using truffle to compile our contract, type in the following command in the terminal to compile our smart contract
```
$ truffle compile
```
Truffle will compile the code and will generate a build folder in the project. If Examine the build/contracts folder You will find HelloWorld.json which has the deployable binary.
Deploy Smart contract in local testrpc

We are using truffle to deploy our contract, to let the truffle know that we are deploying this contract in our local folder we first have to make sure that we have localhost as a destination in the truffle.js file. You can find the truffle.js file in the root folder of your project. Truffle unbox command should have pre-populated with the localhost network. Open your truffle.js and make sure that you have the following entry.
```
module.exports = {
  networks: {
    development: {
      host: "localhost",
      port: 8545,
      network_id: "*" // Match any network id
    }
  }
};
```
Truffle requires having a “Migrations contract” to use the migrate feature. You would have noticed that we did not delete “Migrations.sol” in the contracts folder when we did the clean up in the previous s step. Open 2_deploy_contracts.js from migrations folder. This is the file that truffle uses to determine the contracts to deploy, Clean up this file to remove the reference to the files that we deleted and add a reference to our HelloWorld Contract. Change the 2_deploy_contracts.js to this.
```
var HelloWorld = artifacts.require("./HelloWorld.sol")
module.exports = function(deployer) {
  deployer.deploy(HelloWorld);
};
```
We now need to start our local testrpc server. Open a new Terminal / PowerShell window and type the following command
```
$ testrpc
```
That will start your testrpc server, testrpc comes with 9 accounts, and the first one is the default account. The private keys listed below are the private keys of the accounts. testrpc runs on port 8545

Run the following command in the terminal to deploy the contract to testrpc server.
```
$ truffle migrate
```
If you see a screen similar to this means your contract has been successfully published to the testrpc server.
Execute the Smart Contract

We will use truffle console to execute our HelloWorld contract.
Truffle console is a javascript console that can be used to interact with smart contracts.
Type the following command on the terminal to open truffle console.
```
$ truffle console
```
1. Since this is a javascript console define a variable that will hold the reference to the contract.
```
var hwcontract
```
  Just like the Google Chrome or any other javascript consoles when you define a variable you will get a message “undefined” You can ignore it.
2. In the testrpc, we need to Get a reference to our contract asynchronously since truffle executes the commands line by line make sure that the complete
```
HelloWorld.deployed().then(function(deployed){hwcontract=deployed;})
```
3. Execute the contract in the asynchronously
```
hwcontract.sayHello.call()
```
  You should be able to see the Hello World in the console
  
  Congratulations you had successfully executed your first smart contract in testrpc.
Deploy HelloWorld contract to our Private Blockchain

To deploy this contract to our newly created blockchain, we need to update the truffle.js with the network information of the blockchain network that we had created in our previous step.
Update the truffle.js with the following snippet.
Replace the xxxx with the hostname of ETHEREUM-RPC-ENDPOINT that we copied in the previous step.
Remember the host value should be just the hostname of our endpoint. So do not add the https or the port name to the host value, just add hostname.

network_id is the id that we entered as network id when we created our blockchain
```
module.exports = {
  networks: {
    development: {
      host: "localhost",
      port: 8545,
      network_id: "*" // Match any network id
    },prod: {
      host: "xxxxxx",
      port: 8545,
      network_id: "111222333"
    }
  }
};
```
1. We need to unlock the default account of our blockchain before we start the deployment, Repeat the steps 12, 13, 14 and 15 from Step 1 to unlock the default account
2. Now Use the truffle with network parameter to migrate out the contract to the network.
  Go to the terminal issue and type in the following command
```
$ truffle migrate --network prod
```
  This might take some time.
  Once the migration is completed, you should see a screen like this
Execute your Smart contract in the real Blockchain

We will use truffle console here also to execute our contract.
In order to connect to a remote network we need to use use the network parameter while starting the truffle console.
Type the following command on the terminal to open truffle console.
```
$ truffle console --network prod
```
1. Like in the previous step define a variable that will hold the reference to the contract.
```
var phwcontract
```
2. Get a reference to our contract
```
HelloWorld.deployed().then(function(deployed){phwcontract=deployed;})
```
3. Execute the contract. If you notice here instead of calling the contract asynchronously, we are directly executing the contract here.
```
pcontract.sayHello()
```
  The execution on the real blockchain is going to be a lot slower than the testrpc. However, you should be able to see the response like this in your console.

Congratulations, you successfully created and deployed your first smart contract. This is just a beginning. We will do more exciting programs in the future.

BlockChain Fundamentals Part 1

February 1, 2018March 13, 2018 ~ Ajith Vallath Prabhakar ~ 4 Comments

Let’s take an example where Person A is transferring $50 to Person B.
Person A sends a request to his Bank for initiating the transfer, Bank verifies the request and if everything is ok then subtracts $50 Person A ‘s account and adds $50 to the account of Person B. Then bank updates its ledgers to reflect these changes.

Transaction in a Centralized Ledger

If you look at any of the transaction that we do these days are mostly handled by one or more servers managed by a single entity. This entity could be your bank, a social media or an online shop, and they all do a standard action, record your transactions in a centralized database.

Centralized Ledger

You might already be thinking that these entities do not really use a single server or ledger to perform these transactions, that is true even if they have multi-geographic fault tolerant sophisticated server farms to store their ledgers they all are managed and controlled by a single entity. In other words, the entities who records these data has the full control to do any action with their data.

Person A in the above case has to trust that the bank he transacts with will act as he expects, Though this system has been working for some time, there are few drawbacks for this type of transactions and ledgers.

The entity who owns the ledger has the full control over it and can manipulate the ledgers at it is on will without its customer’s permission.
The records in this ledger can be easily tampered with by someone who has access to it, means if someone makes some malicious changes to this ledger that can affect everybody who is relying on that ledger. (for example, someone can hack into the bank’s centralized ledger and modify transactions).
Another disadvantage is the single point of failure. For example, if the bank decides to shut down their service users will not be able to perform transactions.
In the extreme case where a natural disaster wipes out their all data centers, all the transactions from the ledgers will be lost.
Centralized Ledgers stores data in Silo’s, means, for example, your bank has its ledger, an auditor has his ledger, tax authorities have its ledgers, and they are never synchronized.
Though it is a centralized ledger from the general point of view, the organizations will have to spend too much of money to build redundancy and scaling to their ledgers. That makes this very expensive

What is BlockChain

In simple terms, Blockchain is a distributed ledger of transactions. All the transactions in the blockchain are encrypted and synchronized between the participants.

Blockchain-workings-explained

Key points about Blockchain

It is a Distributed Ledger.
Members of a blockchain network are called Nodes.
Each node has the copy of the full ledger.
Nodes use Peer to Peer Network for synchronization.
All information on the Distributed ledger is Secured by Cryptography.
By design Eliminates the need for a Centralized Authority to validate transactions by performing peer validations before any transactions
The transactions are added to ledger based on Consensus from nodes.
Each valid transaction in the Blockchain is added to a Block
Blockchain miners create Block
Multiple Blocks make a Blockchain.
All Blocks in Blockchain are Immutable.
It ensures the Complete Audit trail of the whole transactions (Verifiability)

I know this is too much to chew on, I promise you will get all these concepts by the end of this article. So be with me and let’s move on…

Distributed Ledgers (DLT)

According to Wikipedia “A distributed ledger is a consensus of replicated, shared, and synchronized digital data geographically spread across multiple sites, countries, or institutions. There is no central administrator or centralized data storage.”

In the Distributed ledger each participating member has a copy of the ledger, In simple terms during any transactions, it updates the ledger of the sender and receiver then broadcast the transaction, The transaction details are updated in the ledgers of all of its participants using peer to peer network.

Peer to peer (P2P) network

Peer to Peer (P2P) is a decentralized communication model where each participating nodes will have the same capabilities. Unlike the client-server model, any node in the peer to peer network can send requests to other nodes and respond to requests by other nodes. The best example for a peer to peer network is BitTorrent.

Peer to peer Network

Any peer can perform a transaction on the P2P network this means When one node can perform a similar transaction at the same time it will end up in conflicts. This is called double-spend problem. Blockchain uses a consensus system to resolve these kinds of conflicts.

We will discuss the double-spend problem and consensus systems in detail in a later post. Let ‘s focus on the basic concepts first.

Cryptography in Blockchain

Due to its nature, any data in a Blockchain is visible to all the members of the network, this makes this data vulnerable and hackable, however, Blockchain uses cryptography to make all the transactions extremely safe and secure.

In simple terms, Cryptography is used for obfuscating (encrypting and decrypting) data. Blockchain leverages two cryptographic concepts in its implementation.
They are the following

Hashing
Digital Signature.

What is Hashing

Hashing is a mechanism where any input is transformed to a fixed size output using a hashing algorithm. The input could be of any file type, for example, you can generate a hash of an image, text, music, movie or a binary file.

Hashing-Representation

Whatever may be the size of the file, hashing algorithm guarantees that the output is of a fixed size. (For example, if you create an SHA 256 hash of any file the hash will always be 256 bits.)

Key properties of Hashing.

Any hashing algorithm should adhere to the following principles.

Determinism

For a given value the algorithm should always produce the same hash value.

For example, the SHA 256 Hash of the word "Hello World"  will be always
A591A6D40BF420404A011733CFB7B190D62C65BF0BCDA32B57B277D9AD9F146E

Pre-image resistance

This means it should be computationally hard or impossible to decrypt the input from the output.

In the above example, we saw the hash value
A591A6D40BF420404A011733CFB7B190D62C65BF0BCDA32B57B277D9AD9F146E
represents "Hello World". 
It is impossible to decrypt the word Hello World from the above hash value.

Second pre-image resistance

This means the hash generated with input should not match with a hash value of a hash value of a different input
For example function hash(“Hello World”) != function hash(“XXX”) where “xxx” is any input other than word “Hello World”

Collision Resistance.

This means it should be hard or impossible to find two different input (of any size or type) to have the same hash. Collision Resistance is very similar to Second pre-image resistance.

Hashing is commonly used to find the checksum of a file. For example, when you are downloading software from a server the software vendor provides the checksum or Hash of the software package. If the hash of the downloaded software is matched with the hash given by the provider of the file, we guarantee that the software was not tampered with.

Blockchain uses Hashes to represent the current state of the blockchain. Each block in the blockchain may have hundreds of transactions and verifying each transaction individually is going to be very expensive cumbersome. So Blockchain leverages Merkle root to verify the transactions.

Merkle tree of a Block

In a Merkle tree, each non-leaf node will have the hash of their child nodes. Look at the below diagram to understand the concept of Merkle tree.

MerkleRoot

Each block in the blockchain has the Merkle root of its transactions and the hash of its previous block. The hash of Merkle root can be used as a definitive mechanism to verify the integrity of the block as even the slightest changes to any of the records in this tree will alter the value of the original Merkle Root.

In other words, the entire state of a Blockchain system can be validated by the hash of its last block which is of 256 bits.

What is a Digital Signature

A classical example of Digital Signature is the website traffic using HTTPS protocol using SSL. SSL uses the digital signatures to ensure the authenticity of the server.

A User generates a digital signature by generating a Public and Private key Pair.

Generated Key

A Public key an a Private key has mathematical relations that tie each other. The private key should be kept as secret and should be used for signing messages digitally. A public key is intended to be distributed publically which should be used by the message recipient to validate the authenticity of the message.

Sending a Message with Digital Signature

Sender signs all his transactions with his generated private key. This will ensure that only the owner of the account with the private key can do the transaction.

Verifiying a message with Digital Signature

The Reciever or any nodes in the Blockchain verifies the transaction by checking the digital signature of the transaction using the public key.

Key Points to Remember about Hashing in Blockchain

Hashing is used for verifying the integrity of the transaction
The digital signature is used for verifying the identity of the performer of a transaction.

For learning more about the Cryptography and Hashing in Blockchain, please visit the following links

https://blockgeeks.com/guides/cryptocurrencies-cryptography/

https://blockgeeks.com/guides/what-is-hashing/

What is a Block

We saw that Blockchain is a group of blocks in sequential order, Let’s take a quick peek at what a block is? In simple terms Block is a group of valid and verified transactions. Each block in the blockchain is immutable. Block miners will continuously process new transactions, and new blocks will be added to end of the chain. Each block will have the Hash of the previous block thus ensuring the integrity of the chain.

Block Structure in BlockChain

Every block in a blockchain will have the following information

Hash of the previous Block
Timestamp at which the block was created
List of the transactions that were part of that Block
Merkle tree of all the transactions in that block
Nonce – (A random String generated by miner)
Hash of header of the block which will be used as the Hash of the previous block in the next block

Let’s take a look at a real example of a Block; As you all know Bitcoin is based on Blockchain, To explain a Block I am referring to a block from bitcoin transaction. I had taken a real Block from Bitcoin Blockchain network from www.blockchain.info

You can see that this block has a header and a list of transactions. Transactions and its details can vary depending upon the blockchain implementation since this is a Bitcoin block you will see Bitcoin transactions.

Bitcoin Block Sample

Let’s go through each some of the key datasets in this block header

Field name	Summary
Block Id	Unique ID representing this block
Number of Transactions	Total number of transactions recorded in that block
Height	Total number of blocks preceding to this block on that blockchain, (in this case, there are 505234 blocks created before this block)
Timestamp	Time at which this block was created
Relayed By	Miner who mined this block
Transactions	This shows the hash of each transaction with its details

Genesis Block

We learned that any Block will always have the hash of its previous block attached to it. So its implied that First block (Block 0) of a Blockchain will not have a previous block, and this is known as Genesis Block. Genesis block is almost hardcoded into the applications that use that blockchain.

Click here to see the Genesis Block of Bitcoin

Block time

Block time is the time taken to mine a block. Block time varies from implementation to implementation in the blockchain. To provide security and prevent forking each implementation defines its own block time. For Bitcoin, the block time is 10 mins whereas for Etherium its around 20 seconds.

What is in a transaction

Again I am taking a bitcoin transaction to explain a transaction record in Blockchain. The below transaction shows the transfer of a bitcoin from one address to two recipients which was part of the Block that you had seen in the previous image.
The Tree diagram below shows the related transfers of those bitcoins. This related or audit trail of the asset (Bitcoin in this example) ensures the legitimacy of this transaction.

Bitcoin Transaction

What is Block Mining

In simple words, Miners are the one who runs a specialized version of the Blockchain software which can add a Block to the Blockchain. The miners get rewarded each time when they add a block to the Blockchain. There may be multiple miners who will compete with each other to create a Block in the blockchain in a network.

Blockchain Network with Nodes and Miners

Miners keep transaction pool of unconfirmed transactions tries to wrap around them to create a block. They will have to solve a mathematical puzzle to add the block to the blockchain. These mathematical puzzles are to create a hash of the block of a particular nature.

The constants in this puzzle are the following

Previous Block Hash
Time Stamp
Merkle root

The variable in this puzzle is the Nonce. A nonce is a fixed size string that can include both numerical and characters.

Miners keep trying new nonce till they solve this puzzle and the first miner who can solve this wins and broadcast to the network and the block is added to the chain. Then the nodes add this block to their ledger.

Currently, Bitcoin and Etherium use an algorithm called proof-of-work to mine a block,

Below is the illustration of the proof-of-work algorithm.

Proof of work - Bitcoin Implementation

There are multiple algorithms used by blockchain network for mining and consensus, We will discuss those algorithms in detail in a different post.

Few Usages of Blockchain

The blockchain is an emerging technology and there are a ton of use cases that we can solve with this. Here are the few use cases that can leverage the power of Blockchain.

Health care records sharing
Privacy of Personal health records is a major concern right now, think about a system where your personal health records can be stored in a blockchain and shared with the doctors within seconds.
Insurance Claim Processing
We know that Insurance industry is prone to lots of fraudulent claims and fragmented sources of data. Chances of error (intentional or unintentional) are very high. With the Blockchain, we can have more transparent and error-free insurance claims.
Payments and Banking
The Major issue in the banking and payment sectors are fraud and money laundering. With the transparency Blockchain provides we should be able to eliminate most of these.
Voting systems
We saw earlier that Blockchain is tamper proof or tamper evident. Implementing a blockchain based voting system can create an unhackable voting system.
Smart Contracts
Smart contracts allow the self-execution of contracts. (I will cover smart contracts with examples in a different post). Blockchain not only eliminates the need for third-party for smart contract enforcement but also enforces the terms of a contract when the terms are met.

If you look at these use cases the blockchain will be a great choice if we auto validate the transactions using smart devices. In other sense, in order to leverage the full potential of Blockchain, we need to have more IoT sensors which can validate many of these “transactions”.

Food for thought

Imagine you go to a grocery store and pick up a bottle of organic, you are not sure whether this milk is really organic or not, you take your smartphone and scan the QR code of the batch id of the milk, The application lists out the details of dairy farm along with the cattle food they are buying, health history of the all the cows in the farm along with their medical records where you can trace back to each and every detail of what the farm states about the milk… that is the future that Blockchain can offer.

Implementations

If you look at the Gartner Hype Cycle for emerging technologies 2017 you can see that Blockchain is slowly moving to Trough of Disillusionment and they are expecting this to mature to mainstream adaptation in 5 to 10 years. My feeling is this could be shorter.

Emerging Technology Hype Cycle for 2017_Infographic_R6A — Picture Courtesy – Gartner.com

Having said that, there are a ton of development going on in the Blockchain field, Both large and small scale players are bringing lots of innovation to the blockchain technology.

Below are few of the current major implementations of blockchain

Bitcoin

I don’t think Bitcoin needs an introduction, It is the first digital cryptocurrency and leverages the blockchain technology.

Ethereum

Etherium is an open-source blockchain platform for Blockchain applications and smart contracts. It is the first majorly accepted Blockchain platform. We will cover more on Ethereum in a different post.

We covered the basics of Blockchain here, This is just a beginning. Stay tuned more articles where we will get to more depth on some of the topics that we discussed here.

Thanks for reading and Please leave your feedback in the comments section.