Ethereum Blockchain Simple Contract Example

This article is about how to get started with creating and deploying a really basic smart contract on the Ethereum network using the Truffle development environment and some solidity scripting .

Solidity is the language in which the contracts are writing its pretty simple enough but lets make some small steps against which then we can build more complex scenarios.

Assumptions :

• We are deploying to an Ubuntu env. , although the commands could be adapted to whichever environment your using 
• We are starting with a fresh Ubuntu with nothing on it
• Ubuntu version used is 16.04 LTS
• We are going to use a development framework such as Truffle to help us in quickly testing our smart contract
• We are not going to connect to either the live or test 'morden' Ethereum network instead we are going to run a test environment locally, this is done via the ethereumjs-testrpc
• Ubuntu server in my case is a t2.medium server 2 cpu with 4GB RAM at least 

Prerequisites

- NodeJS 6

Execute the following commands :

sudo apt-get install python-software-properties

$ curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -

sudo apt-get install -y nodejs

sudo apt-get -y install build-essential

-Install GIT:

sudo apt-get -y install git

- Install truffle:

sudo npm install -g truffle

- Install euthereumjs-testrpc:

sudo npm install -g ethereumjs-testrpc

Starting Test Ethereum Node

Assuming all the installs above were executed without any issues , the first thing to do is fire up your test rpc server using the following command :

testrpc

This should output something like this:

Truffle Workspace

Now lets follow the example from the truffle website on getting started  :

1. Create a directory myproject : mkdir myproject 

2. cd to the directory : cd myproject

3. Execute the truffle initialisation command : truffle init

This will generate a number of truffle files to ease our development to check the official documentation to stay up to date with more extensive information around what each folder and each file does .

However we are concerned at the moment only with the contracts and this would be in the contracts folder where you will see the following files:

ConvertLib.sol  MetaCoin.sol  Migrations.sol

The MetaCoin.sol is the main contract , it imports the ConvertLib.sol library and the Migrations.sol tells truffle how the contracts needs to be deployed. Feel free to open them to have a look.

Adding our own contrats 

Now in that same directory we are going to add 2 new sol files for a very simple dummy hello world type application  ( contract name and file name needs to be exactly the same ) :

-------Contents of Mortal.sol----------

pragma solidity ^0.4.4;

contract Mortal{

    address public owner;

    function mortal(){

        owner = msg.sender;

    }

    function kill(){

        suicide(owner);

    }

}

-----------------

Then another sol file

-----User.sol-----------------

pragma solidity ^0.4.4;

import "Mortal.sol";

contract User is Mortal{

        string public userName;

        string public ourName;

        function User(){

          userName= "Javed";

        }

        function hello() constant returns(string){

        return "Hello There !";

    }

        function getUserName() constant returns(string){

        return userName;

    }

}

-----------------------------------

If you want to know what these files are doing along with syntax i suggest that you follow this great video from one  awesome guy that allowed me to get started quite quickly here are his videos you should watch ( subscribe to his channel ) :

1. Smart Contract 1

2. Smart Contract 2

3. Smart Contract 3

In our case we modified his example such as we get something we can very quickly run and see what happens :) !!

Also in his example he uses the Ethereum wallet but this was a very process for me as the wallet keep synching for a very long time and not even sure if its working fine as well , so better start with a test env . with testrpc .

Truffle Compile

Now go on the console and run the compile command  : 

truffle compile

This will compile your contracts in bytecode .

Truffle Migrate

Now lets move the compiled contracts to test env. ethereum node that is testrcp :

truffle migrate

You should see something like in the left window :

Truffle Build

Now you can build a dapp ( distributed application ) using truffle , i wont go in the details of this as you will find more information from the main documentation page and i am only going to get you started quickly.

Command is well :

truffle build

Truffle Console

Truffle comes with a console that allows you to tap directly into your deployed contract so what you want to do is fire up the console using the command :

truffle console 

Try to execute the following commands :

User.deployed();

User.deployed().userName.call();

User.deployed().hello.call();

You should be able to retrieve values from public property userName and execute function hello.

Conclusion

We managed to :

1. Setup an ubuntu server with all the tools we need to start developping dapps ( nodejs , truffle , ethereumjs-testrpc )

2. We managed to learn about the development framework truffle how to use it

3. We created , compiled and deployed a simple dummy contract to the testrpc node

4. We managed to even call the contract