Introduction to Ethereum

1. Ethereum Developers Community
Introduction to Ethereum
Arnold Pham
Lunyr Inc.
https://www.linkedin.com/in/arnoldpham/
Unless otherwise stated, these slides are licensed under the Creative Commons Attribution-NonCommercial 3.0 License
(https://creativecommons.org/licenses/by-nc/3.0/us/)

2. Computer

3. State

4. 11/15/2016
07:30:00 PM
11/15/2016
07:30:14 PM
11/15/2016
07:30:28 PM
How it works
14s 14s

5. • σ , the world state of Ethereum
• t , time
• σt+1 , the next world state of Ethereum
• T , a transaction
• σt+1 ≡ Υ(σt, T)
11/15/2016
07:30:14 PM
11/15/2016
07:30:28 PM
14s
Ethereum State Transition Function (Υ)

6. State History is represented by the
blockchain

8. The Ethereum Virtual Machine

9. Ether -> gas

10. Ethereum Clients
•Geth (Go-ethereum, implemented in Go)
•Parity (implemented in Rust)
•Pyethapp (implemented in Python)

11. Ethereum Clients
• By installing and running a client you can
• Mine real ether
• Transfer funds between addresses
• Create contracts and send transactions
• Explore block history
• And more…

12. Account types that exist in the World State
• Externally Owned Account
• Address (160-bit identifier)
• Nonce
• Balance
• Contract Account
• Address (160-bit identifier)
• Nonce
• Balance
• Storage
• Code

13. Account addresses
• The last 20 bytes of a public key
• Steps resulting in an address
• During Account Creation
• A 256-bit Private Key is initialized
• Lots of cryptography-related steps in between
• A Public Key is hashed with SHA-3 to produce a 256-bit output
• The lower 160 bits (20 bytes) become the address

14. Transactions and Messages
• Transactions contain
• Signature identifying sender
• Recipient address
• Ether to send
• Data field (Optional)
• STARTGAS value
• GASPRICE value

16. Contract Accounts

17. Contract Accounts – Potential uses
• Maintain a data store
• Forwarding contract which has access policy and some conditions to send
messages
• Ongoing contract such as escrow, crowdfunding
• Library type contract which provides functions to other contracts

18. Contract Demo

19. Benefits of Ethereum
• Ubiquitous
• Anyone can upload and request programs to be executed
• 100% uptime
• DDOS Resistant
• Persistent permanent data storage

20. Benefits of Ethereum
• Auditable
• Interoperability
• Built-in user authentication
• Built-in direct payment system (no 3rd party required)
• Develop and run decentralized applications without relying on
centralized servers

21. Solidity
• High-level language with JavaScript-like Syntax

22. A Block
• B = (BH + BT + BU)

23. JSON
• JSON – a simple (data interchange or serialization) format that uses
human readable text for transmitting data
{
"id": 1,
"name": "A green door",
"price": 12.50,
"tags": ["home", "green"]
}

24. A little more detail
• If you have some object and you want to store it in a file or send it
over a network or something of that nature, you have to convert it to
a string first, because you can't send objects over a network or write
objects to a file. You can only write strings. And the other end has to
receive that string and reconstitute it into an object before it can
work with it.

25. Remote Procedure Call (RPC)
• Fancy word which generally means calling procedures with
arguments on remote systems
• Remote Procedure Call (RPC) is a protocol that one program can use
to request a service from a program located in another computer on
a network without having to understand the network's details.

26. JSON RPC
• A stateless, light-weight remote procedure call (RPC) protocol
• http://www.jsonrpc.org/specification#conventions
• Defines data structures and rules around their processing
• Example rpc call with positional parameters:
• Client → Request object: {"jsonrpc": "2.0", "method": "subtract", "params":
[42, 23], "id": 1} → Server
• Server→ Response object: {"jsonrpc": "2.0", "result": 19, "id": 1} → Client

27. • Library written to allow developers to focus on developing apps
instead of plumbing to interact with Ethereum clients and ecosystem
• Web3.js (JavaScript)
• Library implementing the JavaScript API for Dapps to conveniently interact with an
Ethereum node

28. Default JSON-RPC endpoints
• Geth: http://localhost:8545

29. Compiler
• Solc
• A standalone solidity compiler
• You only need this if you want to use your Dapp or console to compile solidity
code

30. Test Networks
• Ropsten testnet (--testnet)
• Local private testnet

31. Setting Up a Test Network
$ geth --testnet --nodiscover --maxpeers --
Flags
• --nodiscover (make sure your node is not discoverable by people who do not
manually add you. )
• --maxpeers (the number of peers you want connecting to your private chain. Set
as 0)
• --gasprice (0 Makes contracts affordable)
• --port (The network listening port. 0 for random)
• --datadir (the data directory that your private chain data will be stored in. Should
be different from the public Ethereum chain folder)
• Don’t use the deprecated –genesis flag

32. Setting Up a Test Network
• $get --dev attach
• >personal.newAccount(‘password’)
• miner.start()
• miner.stop()

33. Augur Dapp Demo
• https://app.augur.net/
• git clone https://github.com/AugurProject/augur.git
• cd augur
• npm install
• npm run build
• // build and watch source for changes
• npm run watch
• // run local web server
• npm start
• http://localhost:8080

34. Geth Console
• JavaScript console
• geth attach
• attempts to open the console on a running geth instance
• accepts an endpoint in case the geth node is runnign with a non default
interprocess communication (ipc) endpoint or you would like to connect
over the remote procedure call (rpc) interface
$ geth attach ipc:/some/custom/path
$ geth attach http://191.168.1.1:8545
$ geth attach ws://191.168.1.1:8546

35. Starting geth
• By default, doesn’t start the http and websocket service and not all
functionality is provided over these interfaces due to security
• defaults can be overridden with geth --rpcapi and --wsapi
arguments

36. Managing Accounts with Geth
• It is not possible to access your account without a password
• No forgot my password option
• If you lose your keyfile, and thus your private key, then you lose access to
your account

37. What you can do
• Create new accounts
• List all existing accounts
• Import an private key into a new account
• Migrate to the newest key format
• Change your password

38. Create new accounts
• geth account new
• For non-interactive mode supply the --password flag
• geth account --password <passwordfile> new
•Create an account that uses an existing private key
•geth --datadir /someOtherDataDrive account import ./key.prv
• Create an account from geth console
• personal.newAccount(“password”)

39. List all existing accounts
• geth account list
• For geth console
• eth.accounts

40. Show primary account address
• From geth console
• eth.coinbase

41. Convert a number of Wei into a different
unit
Use web3.fromWei(number, unit) converts a number of wei into a
different unit
• unit must be a string
• unit can be a kwei/ada, mwei/babbage, gwei/channon, szabo,
finney, ether, kether/grand/einstein, mether, gether, tether

42. Checking account balance
• Check the balance (in Wei) of an address
• eth.getBalance(“address”)
• For primary account
• web3.fromWei(eth.getBalance(eth.coinbase), “ether”)
• For a specific address
• web3.fromWei(eth.getBalance(“address”), “ether”)

43. Print all balances with a JavaScript function
Inside of geth console:
function checkAllBalances() {
var i =0;
eth.accounts.forEach( function(e){
console.log(" eth.accounts["+i+"]: " + e + " tbalance: " + web3.fromWei(eth.getBalance(e), "ether") + "
ether");
i++;
})
};

44. Sending Ether
• eth.sendTransaction({from:sender, to:receiver, value:amount})
• you can use built-in JavaScript to set variables to values
• var sender = eth.accounts[0];
• var receiver = eth.accounts[1];
• var amount = web3.toWei(0.01, “ether”)
• the value is in Wei
• you must have your account password to complete the
sendTransaction

45. Mining
• analogous to mining gold or precious metals
• secures the network and verifies computation

46. Proof of Work
• A block is only valid if it contains proof of work of a given difficulty
• the PoW algorithm is called Ethash

47. Ethash
• a modified version of Dagger-Hashimoto which involves finding a
nonce input ot the algorithm so that the result is below a certain
threshold depending on the difficulty
• PoW algorithms rely on the assumption that there’s no better
strategy to find such a nonce than enumerating the possibilties
• Verification of a solution is trivial and cheap

48. Difficulty
• the average time needed to find a nonce depends on the difficulty
threshold
• the difficulty dynamically adjusts so that the network produces a
block every 12 seconds
• the synchronization of system state makes it impossible to maintain
a fork or rewrite history without controlling more than half of the
network mining power

49. Miners
• The expected revenue of a miner is directly proportional to the
miner’s hashrate (the nonces tried per second normalized by the
total hashrate of the network)

50. Ethash DAG (Directed Acyclic Graph)
• The algorithm is memory hard, which makes it ASIC resistant
• Calculating the PoW requires choosing subsets of a fixed resource
(the DAG) dependent on the block header and nonce
• several gigabytes of data
• Totally different every 30,000 blocks
• 100 hour window called an epoch
• takes a while to generate
• Since the DAG only depends on the block number, it can be
pregenerated to avoid long wait times at each epoch transition

51. Ethash DAG
• Geth implements automatic DAG generation by default including
when you use “geth --mine”
• maintains two DAGs at a time for smooth epoch transitions
• Clients share a DAG resource, so if you are running multiple
instances of any client, make sure automatic DAG generation is only
enabled on one client
• to pregenerate a DAG for an arbitrary epoch use
• geth makedag <blocknumber> <outputdir>

52. Mining with geth
• Set your etherbase (or coinbase)
• Before earning ether, you must have your etherbase (or coinbase) address
set
• setting etherbase on the command line
• use the --etherbase option
• geth --etherbase '0xa4d8e9cae4d04b093aac82e6cd355b6b963fb7ff' --mine 2>>
geth.log
• setting etherbase in the console
• use miner.setEtherbase
• miner.setEtherbase('0xa073edbcac4a489c3c0f71ec50dd6ffcefa49a00')

53. Extra Data in Block
• As the one who mined the block , you can add a short vanity tag
• Can only be 32 bytes long
• miner.setExtra(“Arnold was here”)
• Interpreted as unicode

54. Start Mining
• from the command line
• use --mine option
• geth --mine
• from the console
• miner.start()
• miner.stop() to stop
• Check your hashrate
• miner.hashrate

55. Mining information anomaly
• Often you’ll find a block that never makes it to the canonical chain
• Locally it may show that your mined block, and the mining reward
was credited to your account, however, after a while the better
chain is discovered and the network switches to a chain in which
your block is not included and therefore no mining reward is
credited
• A miner monitoring their coinbase balance will find that it
fluctuates quite a bit for this reason

56. Spending your gas
• In order to spend your gas to transact you need to unlock the
account
• personal.unlockAccount(eth.coinbase)

57. Checking a Block Header
• eth.getBlock(blocknumber)

58. Software Development Principles

59. The hardest single part of building a software system is deciding
exactly what to build

60. Behavioral requirements to consider
• Security
• Safety
• Performance
• Timing
• Fault-tolerance
(Bass et al. 2003)

61. Developmental Quality Attributes
• Testability
• Changeability (Major problem in Dapp development)
• Maintainability (Major problem in Dapp development)
• Reusability
(Bass et al. 2003)

62. Develop with multi-versions in mind
• even in cases in which only one system intended, systems
inevitably become multi-version as developers better understand
• what they can do for users
• what they can and cannot do within the constraints of cost and schedule

63. Repair and maintainence problems are costly
• immortal contracts
• cannot change code
• storage expensive