Setting Up A TomoChain

BLOCKCHAIN 101:
Session 2 of 5: Setting Up a
Development Environment
1. Recap
2. General Requirements
3. Building a Development Environment
4. Smart Contract Workflow
5. Installing a Simple Web3 Frontend with Web2Py
6. Building a Blockchain Certification System
Developed by Certified by
Introduction to Blockchain & Tomochain

Recap
● Blockchain is a series of distributed, immutable, and public records.
● Ethereum is interesting because we can store and execute

programs (‘smart contracts’) on a blockchain.
● TomoChain is exciting for developers because we can do that faster

and cheaper, opening up new applications.
● Solidity is the language used to write these applications -- while

similar to C it has some unique quirks and challenges.

General Requirements
1. Create a TOMO wallet by installing the App, selecting advanced, and changing the network to
TestNet
2. If running Windows enable Windows subsystem for Linux and install from Windows Store.
○ Developing natively in Windows is possible, but the Linux command line is more powerful,
better documented, and easier to use.
○ 3 easy ways to install
3. Install Truffle
○ Truffle is a tool to compile and deploy smart contracts. It is flexible enough to deploy to
blockchains other than Ethereum (such as TomoChain)
○ As with most powerful software tools, it has no graphical user interface.
4. Install Truffle-HDWallet-provider
○ This tool lets us configure our connection to TomoChain and sign transactions
5. Update NodeJS
○ NodeJS is required by Truffle. Having the wrong version causes strange bugs
6. Configure to use Tomochain instead of ethereum
○ Define the method to connect to Tomo TestNet and MainNet, including our mnemonic or
private keys
Installing Linux on Windows 10
How to Instal Linux on Windows 10:
● Install Linux using Microsoft

Store
● You can install your preferred
Linux Distribution

Setting Up and Using Linux
If running MacOS, an older version of
Windows, or another operating
system, VirtualBox can be used to run
Linux inside your operating system
like a program.
In MacOs you can install the required

tools natively with HomeBrew.

Faster Alternative Install
Sign up for a free tier Google Compute instance running Debian or Ubuntu Linux. You can sign in
with a web browser.
This has sufficient computing power for our purposes, costs nothing, and saves your work in the
cloud too. All you need is an internet connection -- this is the fastest way to get started.. We start by
logging in and increasing our swap size since the free server is small (check with free -m):
sudo fallocate -l 1G /swapfile //create a 1GB swapfile
sudo chmod 600 /swapfile //make accessible only to root
sudo mkswap /swapfile //mark the file to be used as swap space
sudo swapon /swapfile //Activate the swap
echo "/swapfile none swap sw 0 0" | sudo tee -a /etc/fstab //Optional: make ths persistent

Creating a TomoChain TestNet Wallet
● Download the app on play store
● Create a new wallet save your

mnemonic. Press the menu button,
select advanced, and change your
network to Testnet.
● You can get more TestNet TOMO here if

needed:
https://faucet.testnet.tomochain.com/
(or there’s a button in the app)

Installing and Updating NodeJS
Run the following command
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
Logout and back in (or reboot), then nvm install node
npm install -g npm@latest
node -v
npm - v

Installing Truffle and hd_wallet
Run the following command:
npm install -g truffle
npm install truffle-hdwallet-provider
Enter your home directory, create a folder for your project, and enter it
cd ~
mkdir testingtomo && cd testingtomo
truffle init
Note the new directories as well as truffle-config.js

Configuring for TomoChain
Replace the content of truffle-config.js as
specified here:
● https://medium.com/tomochain/how-to-
build-a-dapp-on-tomochain-85532a1192e
7
Remember to enter the mnemonic phrase we

saved earlier.
Now Truffle is configured to connect to

Tomochain and we can deploy smart
contracts.

General Workflow
Write your smart contract out in Remix:
https://remix.ethereum.org/
When it compiles without errors, copy it to a .sol file

under /project/contracts
In /project, run truffle compile
Enter /project/migrations and create a file

2_deploy_contracts.js containing:
var Contractname = artifacts.require("Contractname");

module.exports = function(deployer) {
deployer.deploy(Contractname);
};

General Workflow (con’t)
Now we deploy to Testnet , and keep the destination contract address. Be sure you have enough TOMO to
do this!
run truffle deploy --network tomotestnet
Congratulations, you have a smart contract on the Testnet.
Finally, get the ABI from /build/contracts/name.json -- be sure just to get the section in and including [ ]
brackets. Any web application you write will need this to interact with your smart contract.

Simple Web3 Frontends
Web3 is a tool that lets your web server interact with a blockchain.
● Web applications can then use that data to ‘do something useful’ for our users.
Web2Py is a simple Python framework that we can use to build simple web applications. More advanced
options include Flask (Python), Node.js, React.js, and Angular.js
● Web3 is available as a library for both JavaScript and Python. The Javascript library is probably more
popular, but the Python language itself is more popular -- we’ll use Python today since it’s easier to
read.
● Both libraries work the same way in any case.

Installing Python3 and Web3
First, we need a HTTPS certificate. If you are running locally you don’t need this, but otherwise HTTPS is
forced on an admin login we’ll need later:
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt
Remember where you put server.key and server.crt!

Installing Python3 and Web3
Now we need a python3 environment:
sudo apt-get install build-essential autoconf libtool pkg-config python-opengl python-imaging python-pyrex
python-pyside.qtopengl idle-python2.7 qt4-dev-tools qt4-designer libqtgui4 libqtcore4 libqt4-xml libqt4-test libqt4-script
libqt4-network libqt4-dbus python-qt4 python-qt4-gl libgle3 python-dev
sudo apt-get install python3-setuptools
sudo easy_install3 pip
sudo apt-get install python3-dev
sudo pip3 install web3

Installing web2py
Get the source code:
wget https://mdipierro.pythonanywhere.com/examples/static/web2py_src.zip
sudo apt-get install unzip && unzip web2py_src.zip
Make sure port 8000 is open to tcp under network-->VPC Network-->Firewall rules
Finally:
python3 web2py.py -a 'password' -c server.crt -k server.key -i 0.0.0.0 -p 8000
Now we navigate to https://<ip address>:8000

A Crash Course in Web2Py
Our focus is mainly on smart contracts, but a short lesson on Web frontend basics will be useful in
understanding how smart contracts interact with websites.
Web2Py and many web application frameworks work on the model-controller-view system.
Model: Defines how the data is handled and stored
Controller: Defines how data is processed
View: Defines how the data from the model is displayed
Today we will write a small application that interacts with a smart contract that issues educational
certification on TomoChain. We’ll worry about the smart contract itself tomorrow -- for now let's just worry
about sending and receiving data from the blockchain.

A Simple Model: db.py
In our Model, we import a few modules we need and define our database structure:
from gluon.contrib.appconfig import AppConfig

from gluon.tools import Auth
import hashlib
import web3
import binascii
from gluon.tools import Service
service = Service()
db.define_table('students',Field('address', type='string', length=255, default=None,

required=True, notnull=False, unique=False),
Field('Name', type='string', length=255, default=None,
required=True, notnull=False, unique=False),
Field('gradelist', type='string', length=500, default=None,
required=False, notnull=False, unique=False))
links = [lambda row: A('Certify',_href=URL("call/run/tsend",args=[row.address, row.Name, row.gradelist]))]

Control: default.py
First, some setup:
from web3 import Web3, HTTPProvider, IPCProvider, WebsocketProvider

import time
import datetime
import json
with open('/home/sean/web2py/web2py/applications/Certify/controllers/Certify.json') as f:
abi = json.load(f)
w3 = Web3(HTTPProvider('https://testnet.tomochain.com'))
contract_address = '0x0B2B9FB74aD129f0D296AC72CE43166caA044383'
contract = w3.eth.contract(address = contract_address, abi = abi)

Control: Building a Transaction
Next we define a function to store exam results on Tomochain. It stores the Tomo address, name, and grades
of students. We start with some definitions, then we build a transaction that contains the data.
setStudent is a specific function of the smart contract -- we’ll see how that works tomorrow.
def store_results(address, Name, gradelist):

wallet_private_key = '4a27b6c6401357e426a21a09d6d9e989a6d633e38142811d85da8e6b21590fa2'
wallet_address = '0x29aF7320c45953014FB4445c28beEFb40E0899a3'
wallet_address = Web3.toChecksumAddress(wallet_address)
nonce = w3.eth.getTransactionCount(wallet_address)
txn_dict = contract.functions.setStudent(address, Name, gradelist).buildTransaction({

'chainId': 89,
'gas': 140000,
'gasPrice': w3.toWei('40', 'gwei'),
'nonce': nonce,
})

Control: Signing and Sending
Once the transaction that does what we want is created, we execute it by signing and sending it. The smart
contract in question will only add student data if it is signed by the contract owner.
signed_txn = w3.eth.account.signTransaction(txn_dict, private_key=wallet_private_key)
result = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
tx_receipt = w3.eth.getTransactionReceipt(result)
count = 0
while tx_receipt is None and (count < 30):

time.sleep(10)
tx_receipt = w3.eth.getTransactionReceipt(result)
return(tx_receipt)
if tx_receipt is None:
tx_receipt = "Failed"
return(tx_receipt)

Control: Checking Certification
This one is easier -- our smart contract in question has a function that returns student if you provide the
Tomo address:
def check_certification(address):
tx_receipt = contract.functions.getStudent(address).call()
return(tx_receipt)

A Note on Services
If we call these functions with services, we’ll have an easier time testing them in a minute!
@service.run
def tsend(address,Name,gradelist):
address = str(address)
Name = str(Name)
tx_receipt = store_results(address, Name, gradelist)
return tx_receipt
def call():
session.forget()
return service()
@service.run
def tcheck(address):
address = str(address)
tx_receipt = check_certification(address)
return tx_receipt
def call():
session.forget()
return service()

Control: Organizing Data
Web2Py provides a tool called a ‘Smartgrid’. It will automatically provide a user interface where we can create, read, update, and
delete data (CRUD):
def index():
response.view = 'generic.html' # use a generic view
grid = SQLFORM.smartgrid(db.students, deletable=True, editable=True, user_signature=False, links=links)
return dict(grid=grid)
Pay careful attention to user_signature=False -- this disables all login-based access control to the database.
Probably you won’t want that behavior for a live application :)

Let's Give it a Try
● Remember -- code is 100x more likely to fail in front of a live audience!
● Remember, at the end of the class tomorrow there will be a short quiz!
● Also: We’ll airdrop you some Tomo if you attend our hackathon April 20-21st

Join Our Upcoming Events
April 6-7, 2019:

Tomochain Dapp Development Workshop
April 20-21, 2019:

Tomochain Hackathon 2019
Developed by Certified by

Setting Up A TomoChain

Uploaded by

Copyright:

Available Formats

Setting Up A TomoChain

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Setting Up A TomoChain

Uploaded by

Copyright:

Available Formats

BLOCKCHAIN 101:

Introduction to Blockchain & Tomochain

● Ethereum is interesting because we can store and execute

● TomoChain is exciting for developers because we can do that faster

● Solidity is the language used to write these applications -- while

Introduction to Blockchain & Tomochain

● Install Linux using Microsoft

Introduction to Blockchain & Tomochain

In MacOs you can install the required

Introduction to Blockchain & Tomochain

sudo fallocate -l 1G /swapfile //create a 1GB swapfile

sudo chmod 600 /swapfile //make accessible only to root

sudo mkswap /swapfile //mark the file to be used as swap space

sudo swapon /swapfile //Activate the swap

Introduction to Blockchain & Tomochain

● Create a new wallet save your

● You can get more TestNet TOMO here if

(or there’s a button in the app)

Introduction to Blockchain & Tomochain

Run the following command

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash

Logout and back in (or reboot), then nvm install node

npm install -g npm@latest

Introduction to Blockchain & Tomochain

Run the following command:

npm install -g truffle

npm install truffle-hdwallet-provider

mkdir testingtomo && cd testingtomo

Note the new directories as well as truffle-config.js

Introduction to Blockchain & Tomochain

Remember to enter the mnemonic phrase we

Now Truffle is configured to connect to

Introduction to Blockchain & Tomochain

When it compiles without errors, copy it to a .sol file

In /project, run truffle compile

Enter /project/migrations and create a file

var Contractname = artifacts.require("Contractname");

Introduction to Blockchain & Tomochain

run truffle deploy --network tomotestnet

Congratulations, you have a smart contract on the Testnet.

Introduction to Blockchain & Tomochain

Introduction to Blockchain & Tomochain

openssl genrsa -out server.key 2048

openssl req -new -key server.key -out server.csr

Remember where you put server.key and server.crt!

Introduction to Blockchain & Tomochain

sudo apt-get install python3-setuptools

sudo easy_install3 pip

sudo apt-get install python3-dev

sudo pip3 install web3

Introduction to Blockchain & Tomochain

sudo apt-get install unzip && unzip web2py_src.zip

python3 web2py.py -a 'password' -c server.crt -k server.key -i 0.0.0.0 -p 8000

Now we navigate to https://<ip address>:8000

Introduction to Blockchain & Tomochain

Model: Defines how the data is handled and stored

Controller: Defines how data is processed

View: Defines how the data from the model is displayed