Solidity Simple Tutorial EN

ethereum
smart contract
林修平

online compiler
• online compiler :
https://ethereum.github.io/browser-solidity/

MANUAL COMPILE(using geth)
• connect to console
• set up a chain
• connect to main chain：go-ethereum/build/bin/geth console
• connect to testnet：go-ethereum/build/bin/geth --testnet console
• build a private net：go-ethereum/build/bin/geth --datadir “your_directory"
--rpc --rpcport port --rpccorsdomain "*" --port "30303" --nodiscover --
ipcapi "admin,db,eth,debug,miner,net,shh,txpool,personal,web3" --rpcapi
"db,eth,net,web3" --autodag --networkid number --nat "any" console

MANUAL COMPILE(using geth)
• in console
• var contractABI = web3.eth.contract([{contractABI}]);
• var contract123 = contractABI.new(
parameters,
{from: address,
data: bytecode,
gas: gas
}, callback_function)

• price unit：ether
• address：you can withdraw from or save ether to it.
• it can represent an user account
• no code
• or represent a contract
• tied with a code
• NOTE: same code on different address is different contract
• transaction：
• send ether
• or to execute function in a contract
• or both
Quick Intro

• contract: comprised of state and function
• state: used by user to keep information regarding the contract
• function: change state of a contract
• NOTE: Ethereum discourage users from using state to preserve information, so it cost a lot of gas to either
create or change the state.
• WHY? Since every node(miner) needs to keep a full copy of the blockchain, they have to be compensated
for storage cost of every contract.
• gas
• every function comprised of many operations and there’s a price to every type of operation
• there’s a fixed amount of gas cost to function you design and you have to pay for it when you want to execute a
function
• you can decide how much ether you want to pay per gas and that becomes transaction fee needed for this
execution
Quick Intro

• If you are on a public chain, every storage cost matters.
• But what if you are on a private chain?
• you can have ether as many as you want so you don’t need to
worry about transaction fee
• but does it mean that you can use as many storage as you want?
• YES! but still, the costs of storing these states are to be
taken by all nodes in your private chain
Quick Intro

• state
• function：operate on states
• design logic：use functions
to make your contract work
How it work

How it work
contract Count123{
uint counts(0);
function incre(){
counts = count + 1;
}
}
Transaction(Deploy)

How it work
contract Count123{
uint counts(0);
function incre(){
counts = count + 1;
}
}

How it work
Transaction(Invoke)
Count123.incre()
contract Count123{
uint counts(0);
function incre(){
counts = count + 1;
}
}

let’s take slock.it for example and write a simple bike renting contract!
slock.it
How it work

state declaration
contract bikeRenting {
address public owner;
address public currentRenter;
uint public expireTime;
…
}

• type , visibility , variable_name
state declaration
…
}

• type , visibility , variable_name
• type : bool, int, uint, address, mapping, bytes, string, struct
• visibility : public or private(default)
• public: accessible externally
(declare in your contract) uint public totalCount = 3;
(access in a console) mycontract.totalCount(); //3
(access from other contract) thatcontract.totalCount() //3
• variable_name
state declaration

• Array in solidity :
• address[] owners; address[3] threeOwners;
• push item into array: owners.push(address)
• delete item: delete owners[2]
• pitfall: only changes the value of specified item to zero
instead of erase the item
state declaration

• mapping :
• mapping(typeA => typeB) variable_name;
• example
• declare a mapping:
• mapping(address => uint) deposits;
• map address 0x123456789abcdef to integer 10:
• deposits[0x123456789abcdef] = 10;
• uninitialized or undeclared values are zero instead of NULL
• NOTE: there’s no NULL in Solidity
state declaration

• Units and Globally available variables
• Ether unit：ether、finney、wei
• time unit：seconds、weeks、years、now
• now: present time
• more specifically, the time when this block is mined, i.e,
the time_stamp parameter in the block header
state declaration

• Special variables and functions
• msg: information regarding this transaction
• msg.sender: address who send the transaction
• msg.value: value sent with the transaction
• address related functions
• address.balance
• address.send(amount)：send ether to address
state declaration

• Special variables and functions
• throw
• reverts all changes made so far by the underlying transaction
• confiscate all gas provided by underlying transaction
state declaration

initialization
uint public unitPrice;
function bikeRenting(uint _unitPrice){
owner = msg.sender;
currentRenter = 0x0;
expireTime = now;
unitPrice = _unitPrice;
}
}

• constructor function
• it’s name is exactly the same as contract’s
• executed when the contract is been deployed to blockchain
• executed only once
• not necessary
initialization

function functionName(parameter1, parameter2, …) returns(type) {
…
}
• declare parameters: bool a, uint b, address c, …
• returns:
• not necessary
• function foo() returns(uint, address, bool) {
…
return (1, 0x0, true);
}
function

• visibility of a function
• public(default)
• private: only accessible by this contract
• internal: only accessible by this contract and contracts inherited from this one
• external: exactly the opposite of internal
• payable:
• decide if people can send ether while they execute this function, in other words, if you
create a transaction to execute this function, you will be able to send the transaction
along with some ether only if this function is a payable function
function

function
• we have to make sure person who executes isInUse function has the priority to
rent if the bike is available because he/she pays transaction fee to execute this
function
• why we need someone else to check if the bike is been rented or not?
• because a smart contract is not a robot, it won’t execute a command actively
• it won’t lock the bike itself even time is up, it needs to be triggered
• but if there are more than two people execute the same function in the
same time, there’s no guarantee on the order of the execution
• so we have to make sure person who gets to execute isInUse
function first will have the priority to rent the bike because he/she
pays for this execution

function bikeRenting(uint _unitPrice){…}
function rent() payable returns(bool){…}
function isInUse(bool ifWantToRent) payable returns(bool){…}
function collectMoney() {
if( msg.sender == owner){
owner.send(this.balance) ;
}
}
}
make sure only owner can
execute this function
function

privilege
• there’s no built-in mechanism to restrict execution privilege, you have to check if person
who executes the function has the right to
• HOW?
• using msg.sender to compare with addresses which have the right to execute
function collectMoney() {
if(msg.sender == owner){
…
}
}

• modifier
• attach to modifier: function bar() foo1() {…}
• attach to multiple modifiers: function bar() foo1() foo2() foo3(){…}
repetitive actions
modifier foo1 {
do_something
_;
or_do_something_here
}

contract foo1 {
…
modifier ownerCheck { if(msg.sender == owner ) _;}
function collectMoney() ownerCheck {
owner.send(this.balance) ;
}
…
}
repetitive actions

contract modifierTest{
modifier foo1(){
foo1before;
_;
foo1after;
}
modifier foo2(){
foo2before;
_;
foo2after;
}
function bar() foo1() foo2() {
bar;
}
}
repetitive actions
execution order:
foo1before
foo2before
bar
foo2after
foo1after

contract creation in a contract

contract creation in a contract
contract foo{ … }
address newFooAddr = new foo();
• returns an address
foo foo1 = foo(newFooAddr);
• returns a contract
• NOTE: contract creation usually cost a lot of gas so remember to
supply enough gas if you execute a function which creates new
contracts

fallback function
• it’s executed only when someone executes a function not existed in the contract or
someone simply sends some ether to this contract
• not necessary
• pitfall:
• person who owns this contract gets to decide what to do in a fallback function
• if you simply sends some ether to this contract, you also have to pay for the
execution of fallback function if there is one
function () {
…
}

pitfalls
• throw when address.send() fails
• throw will revert all changes and confiscate all gas even if you are
halfway there
for(uint i=0; i<investorsCount; i++) {
if( inverstors[i].send(100) == false )
throw;
}

pitfalls
• why address.send() fail?
• 1. out of gas
• supply enough gas
• 2. callstack
• 1024 layer

pitfalls
• mitigation: use a withdraw pattern
• still, this solution leaves the problems mentioned to the msg
sender
function withdraw(amount) {
if( balances[msg.sender] >= amount ) {
msg.sender.send(amount);
balances[msg.sender] -= amount;
}
}

pitfalls
• shared state between external call and external callable functions
function extCall() {
…
external_call();
…
if(shared_state) {
…
}
…
}
function extCallable(){
do_something_on_shared_state…
}

pitfalls
• state corruption
• 1. sum of sizes of 1st and 2nd state variables are less than 256
bytes
• 2. first variable is not a signed interger or bytesXX type
function extCall() {
uint32 a;
uint32 b;
function run() returns(uint32){
a--;
return b;
}
}
fixed after compiler version 0.4.4

Misc
• selfdestruct(recipient)
• terminate the contract, destroy code and storage, then transfer the remaining ether to
recipient
• event: writes data into transaction receipt
• example: event paymentRecord(address indexed buyer, uint value)
• indexed: write data into topics field
• if data is more than 32 bytes, hash of data is written into topics instead
• transaction receipt
• data
• topics: can be used as a condition filter

• contract inheritance : contract Final is most-base-like, …, most-derived
{…}
Misc

tips
• use delete on array to delete all elements
• --vmdebug, --verbosity
• --targetgaslimit

Solidity Simple Tutorial EN

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Solidity Simple Tutorial EN (20)

Recently uploaded (20)

Solidity Simple Tutorial EN