Building crowdsourcing application using an Ethereum platform

December 17, 2018 Original post View as markdown

In this section, we will build a crowdsourcing application using an

Ethereum platform. Our crowdsourcing application has the following

requirements;

Register a project that needs funding. The minimum funding amount for a project can’t be changed after the initial setup.
Multiple funders should be able to fund the project.
View the status of the funding at any interval.
Update the status of project as it goes through the process of funding.
Funding of the project can be closed explicitly. If the funding is closed explicitly, the funders should get their respective

amount automatically.

We will create a smart contract that will implement the above use case

requirement. To realize our use case, we will create a local private instance

of Ethereum, where all functions of the use case will be executed locally.

Setting Ethereum on Local Environment

To set up an Ethereum network on a local environment, you will need to

download one of its implementation. We would go with Go Ethereum.

Go Ethereum is an implementation of Ethereum in Go programming language.

To get started, download Go Ethereum a.k.a. Geth for your operating

system from https://geth.ethereum.org/downloads/. The current

version of Geth at the time of writing this book is 1.7.1.

*Tip – If you are

on a MAC, use the following details to quickly install Ethereum using brew.*

*$ brew tap

ethereum/ethereum*

*$ brew install

ethereum*

To bootstrap your private Ethereum network, we need to create a

starting block or the first block termed as genesis block. A genesis block is

the block that contains configuration details of the Ethereum network. The

following JSON file is a sample custom genesis configuration that you will use

to bootstrap the Ethereum private network.

{
  "config": {
        "chainId": 1,
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
    },
  "alloc"      : {},
  "coinbase"   : "0x0000000000000000000000000000000000000000",
  "difficulty" : "0x20000",
  "extraData"  : "",
  "gasLimit"   : "0x2fefd8",
  "nonce"      : "0x0000000000000050",
  "mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "timestamp"  : "0x00"
}

The above configuration file named start.json specifies the fields in

JSON format that sets up the Ethereum network. Some of the significant fields

are difficulty level, gas limit, nonce, mixhash hash

values (used for applying PoW), starting block number (i.e., chainId) and so on. You can also

bootstrap the network with predefined wallet accounts and ether by specifying

it in the alloc field. We will leave

the alloc field blank for now, as we

will focus on creating accounts and mining ethers locally as part of our

application.

In the next section we will create the above genesis block and set up

a local Ethereum network. To get started, download the project from the GitHub

repository – https://github.com/enterprise-blockchain-book/first-edition.git.

Note - For more details

on genesis block, refer to https://github.com/ethereum/go-ethereum/wiki/Private-network

Creating Genesis Block

As a first step, we will bootstrap a local Ethereum network by

creating the genesis block using the above described start.json file. You can

follow the below steps:

Open a terminal or command prompt and navigate to ethereum/setup folder from the downloaded git project. Run the following

command:

geth —datadir=./data init start.json

It will create

the genesis block in the data folder. You should see a message at the end

–“Successfully wrote genesis state”

Next execute the following command to start a local instance of Ethereum using the data folder created in earlier step.

geth

—networkid 999 —ipcpath ~/Library/Ethereum/geth.ipc —rpc —rpcaddr

“127.0.0.1” —rpcapi=“db,eth,net,web3,personal,web3”

—rpcport “8545” —datadir=./data

—rpccorsdomain ”*” console

Note - For

windows, use the same command without the ipcpath. -

geth

—networkid 999 —rpc —rpcaddr “127.0.0.1”

—rpcapi=“db,eth,net,web3,personal,web3” —rpcport “8545”

—datadir=./data —rpccorsdomain

”*” console

The following provides the

details of the above command line options:

networkid – The networkid value of 999 signifies a local environment. There are standard

predefined networkid values from 1 to 5, like 1 for Frontier which connects to

an actual Etherum network, 3 is for Ropsten which is a Test Ethereum

network. Any value other than these

predefined values implies a local instance.
- ipcpath – This is the IPC endpoint file. IPC or interprocess communication allows local processes to
  
  communicate with geth using the IPC endpoint.
- rpc - Enable remote procedure call of Geth APIs over HTTP JSON-RPC protocol.
- rpcaddr and rpcport - Specify RPC address and RPC port
- rpcapi – List of Geth APIs that would be enabled over RPC port
- datadir – The data directory for the databases.
- rpccorsdomain - Comma-separated list of domains from which to accept cross-origin requests from the browser. A
  
  value of “*” implies accept a request from all domains. Our web application
  
  will use XMLHttpRequest to interact with Ethereum node using RPC protocol.
- o console – This would start
  
  the geth node instance and open the console.

*Note - To view all command line options, kindly

visit https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options.*

After you execute

the command, you would see the below set of messages being printed on the

console, denoting IPC endpoint and RPC-HTTP location of the Ethereum node,

along with the Geth JavaScript console welcome message. Let’s refer to the said

console as ‘geth console’, and we would reference this later in this chapter.

You can also see some modules loaded at the end. We will use one of the module

web3 API to invoke certain useful functions.

“INFO

[08-15|17:55:27] IPC endpoint opened: /Users/Navveen/Library/Ethereum/geth.ipc

INFO

[08-15|17:55:27] HTTP endpoint opened: http://127.0.0.1:8545

Welcome to

the Geth JavaScript console!

instance:

Geth/v1.6.1-stable-021c3c28/darwin-amd64/go1.8.3 modules: admin:1.0 debug:1.0

eth:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0”

Creating Main Account

In this section, we would create our first account using geth console.

Follow the steps below:

On the geth console prompt, let’s create an account by invoking the web3 API *personal.newAccount()*method. You can replace ‘password’ by the password of your choice..

web3.personal.newAccount(“password”)

You will see the following public address and keystore location of the

account. The first account is designated as the main account (a.k.a. etherbase)

by default. This is the default address where the mining reward (i.e., ether)

would be credited.

“0x42d187a0fce3392e853770d360e850f2ea1681bc”

INFO [08-15|18:00:47] New wallet appeared url=keystore:///Users/Navveen/Downlo…

status=Locked

You can view the list of accounts, by using the web3 API method personal.listAccounts()

as shown below

web3.personal.listAccounts

The above method

will display the public address of the main account.

[“0x42d187a0fce3392e853770d360e850f2ea1681bc”]

Next, you would get the balance associated with the main account as

web3.fromWei(eth.getBalance(eth.coinbase));

The getBalance() method returns 0, which is

as expected as we do yet have any ethers in the account.

Creating Miners

In this section, we would start mining locally to add ethers to the

main account. Follow the steps below:

Open a new terminal or command prompt and type in the following command to connect to existing Ethereum geth node instance over

IPC port that we had set up earlier. We will provide the path to the existing

IPC endpoint location to the ‘geth attach’ command. Upon running the command it

will open up the console. Let’s refer to this console as ‘geth sub-console’; we

would reference this later in the chapter.

geth

attach ~/Library/Ethereum/geth.ipc

Note - For

windows, use the same command without specifying the ipc path as shown below.

If you recall earlier while starting the geth instance we did not specify ipc

path for windows.

geth attach

You should see

the following message –

instance:

Geth/v1.6.1-stable-021c3c28/darwin-amd64/go1.8.3

coinbase:

0x42d187a0fce3392e853770d360e850f2ea1681bc

at block:

0 (Thu, 01 Jan 1970 05:30:00 IST)

datadir:

/Users/Navveen/Downloads/ethereum/setup/data

modules:

admin:1.0 debug:1.0 eth:1.0 miner:1.0

net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0

On the prompt, enter the following command

miner.start(2)

This will start mining on the geth console. On the geth console, you

should see the messages “committed new block” being printed. The value of 2 signifies the number of

threads. It means the command will spawn two threads to perform mining in

parallel. You can specify any number of threads. Please note that threads are

expensive resources and therefore specifying large number of threads will take

up more system memory.

You can stop the mining after 30 minutes, and you should have enough

ethers in the main account. To stop mining, execute the following command

miner.stop()

Go back to the geth console and type in the following to get the balance of the main account.

web3.fromWei(eth.getBalance(eth.coinbase));

You would see

ethers in your account. For the crowdfunding application, we would need around

2000 ethers. So, make sure you have enough ethers; else you can start the

mining process again by issuing commands in geth sub-console as described

earlier.

With the main

account setup with enough ether balance, next we will create additional

accounts using the Ethereum Wallet application. We will also deploy and execute

our smart contract using the said application.

Installing Ethereum Wallet

Ethereum Wallet provides a graphical interface to create and manage

accounts and execute smart contracts. You can download the Ethereum Wallet for

your operating system from the Download section at https://github.com/ethereum/mist/releases

Next, open the Ethereum Wallet, and this should connect to your running local Ethereum instance. You should see a message – Private NET on the application window as shown below. It effectively means the wallet is connected to the running local instance. Click on Launch Application.

You should see an *Account

Overview* screen as shown in the figure below. The Accounts section contains

the Main Account (etherbase) that we created earlier,

along with the ether balance that was mined locally.

Creating Accounts

Next, we would create sample accounts for our crowdsourcing

application. We will create total of three accounts, two funder accounts and

one beneficiary account for which the money is being raised.

Earlier we created the main account using the Web3 APIs; this option

provides an alternate way to create accounts using the wallet interface.

For creating accounts, click on the Add Account link. Enter the password for the account and confirm

it. Next screen would display the password key files for your account and its

path. If you plan to use your account on other machines or phones, you can

simply import this key files to get access to your account.

Note – A pair of keys, a private key, and a public address defines every account in Ethereum. If you lose the key file, you will lose access to your account. So make sure to backup this key file when running in a production environment. The key file is available in Ethereum node’s data directory. For Mac, this is located at ~/Library/Ethereum, for Linux - ~/.ethereum and for windows at C:\Users%username%%appdata%\Roaming\Ethereum.

The key file is a hidden file; so make sure you have enabled the

appropriate option to view the hidden files.

Click on the newly created account. On the account details page, click on Account 2 and rename it as Funder1. The following figure shows the details of Funder1 account.

Now, click on the copy address

link located on the right side. A warning window will be displayed as the

account is on private network, click *copy

anyway*.

Next, click on Transfer Ether and Tokens. On the Send tab, select From as the Main Account (Etherbase), and the To field should be populated with the address of the Funder1 account. If not, paste the address that you copied in the earlier step. Enter amount as 1000. If you click on Show More Options, you can specify the fee you are willing to pay for executing this transaction in the blockchain network. You can also select a higher fee for faster processing of the transaction. Since this is a private network, drag the fee slider to Faster. The following figure shows the Send tab with these details. Click Send.

On the Send transaction window, specify the account password to confirm the transaction. In this page, you would see the gas price, the estimated consumption fee in ethers from earlier selected option and the maximum fee, which you are willing to pay for the transaction.

If you go to Wallets tab and scroll down to Latest Transactions section, you would see a transaction entry for the above record and confirmation block counts (0 of 12.). To invoke this transaction, the miner needs to be started, as they would execute the transaction and commit the block. Start the miner again in the geth sub-console using the command miner.start(2) as described earlier and you would see the confirmation block count progressively increasing as shown in the figure below.

Once the confirmation count reaches 12 of 12, the block would be added

to the blockchain. If you click on it, you can view the transaction details and

block number mined for this transaction.

*Note – The number

of confirmations is the number of new blocks (in a sequence) that is appended

to a block of transaction. The 12 number implies, 12 new blocks were appended

to the block that contains your transaction. Once the confirmation is reached,

the transaction block is committed. The confirmation is required to ensure a

secure block is being committed to the blockchain and avoid orphaned blocks.

The orphaned block occurs when two miners produce blocks at the same time.

However, some public Ethereum network might require many blocks for

confirmation based on their use cases, which implies it might even take hour(s)

for a single block to be committed. For more details, refer to this excellent

article from* Vitalik Buterin*at

https://blog.ethereum.org/2015/09/14/on-slow-and-fast-block-times**/*

Similarly, create another account called Funder2 and transfer 500 ethers from Main Account. For the beneficiary account, create an account and call it as ProjectAI. We will transfer the funds to ProjectAI account now using smart contract. Copy the address of ProjectAI account, as we would need this later once we deploy the contract. The following image shows the snapshot of all the accounts created so far along with its balance in ethers.

In the next article, we would create the smart contract,

blockchain