Smart Contracts Development and Projects with Ethereum
5.0 (2 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
46 students enrolled

Smart Contracts Development and Projects with Ethereum

Build Blockchain projects and smart contracts by building decentralized applications using Ethereum
5.0 (2 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
46 students enrolled
Created by Packt Publishing
Last updated 5/2019
English [Auto-generated]
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 10 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Create a simple, functional decentralized application on the Ethereum network
  • Learn fundamental Blockchain programming concepts
  • Understand the Blockchain application development life cycle
  • Develop your ideas fast and efficiently using the Ethereum Blockchain
  • Make writing and deploying smart contracts easy and manageable.
  • Create your own cryptocurrency/token on the Ethereum Blockchain.
  • Build captivating web applications on top of the Ethereum blockchain.
  • Develop, test, and deploy secure smart contracts.
  • Assemble your own smart contract development production environment
  • Understand the allure of building decentralized web applications using Ethereum.
  • Discover the capabilities and potential of Ethereum smart contracts.
  • Some knowledge of Java or JavaScript is required since the examples use a web front-end.
  • Basic knowledge of NPM would be beneficial.

Ethereum is an open-source, public, blockchain-based distributed computing platform and operating system that includes smart contract functionality. It also allows you to build smart & efficient contracts integrating them within applications. Ethereum enables the development of efficient, smart contracts that contain code. These smart contracts can interact with other smart contracts to make decisions, store data, and send Ether to others.

This comprehensive 3-in-1 course is a practical and easy-to-follow guide to building Blockchain currencies, contracts, and applications. To begin with, you’ll learn fundamental Blockchain programming concepts and create a simple, functional decentralized application on the Ethereum network. You’ll work with private data in a Blockchain application as well as handle large files in a Blockchain application. By discovering the capabilities and potential of Ethereum smart contracts, you’ll finally build decentralized, transparent and fraud resistant Ethereum blockchain smart contracts.

Towards the end of this course, you'll build Blockchain, Cryptocurrency, and smart contracts by building decentralized applications using Ethereum.

Contents and Overview

This training program includes 3 complete courses, carefully chosen to give you the most comprehensive training possible.

The first course, Blockchain Application Development in 7 Days, covers building Ethereum DApps Using Smart Contracts for Beginners. Our course will teach you to build an online gaming application using the Ethereum Blockchain. Each 30-minute section will introduce fundamental Blockchain programming concepts as they relate to creating an online game, followed by practical exercises that customers can implement as homework assignments. With this course, you will learn core Blockchain application development skills, creating smart contracts, interacting with the Ethereum network, building user interfaces, and deploying your application to the Internet. This course supplies seven self-contained lessons taught in a practical, hands-on way. By the end of the course, you will be amazed at how much you have learned about Blockchain application development on the Ethereum network in just one week.

The second course, Ethereum Projects, covers building Blockchain, Cryptocurrency, &and smart contracts by building decentralized applications using Ethereum. This course provides you with a clear approach to building cryptocurrencies, smart contracts, and decentralized applications. Throughout the course, we walk you through a detailed step-by-step process to build advanced Ethereum projects. Each project will teach you just enough about Ethereum to be productive right away. You will learn how tokenization works, how to think in a decentralized way, and how to build Blockchain-based distributed computing systems. You will build interesting projects with Ethereum such as wallets, copyright, secure data sharing, and more. By the end of this video, you will be able to tackle Blockchain challenges by implementing projects end-to-end using the full power of the Ethereum Blockchain.

The third course, Creating Smart Contracts with Ethereum, covers building decentralized, transparent and fraud-resistant smart contracts. In this course, you’ll start by learning the Ethereum smart contract programming language Solidity and its capabilities. You’ll design, test, and deploy secure Ethereum smart contracts using the latest industry standards. Also, you’ll build dynamic front ends for web applications and configure your project infrastructure with smart contracts and the Ethereum blockchain. By the end of the course, you’ll have comprehensive knowledge in writing smart contracts and building applications that interact with them.

Towards the end of this course, you'll build Blockchain, Cryptocurrency, and smart contracts by building decentralized applications using Ethereum.

About the Authors

  • Will Button has worked in software engineering and Information Technology since 1995. For the past 10 years, he has focused on scaling, performance, and automation for tech startups in healthcare, logistics, fitness, and more. During that time, he has helped startups manage explosive growth, align expenses with funding, and control customer acquisition costs. Having turned his attention to Blockchain in 2017, Will is bullish about its long-term potential and the opportunities available for tech industry professionals. He believes we are at the forefront of the next big revolution in technology and shares his experience, skills, and knowledge with those ready to be part of it.

  • Daniel Wise has worked in various career paths both domestic and abroad, and since then he focused on the tech field. He began his journey learning programming on Treehouse .com while he lived abroad in Busan, South Korea. His interest in tech began to grow after being accepted into the Flatiron School and returned to the USA to pursue this new career. He has gained experience in the tech field not just on the development side but on the business side as well. His experience and hard work running an indie game studio (known as Ultima Game Studios) paid off when their game demo was chosen to be exhibited at PAX East 2017. This experience in the gaming industry allowed him to utilize his talents in both development and marketing. Currently, he is a busy freelancer, handling projects in Unity development and also writing technical lessons to share his knowledge online. He believes that it is his duty to help others learn about tech/coding while creating projects and learning new things himself. He also assesses promotional ideas and strategies for those looking to promote their businesses online.

  • Drew Taylor has been a Bitcoin and Ethereum miner since February 2017, and Montreal's rapid growth in the fintech space has given him rich first-hand experience of the cryptocurrency industry. He also works as senior blockchain developer for Greenstream Networks. By constantly tackling new programming tools, Drew has developed a powerful learning curve that has allowed him to master web development, mobile development, cryptocurrency development, and blockchain development.

Who this course is for:
  • This Course is perfect for:
  • IT Professionals, Developers, Software Engineers, Entrepreneurs, and Blockchain enthusiasts at all levels, who want to get themselves updated with the latest version of Ethereum 2 to build Blockchain, Cryptocurrency, and smart contracts by building decentralized applications using Ethereum.
Course content
Expand all 90 lectures 10:06:30
+ Blockchain Application Development in 7 Days
45 lectures 03:34:35

This video provides an overview of the entire course.

Preview 02:30

To build dapps, you need the right tools. You will learn how to install the tools needed and learn their role in blockchain application development.

   •  Identify the tools used in building decentralized applications

   •  Understand the relationship between the tools

   •  Install the tools on your computer

Installing Visual Code, Node.js, the Truffle Framework, Git, and Ganache

To build dapps, you use contracts. To build contracts, you will need to understand what they are and how they operate.

   •  Learn what a smart contract is

   •  Understand how contracts work

   •  Create and implement a contract

Create Your First Contract

Contracts are written in the Solidity programming language. Learning the language syntax is necessary to mastering this skill.

   •  Learn the syntax conventions and guidelines

   •  Learn the programming types used in Solidity

   •  Write your first solidity code

Understand Basic Syntax

Code contains errors. Writing tests can detect these errors and prevent them from impacting your dapp.

   •  Identify the types of tests available in Solidity

   •  Learn the capabilities of each test type

   •  Write a solidity test

Writing Your First Test

Here is the assignment for Day-1.

   •  Install software as needed

   •  Using the truffle command, unbox the truffle files for this project

   •  Confirm steps were successful with the “truffle test” command


Learn what variables are and how they are used in the Solidity programming language.

   •  Identify what a variable is

   •  Learn about static typed variables

   •  Understand variable visibility

Understanding Variables

Put your knowledge of variables to use by implementing a real-world solution using variables.

   •  Analyze how variables are used in contracts

   •  Follow the application logic using variables

   •  Identify special variables in Solidity

Data Types in Solidity

To write contracts, you must understand how to store contract data using variables.

   •  Learn what value type variables are

   •  Learn what reference type variables are

   •  Combine value and reference type variables in a contract

Using Variables in Code

Learn how to implement business logic through the use of operators.

   •  Identify the operators available in Solidity

   •  See the operators in action

   •  Learn about type conversion in Solidity

Understanding Solidity Operators

Get a deeper understanding of using operators by evaluating their use in code.

   •  Examine code using operators

   •  Nest multiple operators together for complex logic

   •  Determine a function’s role using the defining code

Usage of Solidity Operators

Here is the assignment for Day-2.

   •  Create a new smart contract in the contracts folder called Gaming.sol

   •  Create a struct datatype called player with the following variables


Here we will learn how we implement complex business logic in contracts.

   •  Learn that functions are executable units of code

   •  Identify the format of functions

   •  Understand the different types of functions

Understanding Functions

Function visibility allows you to protect access to functions. In this video, we will learn the importance of function visibility.

   •  Identify the types of function visibility

   •  Learn the differences between each visibility

   •  See how visibility is used to implement our dapp

Function Visibility

In this video,we will learn how to use functions to implement the rules of our game.

   •  Define the rules of our online game

   •  Walk through the logic of our main function

   •  Combine multiple functions to create complex logic

Using Functions to Execute Business Logic

In this video, we will learn to use modifiers to create constraints and conditions prior to executing functions.

   •  Define what modifiers are

   •  Use require to define rules for a function

   •  Implement modifiers to enforce rules

Understanding Modifiers

In this video, we will gain a better understanding of modifiers by reviewing practical examples.

   •  Implement a modifier restricting access to a function

   •  Implement a modifier restricting access by time

   •  Implement a modifier requiring funds

Using Modifiers to Ensure Conditions Are Met

Here’s the assignment for Day-3

   •  Create a function named “loseAll”

   •  Identify users who try to avoid losing money by betting on both possible outcomes

   •  Transfer all of the player’s funds to the contract


In this video, we will learn about two common types of tests to identify their function and provided guidance on writing your own tests.

   •  Identify the function and scope of unit tests

   •  Identify the function and scope of integration tests

   •  Evaluate the operation of a Solidity test

Understanding Unit Tests versus Integration Tests

How do you know where to start writing tests? How do you know when to stop? This lesson will offer guidance on those questions.

   •  Learn common strategies for writing tests

   •  Examine tests using Solidity

   •  Examine tests using Javascript

Testing Strategies for Applications

Writing tests in Solidity leverages coding principles similar to writing contracts. How can you leverage that knowledge?

   •  Learn Solidity test conventions

   •  Understand the imports required for Solidity tests

   •  Evaluate tests to understand their role

Creating Unit Tests in Solidity

Solidity tests have limitations.In this video, we will learn to write JavaScript tests for more flexibility and control.

   •  Learn JavaScript test conventions

   •  Understand the syntax of JavaScript tests

   •  Evaluate JavaScript tests to understand their function

Creating Integration Tests in JavaScript

In this video, we will learn to execute the test suite to evaluate the tests for your application.

   •  Understand the role of the components required for testing

   •  Configure truffle to use the local development network

   •  Learn to debug solidity contracts

Running Test Suites

Here’s the assignment for Day-4

   •  Create tests for the “loseAll” function

   •  Test all possible scenarios to ensure proper operation


In this video, we will learn how the User Interface interacts with our Ethereum contract.

   •  Understand the role of react and redux in our Dapp

   •  Learn the action - reducer - state lifecycle

   •  Identify the functions provided by web3

Understanding the Role of JavaScript and React in a DApp

Creating a react app from scratch requires a lot of setup.In this video,we will learn the pros and cons of common methods.

   •  Learn the pros and cons of create-react-app

   •  Learn the pros and cons of cloning a project

   •  Identify the correct method for your application

Creating a React App from a Template

In this video, we will learn where to store the application state, or user data for your Dapp.

   •  Learn what React components are

   •  Identify React lifecycle methods that update state

   •  Create components with values set by application state

Display Game State to Players

In order to execute our game, we need input from our player. Namely, how much they wagered and their guess. How do we get this information?

   •  Use functions to execute actions

   •  Write code to dispatch actions to reducers

   •  Use reducers to update the Redux store

Get Player Input from the UI

Once we execute game play, we need to notify the player the results of that round. This step completes the action - dispatch - reducer lifecycle.

   •  Use componentDidUpdate to check for changes to state

   •  Bind UI components to state variables

   •  Update UI components on state change

Provide Feedback to the Player

Contract calls don’t execute immediately.In this video,learn to use Promises to identify when they complete.

   •  Understand how network calls impact JavaScript applications

   •  Learn how Promises solve this issue

   •  Examine a common JavaScript Promise

JavaScript Promises in a Networked Application

In this video,learn to use the web3.js library to facilitate this.

   •  Refactor game play to implement Ethereum contract calls

   •  Implement the web3.js library to access the contract

   •  Evaluate the contract response for data returned

Using web3.js to Communicate with the Ethereum Network

Contract function call results are saved in the Redux store. In this video,we will learn how to access the store to implement results in the UI.

   •  Understand the role of mapStateToProps

   •  Identify the correct lifecycle method to call on new props

   •  Integrate data from props into the UI

Implementing JavaScript Functions in a User Interface

Here’s the assignment for Day-5

   •  Render an element in the UI that displays the random number generated in each round


Learn what wallets are and the different types of wallets available.

   •  Understand the role of wallets in cryptocurrencies

   •  Learn about the types of wallets available

   •  Choose a wallet based on your requirements

Understanding Wallets and Security

Install and configure MetaMask to act as the wallet and web3 provider for our Dapp.

   •  Learn the features of MetaMask

   •  Install MetaMask

   •  Connect MetaMask to Ganache

Install and Configure MetaMask

Learn what gas is in the Ethereum network and the role it plays in our Dapp.

   •  Identify how gas is used in decentralized applications

   •  Learn the function of gas price

   •  Understand the limits imposed by gas limit

Understanding Gas Price and Gas Limits

Identify transactions on the blockchain network and the status of the transaction.

   •  Learn what confirmations are

   •  User to view transactions

   •  Explore data exposed by

Viewing Blockchain Transactions on the Ethereum Network

Understand the key differences and benefits between online and offline wallets.

   •  Identify the types of wallets available

   •  Understand the features of each type of wallet

   •  Implement a multi-wallet strategy

Understand Online and Offline Wallets

In this video, you’ll look into the metamasks which exists

   •  Inject web3Provider into the browser

   •  Read the account information

Injecting the Web3 Provider

Here’s the assignment for Day-6

   •  Configure MetaMask for your local development environment

   •  Verify proper operation by deploying your contract

   •  Identify the transactions in your local Ethereum network using the transaction hash


There are multiple test networks available. Learn the key features of each to make informed choices when choosing one.

   •  Identify the three main test networks

   •  Summarize the differences between the networks

   •  Explain why the Ropsten network is used in our Dapp

Understanding the Role of the UI and Smart Contract

Learn to configure truffle to use the test network and deploy your contract.

   •  Configure truffle.js to use the Ropsten network

   •  Install the geth client

   •  Launch and sync get with Ropsten

Deploying Smart Contracts to the Ethereum Network

In order to use the Ropsten test network, you need Ropsten Ether. Learn how to obtain it in this lesson.

   •  Connect Metamask to Ropsten

   •  Request ether from a faucet

   •  Configure geth to use your Ropsten account

Obtaining Ether for Use in Test Networks

The last step to launch our application is to make it available to the world

   •  Create a Docker image

   •  Create an ECS service

   •  Launch the service and test the Dapp

Deploying the UI to AWS

Here’s the assignment for Day-7

   •  Deploy your smart contract to the Ropsten test network

   •  Obtain Ether from the Ropsten test network

   •  Verify proper operation of your game by playing a few rounds

+ Creating Smart Contracts with Ethereum
23 lectures 04:44:15

This video will give you an overview about the course.

Preview 05:21

Developers should have a good understanding of how Solidity code is compiled and executed on the blockchain as EVM byte code, and how gas payments work. Ethereum has a steep learning curve, so we'll also be looking at challenges that the developers are facing that are unique to DApp development.

  • Learn about the different pieces which make up the Ethereum network

  • Understand how gas payments work in Ethereum

  • Understand the unique challenges particular to ETH development

Ethereum and the Blockchain Technology

To be a good Solidity developer, it's important to know some of the pitfalls particular to blockchain development so that we don't get unnecessarily frustrated or distracted by configuration problems or misunderstandings during the workflow.

  • Local blockchains can be resource-intensive, remote instances can prevent this

  • Ethereum SDKs and developer tool sets are changing constantly

  • How to avoid losing money (ETH) during the development process?

Adapting for Blockchain Programming

Before programming a smart contract, we need to understand what the Solidity language is, what smart contracts are, and how to deploy them on the blockchain.

  • Learn about the Solidity language and what smart contracts are

  • An overview of the workflow process for programming with Solidity

  • Compile, deploy, and call a Solidity smart contract

Exploring Solidity – The Smart Contract Programming Language

In order to deploy the solidity code we compile, we first need to have a working Ethereum wallet and access to a node on the Ethereum network.

  • Install and configure the MetaMask browser extension

  • Link a MetaMask wallet to the Remix Solidity compiler

  • Fund a MetaMask wallet with ether from the Kovan testnet faucet

Interacting with the Blockchain Using MetaMask

We already compiled a Solidity program in Section 1. We know what it does, but we don't yet know what the code means. In this lesson, we'll learn to understand the contract we deployed in Section 1 by examining each line of the program carefully.

  • Understand `pragma solidity ^x.x.x` declarations and Solidity versioning

  • Understand the Mortal contract

  • Understand the Greeter contract

Working with Remix – The Solidity Browser IDE

Why does the most recent version of Solidity throw warnings when we try to compile the smart contract from last video? How can I deploy this code with the warnings removed? We'll take a hands-on approach to answering these questions by debugging the warning messages and updating our code to be Solidity ^0.4.25 friendly.

  • Understand Solidity constructor statements

  • Understand Solidity visibility requirements for variable types and functions

  • Understand static analysis warnings

Compiling, Deploying, and Testing Smart Contracts Using Remix

Understanding how to call smart contracts from a web application environment, and just from within the Remix console, is important if we want to build Ethereum applications. In this video we will learn how to query the Ethereum blockchain from our own JavaScript environment.

  • Query open permissions endpoints from Infura

  • Set up a Web3 JavaScript with npm and Node.js

  • Connect Web3 with an Infura provider

Incorporating Web3 and Infura into Smart Contract Applications

Once we have configured Web3 to work with Infura, we'll need to learn how to connect our Web3 instance with an instance of our contract. In this video, we'll learn how to connect our Infura provider instance of Web3 with a contract instance and how to query the contract's functions using Web3.

  • Understand the ABI or Application Binary Interface

  • Connect Web3 with an instance of our smart contract

  • Call our deployed contract using Web3

Interacting with Smart Contracts Using Web3 and Infura

Now that we're competent at compiling and deploying basic smart contracts, we need to take a deeper look at what interacting with complex contracts entails.

  • Understand what the open auction contract will do

  • Compile and deploy the contract

  • Call the bid function by bootstrapping the contract in MyEtherWallet

Creating Complex Smart Contracts with Solidity – Part One

Now that we understand the contract's basics and how to load and call it, we finish analyzing the contract by calling all its functions and investigate sending invalid data to the bid function.

  • Investigate how the smart contract handles a bid sent to it with invalid parameters

  • Call the withdraw function to return losing bids to the sender

  • Call the auctionEnd function and closing the auction

Creating Complex Smart Contracts with Solidity – Part Two

In order to program complex smart contracts, we need to know about all of the data and reference types available to developers, which are explained in detail in this video.

  • Understand function declarations and how Solidity functions can differ from other programming languages

  • Understand value type variables in Solidity and how to declare and implement them

  • Understand reference type variables in Solidity and how to declare and implement them

Exploring Solidity Types

We already have a basic understanding of value and reference type variables, but this video provides an in depth lesson on utilizing two key variable types which are more specific to Ethereum development, and which may be new concepts for developers.

  • Understand how mappings work in Solidity

  • Understand and making use of structs

  • Investigate using a struct in a real DApp which is served online

Using Function Modifiers

Although type modifiers are common to many programming languages, function modifiers are specific to Ethereum. In this video we learn what function modifiers are and how to use them.

  • Understand what function modifiers are and also how they can be overridden

  • How to declare and implement function modifiers

  • Call a modifier from a deployed smart contract using Remix

Assertions, Control Structures, and Emitting Events

We've already covered a lot of concepts in advanced smart contract programming. This lesson will complete any knowledge about Solidity syntax and available commands which haven't yet been covered.

  • Understand returning output from a smart contract

  • Use assertions in Solidity to handle errors and exceptions

  • Emit events and how they can be listened for by a DApp frontend

Utilizing Solidity Mappings and Structs

We've already learned how to create, compile and deploy smart contracts, but we haven't yet learned how to interact with them from an ender user perspective. In this video, we'll learn how to build web application that calls our Solidity code in a way fit for public consumption.

  • Learn about the smart contract powering our web application

  • Compile and deploy the contract

  • Decide on, and listing, our DApp's dependencies

Building a Web Application on Top of the Ethereum Blockchain

Before we can call our smart contract code from a web browser, we need to create our web application environment and connect with with Web3. In this video, we'll learn the step by step process of how to achieve this with the React.js framework.

  • Install our dependencies and running a web server

  • Brainstorming creating our MetaMask user workflow

  • Program our web application and incorporating that user workflow

Bootstrapping a React Application and Incorporating Web3

We've already created a Web3 enabled web application, but we need to connect our smart contract and interact with it as an end user. In this video, we'll learn all about connecting to a smart contract and calling its functions.

  • Update our main application file (app.js) and listening for emitted events

  • Import the ABI and connecting Web3 with our smart contract

  • Update our Redux reducers and calling smart contract functions from React

Building an Ethereum Application with React

A lot of code has been written and our game DApp is finally ready to be played by others. In this video we take a hands-on approach to interacting with our DApp from the UI.

  • Review our old deployment

  • Review the final version of our DApp

  • Review the source code implemented in the final version

Demonstration of the Ethereum Application

Before our decentralized application is ready to be deployed on the Ethereum mainnet we need to assemble a unit testing environment, and test the security of our smart contract. In this video we'll learn how to begin this process.

  • Explore our project layout, the Truffle framework, and its modules

  • Install and configure Truffle

  • Connect Truffle to our DApp's smart contract

Setting Up an Ethereum Production Environment

Now that we have configured a unit testing environment for Solidity we can start to run unit tests against our DApp's smart contract, as demonstrated in this video.

  • Create and run a simple unit test

  • Add more complexity to our unit test

  • Finalize and run our complex unit test

Unit Testing Smart Contracts with Truffle

If we want users of our DApp to be able to trust that the smart contract they are sending money too isn't doing something suspicious, we're going to need to publish verified Solidity files for them to browse online. This video demonstrates how to do that on, the most popular Ethereum transaction browser.

  • Learn why verifying and publishing Solidity source code online is important

  • Upload and verify the source code for our DApp

  • Browse the published source code on Etherscan

Verifying Smart Contract Code on Etherscan

In the same way that the Internet DNS system provides human readable addresses to resolve IP addresses, the Ethereum network has the ENS system to provide human readable names for wallet and smart contract addresses. In this video we cover the steps required for registering an ENS name with the Ethereum Name Service registrar.

  • Learn about ENS

  • Open an ENS auction

  • Reveal our bids during the bid phase, to validate them

Deploying Over ENS
Test your knowledge
5 questions
+ Ethereum Projects
22 lectures 01:47:40

This video will give you an overview about the course.

Preview 02:25

Blockchain opens up a vast array of possibilities, but navigating these possibilities is hard. Here we look at some existing use cases.

  • Warm up by looking at existing use cases made by other developers and companies

Use Cases

In this video, we will break these technologies down and explain their working components in greater detail.

  • Look at the components and inner workings of Blockchains in general

  • Look at the components and inner workings of Ethereum

An Overview of Blockchain and Ethereum

Blockchain and Ethereum are great and very flexible technologies that can be used for many applications. However, as with each technology, it has its potentials and limitations. In this video we will evaluate those.

  • Evaluate the potential added benefit of using Blockchain technology

  • Evaluate the potential dangers and limitations that present when developing with Blockchain technology

Potentials and Limitations

Developing and testing Ethereum applications can be a very slow process. In this video, we will look at how to set up a proper and efficient workflow to develop Ethereum applications.

  • Install Truffle

  • Install TestRPC

  • Install MetaMask

Workflow Setup

This video focusses on how you can quickly set up a new Ethereum project using Truffle.

  • Create new project with Truffle

  • Examine the standard project’s architecture

Starting a New Project

In this video, we will look at how we can quickly deploy and test our smart contracts on a testing environment.

  • Setup test environment

  • Deploy on test environment

  • Test smart contracts in testing environment

Deploying and Testing Out Our First Project

In this video, we will be learning syntax and exploring the code.

  • Take a look at the solidity syntax

  • Check out how the example project’s code is set up

Syntax and Code Exploration

In this video we will look at the best ways to debug smart contracts.

  • Deploy smart contracts

  • Debug smart contracts in Remix

Bug Fixing and Debugging

In this video, we will focus on what you could do to change this application into an application that is better suited for real-world payments.

  • Add a creator fee system

  • Make additional changes that could enable exchange of real money for digital currency

Changing Our Application into a Better Payment Application

In this video, we will look at, and create, a basic ERC20-compliant Cryptocurrency using OpenZeppelin

  • Install OpenZeppelin

  • Transform MetaToken to an ERC20 token

Creating an ERC20 Token

In this video, we will look at how you can deploy and test your ERC20 tokens on the development Blockchain.

  • Deploy ERC20 smart contract

  • Add ERC20 token to MetaMask

Deployment and Testing an ERC20 Token

In this video, we will look at more tokens specifications with OpenZepplin.

  • Look at some more specifications beside ERC20, such as ERC721, the non-fungible token

  • Look at how you can use OpenZeppelin to easily create these tokens

Implementing Other Token Standards

Sometimes you want to have certain code to be executed upon the receiving of a token. In this video we examine how exactly you can achieve that.

  • Get the compiled bytecode of a function

  • Add a callback to the transfer function

Using Tokens and Executing Logic

In this video, we will look at how you can anchor sensitive data to the Blockchain, and keep the data off-chain.

  • Save data in own back-end

  • Hash data

  • Store hash of data on the Blockchain

User Identity and Sensitive Data on the Blockchain

In this video, we will look at some possible ways you can work with big files and Blockchains.

  • Save large files in own back-end

  • Hash the files

  • Store the hash of the files on the Blockchain

Dealing with Files and Large Data on the Blockchain

In this video, we will look at how you can verify a user’s identity for yourself while keeping him anonymous to the rest of the world.

  • Take a look at the user solidity code for user verification process

  • Get an in-depth look at how the process works

User Identity Verification with Blockchain

In this video, we will be signing a real-world contract with a smart contract.

  • Add user to smart contract

  • Add file to smart contract

  • Add signing function

Signing a Document on the Blockchain

In this video, we have a look at the potential applications that can be developed outside of the browser using Ethereum.

  • Know the pre-requisites to using Ethereum outside the browser

  • Get to know how Golem is used for this purpose

Ethereum Outside the Browser

In this video, we have a look at how Ethereum can serve as the backbone of IoT by allowing secure, open communication between tamper-proof sensors and devices.

  • Get to know that dataflow and security are the major reasons why Ethereum forms the backbone of IOT

  • Learn by getting practical example on how Ethereum is crucial in IOT

Ethereum and IoT

In this video, we will look at how to use Ethereum in a smartphone application.

  • Know the three ways of making mobile application using Ethereum

  • Learn something about DAPP browsers

Ethereum in Smartphone Applications

In this video, we discuss some of the further steps you can take to learn more and stay updated on these ever-evolving technologies.

  • Learn about Infura that acts a relay server for the Ethereum and IPFS network

  • Get to know about various sources where you can keep up to date regarding Ethereum

Further Steps and Resources