Ethereum Developer Masterclass

Solidity is the most popular programming language for building Ethereum dApps

Solidity compiles to bytecode that runs on the EVM -- Ethereum Virtual Machine

Solidity accepts multiple inheritance

Solidity accepts most of the primitive types except float number

Solidity accepts if/else and for/while statements

ABI (Application Binary Interface) is a JSON file that contains all the information (functions/params/return values) to interact with the smart contract

Smart contracts are immutable -- changes are not possible

An Ethereum Blockhain node implements the Ethereum Protocol and connects to other nodes -- it gives you access to the blockchain

TestRPC library simulates the Ethereum Network and is used to unit test smart contracts since mining is simulated and takes almost no time

MetaMask is a plugin for Chrome, can sign transactions and doesn't download the blockchain -- it's not a full node nor a light client

A transaction, when processed and validated by miners, go to the blockchain. It updates the state and costs ETH (gas)

Calls are local, read-only and free

Transactions cost ETH (gas to miners), it's a write operation, it changes the state of the blockchain

Transactions between Contracts are mined in the same block and returned all together

The Genesis block can be configured in a file named genesis.json or config.json

We can save the MNEMONIC pass phrase given by testrpc to always generate the same accounts: testrpc -m 'MNEMONIC'

Access to the blockchain is a normal REST interface that uses JSON

Web3.js is a JS library that makes it easier to interact with the Ethereum Blockchain

Ethereum Wallet is a dApp in pure HTML/JS that uses Web3.js to manage our accounts

geth is the the command line interface for running a full ethereum node implemented in Go

MIST is a 'browser' that uses Web3.js to interact with geth node

For Linux/MacOs we need to tell MIST where our private geth.ipc file is located

Remix is a web IDE for smart contract development

Truffle is a Smart Contract development framework that makes testing and deployment easy. It uses Mocha and Chai and works with Promises

ERC20 Tokens is a standard pattern for tokens in the Ethereum Network

ERC20 is a set of functions used as interface

An ICO is nothing else than deploying a smart contract

ICO - Initial Coin Offering is usually just a Smart Contract offering tokens

Libraries are reusable contracts, they're not inherited

Truffle works with EthPM which is a Package Manager only for Ethereum, similar to NPM

address.transfer() is preferrable over address.send() since it delegates gas, exceptions and rolls back in case of any issue

You can only throw an exception in Solidity, there's no message and no catch block

assert() and require() are better ways of throwing exceptions

In case of failure, assert() consumes all the gas whereas require() returns all gas

Everything is public on the blockchain, even local and private variables

Random numbers depend on miners, be careful

Be careful with loops since it can consume all the gas available

Maximum call-stack in the Ethereum network is 1024

msg.sender vs tx.origin -- never use tx.origin for authorization to avoid unauthorized access

Restrict the amount of Ether or tokens -- just in case

mappings in Solidity are like hash tables

The value of a mapping can be of any type, except of a mapping

The key of a mapping can be anything except: mapping, dynamic array, contract, enum and struct

mapping(keyType => valueType) name

mapping: all values are initialized by default, it doesn't have a length, it's not possible to retrieve list of values or keys

Struct is like a Java class, but you don't need to use the new keyword to instantiate it

msg.sender is a global variable and its type is 'address'

In order to compare strings, they must be converted to bytes. A commonly used version of equals() is available on the internet

truffle test: uses Mocha, you need to required the contract as a JS object, all calls return promises, transactions don't need to be mined

We can test events in Truffle by getting the tx object that is returned from the method call and asserting that txResult.logs[0].event exits

memory keyword cannot be used at the contract level. Only in methods

Without the memory keyword, Solidity tries to declare variables in storage

You can think of storage as a large array that has a virtual structure you cannot change at runtime - it is determined by the state of variables

There are four formal names for the sub-divisions of ether: the wei, the szabo, the finney, and, of course, the ether

A wei is the most basic unit in the ethereum world. It is worth 10^-18 of an ether. That’s about one god-gillionth of an ether

Truffle is just a contract management tool, we can use any JS framework to work in the frontend

Web3 is the connection between the browser and the blockchain

Instantiating Web3 with our own provider: window.web3 = new Web3(new Web3.providers.HttpProvider('http://localhost:8545'));

Instantiating Web3 with an existing provider e.g. Mist/Metamask: window.web3 = new Web3(web3.currentProvider);

We can 'watch' all events or 'get' a specific one from a contract instance

Rinkeby is an Ethereum Testnet

geth --datadir=./testnet --rinkeby will download the rinkeby testnet

If you want to get some ETH in your account running on Rinkeby TestNet, you can use the faucet on Rinkeby's website

geth --datadir=./testnet --rinkeby --rpc --rcpapi db, eth, net, web3, personal will open the HTTP endpoint on the default port

We must configure the rinkeby connection in truffle.js -- make sure to add the 'from' address and the 'gas' limit

To use Truffle with Rinkeby Testnet we must unlock the account in geth: personal.unlockAccount('0x00')

truffle migrate --network rinkeby: will deploy the smart contracts in the Rinkeby Testnet