Ethereum Developers
Community
Smart Contract Tutorial
Arnold Pham
Cofounder of Lunyr
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/)
High level view of web app client server architecture
High level view of Ethereum Dapp Architecture
Yikes! Downloading the whole blockchain?
EVM - Database and Code
Built in financial system
Solidity
Useful Tools - Opportunities for contribution
ethereumjs-testrpc
• Node.js based Ethereum client for testing and development
• Simulates full client behavior
• https://github.com/ethereumjs/testrpc
dapple
• developer multitool for managing the growing complexity of interconnected smart contract
systems
• https://github.com/nexusdev/dapple
truffle
• A development environment, testing framework and asset pipeline for Ethereum
Browser-Solidity
Shows errors
Creating Contracts
What is the ABI?
Application Binary Interface
Deploying a Contract with Web3
1. Write your contract
2. Make sure you have the Solidity compiler
No Solidity compiler? Proceed to next step
Download https://github.com/ethereum/solidity/releases
3. Compile your contract with web3.eth.compile.solidity(source) to get an
object with the contract and compiler info
You need the abiDefinition
Create a contract object which can be used to
instantiate contracts on an address
Deploy the Contract
var contractInstance = MyContract.new([contructorParam1] [, contructorParam2], {data: '0x12345...', from: myAccount,
gas: 1000000});
Make sure to unlock the account first with personal.unlockAccount(eth.accounts[0])
Contract mined!
Check transactionHash
transactionHash: 0x87e42f5a325e13736342ce0d8e505e332b3ee20a5aa0c6f1080c0d5df8a0f1ab
You can also check that the contract was deployed at the address with:
eth.getCode(simplestorage.address)
Contract Address: "0xeb2186b9f667796497f0fc3c824d0bb57a548c25"
1. Write your contract
Retrieving Data from the simplestorage Contract
instance
> simplestorage.get ()
Method calls with sendTransaction
contractInstance.method.sendTransaction([parameter], { from: eth.accounts[0])
Change storedData to 20. simplestorage.get() to
view change
> simplestorage.set.sendTransaction(20, {from: eth.accounts[0]})
Getting other people to interact with your code
Requires the ABI
Then they can instantiate a Javascript object which can be used to call the
contract from any node on the network
var newInstance = eth.contract(ABI).at(Address);
Deploying a Contract with Browser-Solidity
Write the contract in Browser-Solidity
Uses Metamask. Spend Ether to deploy it
Now on blockchain
Etherscan Block Explorer shows the contract
ERC20 Specification
Token Methods:
totalSupply
balanceOf
transfer
transferFrom
approve
allowance
Creating a simple token contract
(Warning: Very simplified Example)
The Token Contract
Steps to deploy the contract
> var tokenSource = 'contract Token{address public owner;mapping(address=>uint)balances;function
Token(){owner=msg.sender;balances[owner]=100;}function transfer(address _to,uint _value)returns(bool
success){if(balances[msg.sender]<_value){return false;}balances[msg.sender]-=_value;balances[_to]+=_value;return
true;}function getBalance(address _user)constant returns(uint _balance){return balances[_user];}}'
> var tokenCompiled = web3.eth.compile.solidity(tokenSource)
> var tokenContract = web3.eth.contract(tokenCompiled.Token.info.abiDefinition)
Create new instance
Check the owner
GetBalance
Transfer tokens to another address
Thank you for watching! Stay tuned for more!

Ethereum Smart Contract Tutorial

Editor's Notes

  • #3 If you are a web developer, you know how a webapp with it’s client server architecture works at a very high level. You have your web application hosted on a hosting provider like AWS, Heroku or a VPS. All the clients interact with this one central application. Clients can be a browser, another api consuming your service etc. When a client makes a request to the server, the server does it’s magic, talks to the database and/or cache, reads/writes/updates the database and serves the client. https://medium.com/@mvmurthy/ethereum-for-web-developers-890be23d1d0c#.l6ucyhvl0
  • #4 If you notice, every client (browser) communicates with it’s own instance of the application. There is no central server to which all clients connect to. This means, every person who wants to interact with a dapp (Decentralized Application) will need a full copy of the blockchain running on their computer/phone etc. That means, before you can use an application, you have to download the entire blockchain and then start using the application. This is currently changing with the continued development of “light” clients which will enable users in low-capacity environments to receive data from the network about parts of the state without downloading the blockchain in its entirety https://medium.com/@mvmurthy/ethereum-for-web-developers-890be23d1d0c#.l6ucyhvl0
  • #5 In reality, you aren’t really using all of your storage and RAM downloading the entire blockchain. There are optimizations and technical advancements within Ethereum improving the efficiency
  • #6 The Ethereum blockchain can be thought of as a world Database and Code base. The Ethereum Virtual Machine (EVM) stores your data, stores the code, and runs the code in the EVM
  • #7 A special capability of Ethereum is it has a built in financial system. You create bank accounts at a fraction of a second. These accounts store a cryptocurrency called Ether which you can send to other accounts on Ethereum
  • #8 The high-level language used in Ethereum for writing contracts. Javascript-like with strong variable types
  • #10 Useful tool
  • #11 Shows errors
  • #13 The contract are stored as bytecode in a binary form into the blockchain under a specific address. The ABI defines the structures and methods that you will use to interact with binary contract (just like the API did), only on a lower level. You can accesses the binary data in the contract through the ABI. In ethereum, the ABI is how you can encode solidity contracts for the EVM and backwards how to read the data out of transactions.
  • #14 Since we’re working inside the geth console, we don’t need to use web3.eth and can just write eth.
  • #15 Compile your contract in Browser-Solidity or use web3.eth.compile.solidity(source)
  • #17 var simpleStorageCompiled = web3.eth.compile.solidity(simpleStorageSource)
  • #19 var simpleStorageContract = web3.eth.contract(simpleStorageCompiled.SimpleStorage.info.abiDefinition) Gets you a contract object
  • #20 Deploy the contract and check if it was mined using the transactionHash
  • #23 Check Transaction Hash on Ropsten Testnet. 2 Block confirmations
  • #25 Compile your contract in Browser-Solidity or use web3.eth.compile.solidity(source)
  • #28 After calling the set method
  • #31 You can see the bytecode of the contract and the ABI. There isn’t anything to interact with in this. Write your code. Then click Create.
  • #32 Metamask will popup and ask you if you’d like to accept or reject the transaction. Ignore the Transaction Error, it’s a current bug with Browser-Solidity and metamask when confirming transactions but everything works fine. You can still compile, create the contract, and run transactions
  • #35 Get the total token supply Get the account balance of another account with address _owner Send _value amount of tokens to address _to Send _value amount of tokens from address _from to address _to Allow _spender to withdraw from your account, multiple times, up to the _value amount. If this function is called again it overwrites the current allowance with _value. Returns the amount which _spender is still allowed to withdraw from _owner