Ethereum Hello World Example Using solc and web3

DZone 's Guide to

Ethereum Hello World Example Using solc and web3

Looking for an example of how to get an Ethereum Smart Contract up and running quickly? Then look no further and come check out this post!

· Security Zone ·
Free Resource

I’ve been trying to find an Ethereum Hello World example and came across Thomas Conté’s excellent post that shows how to compile and deploy an Ethereum smart contract with solc and web3.

In the latest version of web3, the API has changed to be based on promises so I decided to translate Thomas’s example.

Let’s get started.

Install npm Libraries

We need to install these libraries before we start:

npm install web3
npm install abi-decoder
npm install ethereumjs-testrpc

What do these libraries do?

  • web3 is a client library for interacting with an Ethereum blockchain.
  • abi-decoder is used to decode the hash of a smart contract so that we can work out what was in it.
  • ethereum-testrpc lets us spin up a local test version of Ethereum.

Smart Contract

We’ll still use the same smart contract as Thomas did. Token.sol is a smart contract written in the Solidity language and describes money being transferred between addresses:


pragma solidity ^0.4.0;

contract Token {
    mapping (address => uint) public balances;

    function Token() {
        balances[msg.sender] = 1000000;

    function transfer(address _to, uint _amount) {
        if (balances[msg.sender] < _amount) {

        balances[msg.sender] -= _amount;
        balances[_to] += _amount;

Whenever somebody tries to transfer some money we’ll put 1,000,000 in their account and then transfer the appropriate amount, assuming there’s enough money in the account.

Start Local Ethereum Node

Let’s start a local Ethereum node. We’ll reduce the gas price – the amount you ‘pay’ to execute a transaction – so we don’t run out.

$ ./node_modules/.bin/testrpc --gasPrice 20000
EthereumJS TestRPC v6.0.3 (ganache-core: 2.0.2)

Listening on localhost:8545


We need to load a few Node.js modules:

const fs = require("fs"),
      abiDecoder = require('abi-decoder'),
      Web3 = require('web3'),
      solc = require('solc');

Compile Smart Contract

Next, we’ll compile our smart contract:

const input = fs.readFileSync('contracts/Token.sol');
const output = solc.compile(input.toString(), 1);
const bytecode = output.contracts[':Token'].bytecode;
const abi = JSON.parse(output.contracts[':Token'].interface);

Connect to Ethereum and Create Contract Object

Now that we’ve got the ABI (Application Binary Interface), we’ll connect to our local Ethereum node and create a contract object based on the ABI:

let provider = new Web3.providers.HttpProvider("http://localhost:8545");
const web3 = new Web3(provider);
let Voting = new web3.eth.Contract(abi);

Add ABI to Decoder

Before we interact with the blockchain, we’ll first add the ABI to our ABI decoder to use later:


Find (Dummy) Ethereum Accounts

Now we’re ready to create some transactions! We’ll need some Ethereum accounts to play with and if we call web3.eth.getAccounts we can get a collection of accounts that the node controls. Since our node is a test one, these are all dummy accounts.

web3.eth.getAccounts().then(accounts => {
  accounts.forEach(account => {

Transfer Money between Accounts

Now that we have some accounts, let’s transfer some money between them.

var allAccounts;
web3.eth.getAccounts().then(accounts => {
  allAccounts = accounts;
  Voting.deploy({data: bytecode}).send({
    from: accounts[0],
    gas: 1500000,
    gasPrice: '30000000000000'
  }).on('receipt', receipt => {
    Voting.options.address = receipt.contractAddress;
    Voting.methods.transfer(accounts[1], 10).send({from: accounts[0]}).then(transaction => {
      console.log("Transfer lodged. Transaction ID: " + transaction.transactionHash);
      let blockHash = transaction.blockHash
      return web3.eth.getBlock(blockHash, true);
    }).then(block => {
      block.transactions.forEach(transaction => {

      allAccounts.forEach(account => {
          Voting.methods.balances(account).call({from: allAccounts[0]}).then(amount => {
            console.log(account + ": " + amount);

Let’s run it:

Transfer lodged. Transaction ID: 0x699cbe40121d6c2da7b36a107cd5f28b35a71aff2a0d584f8e734b10f4c49de4

{ name: 'transfer',
   [ { name: '_to',
       value: '0xeb25dbd0931386eeab267981626ae3908d598404',
       type: 'address' },
     { name: '_amount', value: '10', type: 'uint256' } ] }

0x084181d6fDe8bA802Ee85396aB1d25Ddf1d7D061: 999990
0xEb25dbD0931386eEaB267981626AE3908D598404: 10
0x7deB2487E6Ac40f85fB8f5A3bC6896391bf2570F: 0
0xA15ad4371B62afECE5a7A70457F82A30530630a3: 0
0x64644f3B6B95e81A385c8114DF81663C39084C6a: 0
0xBB68FF2935080c807D5A534b1fc481Aa3fafF1C0: 0
0x38d4A3d635B451Cb006d63ce542950C067D47F58: 0
0x7878bA9138361A08522418BD1c8376Af7220a506: 0
0xf400c0e749Fe02E7073E08d713E0A207dc91FBeb: 0
0x7070d1712a25eb7FCf78A549F17705AA66B0aD47: 0

This code:

  • Deploys our smart contract to the blockchain.
  • Transfers £10 from account 1 to account 2.
  • Decodes that transaction and shows the output.
  • Shows the balances of all the dummy accounts.

The full example is available in my ethereum-nursery GitHub repository. Thomas also has a follow-up post that shows how to deploy a contract on a remote node where client-side signatures become necessary.

blockchain development, ethereum, node.js, security, smart contracts

Published at DZone with permission of Mark Needham , DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}