Ethereum : Decentralized Application Design & Development

Lecture provides an overview of the Ethereum Decentralized applications. At the end of this lecture student should be able to:

1. Describe the working of DAPP
2. Explain the architecture & technical components of DAPP

Students will learn about the:

• Ethers which is the value token on Ethereum; how do they get created?
• What an EVM is
• Gas
• How the transaction fee is processed

There are multiple types of Ethereum networks. In this lecture student will learn about the different types of Ethereum networks. When working on DAPPs the developer will need access to the block and transaction information. This lecture will cover the webapps for exploring the Blockchain networks.

Consensus refers to a process that secures the Blockchain network and validates the transaction. There are multiple consensus models but the two common ones are 

• Hashing functions
• Proof of Work
• Proof of Stake

Students will learn about these two common consensus model in this lecture.

In this lecture students will learn about a recently added consensus model....Proof of Authority | Ethereum Clique Protocol.

Students will learn:

1. How to setup the Ethereum Wallet
2. Internal working of the wallet
3. Light Client SYNChronization

Many students are interested in knowing "What they need to do in order to mine for ethers?". This lecture will provide the answer to the question.

In this lecture students will learn about faucets.

In this lecture students will learn:

1. How to mine for ethers using a wallet
2. How to send ethers to other accounts

Provides a walkthrough for the installation of the Ethereum Wallet on Mac

There are different types of accounts. This lectures describes these account types along with demo of how these accounts are used from the wallet.

Students will learn how an ethereum wallet can be used for:

• Deploying custom contracts
• Watch contracts deployed outside the wallet

This is an exercise that student must try out on their own.

Meta Mask is a chrome plugin that turns a browser into a Decentralized App container. Students will learn about its capabilities and see it in action.

There are many wallets available online. This lecture covers the official online wallet.

This lecture demonstrates the use of an online tool that can be used for developing smart contract code.

Exercise to reinforce the concepts covered

Ethereum client software is used for participating in the Ethereum network. In this leacture students will learn about how the client works.

Geth is the "Go Ethereum" client.

• Lecture demonstrates the installation of the Ethereum client: Geth
• Provides as an overview of the various commands & options

Students will learn:

• Commands for getting information from the client (help, license, version)
• How to setup Geth client for connecting to the testnet
• Different synchronization modes for the Geth client 

Geth uses TOML formatted files to manage configurations. In this lecture students will learn how to use TOML files for managing client configurations.

Lecture covers the 

• High level overview of the API available for geth
• Covers the protocols used for communicating with geth (IPC/RPC & Websockets)

Lecture shows how the console/attach commands can be used for connecting to a running geth client. Geth allows execution of Javascripts, in this lecture student will learn about this feature as well.

Lecture covers the commands/options for 

• Accounts management
• Mining

In this lecture students will learn how to create a Private Dev Network

> geth --dev

Students will learn about the following options:

--maxpeers

--port

--nodiscover

--bootnodes

Ethereum client exposes API for invoking actions & for inquiring the network. This lecture provides an overview of:

• Management API
• web3 API

The Ethereum clients expose an admin object on which API can be invoked for controlling the behavior of the node or client.

Lecture shows how the personal object exposed by the Ethereum client is used.

The miner API provide control over the mining operations. Students will learn these commands and see the mining operation in action.

This lecture covers the :

• Concept of transaction pools & nonces
• Demo of txpool object's use

The debug object is available for getting visibility into the Ethereum client implementation. This lecture discusses the information that can be accessed using the debug object.

Talks about the sample application developed in this section.

There are multiple libraries available for connecting front end applications to the Ethereum network. In this lecture students will get an overview of the web3 API

In this section a full blown single page application will be developed to connect with the Geth node. 

This lecture will show the students how to setup a sample application development environment.

Describes the decentrallzed application that will be incrementally developed through the lectures in this section.

This lecture describes the sample application components. It also shows how the front end connects to the Geth node using the web3 JS

Talks about the web3 API that can be used for getting the version information for the node and the runtime status of the node to which the app is connected.

Student is advised to code the suggested API in the application. This would help them get up to speed on web3 API coding.

In this lecture students will learn how to use the web3 Account APIs. The sample app will be expanded to show the accounts setup on the Geth.

The sample app will be expanded to:

• Lock/UnLock accounts
• Send ethers to different accounts
• Get the balances of the accounts

Two objectives for this lecture:

• Setup the Solidity compiler on local machines
• Setup Geth to use the compiler

Lectures covers

• Contract deployment process
• Web3 API for deployment of contract

The front end of the decentralized application invokes the function on the deployed contracts. You can invoke the functions using call of send API. This lectures describes the difference.

Ethereum has a built in logging and event functionality. Decentralized applications can use the logging and events for creating rich UI applications. This lecture provides an overview of the patterns that are implemented by applications around events/logs.

Lecture covers the API for:

• Watching for events
• Getting event data from logs

In this lecture students will learn how end-to-end events work i.e., when an event is emitted by contract instance how it is received by the front end.

• Indexed attributes
• Filtering on topics

Coding exercise for creating a DAPP

This lectures talks about how developers can become productive by leveraging Ethereum simulators. Students will learn about Ganache the Ethereum simulator which is part of the Truffle framework v4.x

Lecture walks through the steps for the installation of:

• Visual studio code (VSC)
• Solidity extension for the VSC
• Truffle framework

Truffle framework uses Mocha & Chai to support the Test Driven Development (TDD) practices. This is a crash course on Mocha and Chai. 

PS: Students who are new to Mocha/Chai MUST use additional resources to understand these NPM packages as the lecture is just scratching the surface.

Truffle v4.x has introduced the concept of Boxes. Boxes are sample applications | Boiler-plate-code that developers can use as a starting point for creating their own custom application(s). This lecture will show students how to leverage the Truffle boxes for building their own applications.

This lecture will provide the student an overview of the contract development using the Truffle framework. Primarily at the end of this lecture student should be able to create a project using the Truffle CLI commands.

In this lecture student will learn about the practices for developing smart contracts & use of Truffle for creating contracts/test cases etc.

This lecture talks about the

• Deployment process for contracts
• Describes the configuration for migrations/deployments
• Walkthrough of the truffle commands used for deployment

Exercise - Students are encouraged to code the contract and test cases on their own. This will require them to review the code in Calculator.js

At the end of these exercises students are expected to have the *minimal* knowledge that is needed before the student proceeds with the lectures on Solidity in the next section.

Describes the structure and layout of the contract at a high level.

Student will learn about the:

• Value types in Solidity
• Variable initialization (checking for nulls)
• How conversion is handled between different data types

EVM manages the data in memory divided into multiple regions. This lecture explain the regions and the keywords used for managing the storage location of the data elements

This lectures covers the Solidity arrays

• Static versus Dynamic arrays
• Storage versus Memory arrays

Coding exercise

Students will learn about 3 new data types:

• byte
• bytes & string referred to as special arrays

Although both bytes & string type are byte arrays there are some difference between the two. Those differences are also covered in this lecture.

In this lecture students will learn about how to declare and use Solidity functions.

Coding exercise

Lecturer discusses

• The global variables and objects available in the EVM contract
• Throwing exception using the throw keyword

Lecturers discusses the:

• Recent hacking attacks & why hackers were successful
• Best practices to avoid contract vulnerabilities
• view and pure modifiers

Errors are handled by throwing exceptions using the global functions

• revert()
• require()
• assert()

Solidity exposes multiple hashing functions. Students will learn about:

• Hashing
• Global hash functions

Students will learn how to create and use complex types:

1. mapping
2. enum
3. struct

Coding exercise

In this lecture students will learn how Solidity supports Object Orientation concepts:

• Overloading
• Inheritance, Abstract contracts, Interfaces
• Polymorphism

In this lecture students will learn how to use the following keywords to control the visibility of the functions and storage variables:

• private & public
• internal & external

Students will also learn about the keyword this and function type variables.

Student will learn how to declare and generate events from the contract.

Behavior of the functions may be changed using the function modifiers. In this lecture students will learn how to use function modifiers.

Function modifiers

This lecture will show the student how to declare the events and generate events in the contract code.

Coding exercise

This is where rubber hits the road :-)

Contracts can self destroy. This self-destruction need is sometime driven by business. This lecture will cover:

• Lifecycle of a contract
• Why, How, Implications of self destruction

This lecture describes how Decentralized applications can use the factory contract instance to create other contracts.

Complex Decentralized apps may have dependency on multiple contracts. The Name Registry pattern simplifies the dependency management. In this lecture student will learn about the benefits of using this pattern and see an implementation of this pattern in action.

This pattern can be seen in action here:

http://thedapps.com/DAPP-Registry/

Solidity mapping does not allow the access to all keys contained in the mapping as a result there is no out of the box feature to iterate over the values contained in the mapping. This lecture discusses how to implement iterator functionality for mapping.

The UserAddressRegistry is not optimized. Student will help the instructor to optimize the code :-)

Withdrawal pattern is used for safely sending ethers from the contract code.

This article describes the project that students will be developing as part of the project.

Open Blockchain project - Intent is to let the student decide on the scope, design & implementation

In this lecture students will learn how to setup a 2 node private blockchain on their local machine.

In this lecture students will learn about the Bootnode tool. At the end of this lectures students should be able to design a private Blockchain network with Bootnode based peer discovery mechanism.

In this lectures students will learn:

• About Puppeth tool
• How Puppeth is used for setting up genesis
• Steps for setting up a PoA Private Network

This lecture will show the testing of the Clieque network that was setup in the previous lecture

Recently ERC20 specifications has been adopted as a standard way for implementing tokens. This lectures will teach students on how they can implement an ERC20 compliant token.

Students will see the design/code for implementing a simple token. The code demonstrated in the lecture is available in the GitHub, so students after going through the lecture will be able to make changes to the code to create their own ERC20 token that they can then deploy on the Ethereum network.

Students will see the design/code for implementing a simple token. The code demonstrated in the lecture is available in the GitHub, so students after going through the lecture will be able to make changes to the code to create their own ERC20 token that they can then deploy on the Ethereum network.