CourseFlix

Ethereum Blockchain Developer Bootcamp With Solidity (2023)

23h 38m 36s
English
Paid

Learn how to build real smart contracts with simple steps and clear code. This intro helps you start fast with Solidity and the Ethereum stack. You get short lessons, hands-on tasks, and plain guides that show you how each part works. You write code from day one, so you see how the pieces fit together.

What You Will Do

You will build a full blockchain app. You start with the basics, then move into tools, tests, and deploy steps. Each part has clear goals, so you can follow along with ease.

Project: Blockchain Notary

You and the instructor create a notary app on Ethereum. You write the contract, test it, and deploy it to local, test, and public networks. This gives you real skills that match daily work in Web3.

Steps in the Course

  1. Solidity basics
  2. How a blockchain works
  3. Notary contract logic
  4. Ethereum tools
  5. Intro to Web3
  6. Web3 tools
  7. Types of blockchain nodes
  8. How decentralization works
  9. Local work with Truffle
  10. DApps with HTML and JavaScript
  11. Publish your project

Requirements

  • Basic JavaScript or HTML skills
  • A computer with Windows, Linux, or macOS
  • Nice to have: C++ or Java basics
  • Nice to have: Git basics
  • Nice to have: Some Solidity exposure

Who This Course Is For

  • Developers with general coding skills but no Solidity experience
  • People who know about Ethereum but do not know how to begin
  • Anyone who wants to learn how this tech works
  • Developers who wrote simple Solidity code and want deeper skill
  • People who feel lost in the Web3 space and want a clear path

What You Will Learn

  • Tools used to build smart contracts
  • How to read and write safe Solidity code
  • How to avoid common bugs in blockchain code
  • The full build and deploy flow
  • Pros and cons of blockchain tech
  • How to use private, test, and public networks
  • How transactions work
  • How gas and gas cost work
  • How to write, deploy, and interact with a contract
  • The difference between web3.js and truffle-contract
  • How to write tests with Truffle
  • How to install and use the Truffle framework
  • How to deploy to IPFS

About the Author: udemy

udemy thumbnail

Udemy is a global online marketplace for teaching and learning. It connects students with instructors who share skills in many fields.

Who Uses Udemy

Millions of learners use Udemy to gain skills for work and personal growth. Companies, governments, and nonprofits also use Udemy to train their teams.

What Udemy Offers

Udemy provides a curated set of business and technical courses. These courses help teams build practical skills and support ongoing learning at work.

Watch Online 194 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 194 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Your Instructor For This Course
All Course Lessons (194)
#Lesson TitleDurationAccess
1
Your Instructor For This Course Demo
02:16
2
Who Is This Ethereum Course For?
02:15
3
Course Structure - So You Get The Most Out Of It
02:58
4
A Quick Note On Udemy Reviews
02:30
5
Section Overview
01:17
6
Setup Remix
01:42
7
Remix File Management
04:58
8
Starting, Stopping And Interacting With Smart Contracts
08:25
9
Blockchain Basics
11:14
10
Read And Write To Smart Contract
05:40
11
Section Wrap Up
10:20
12
Congratulations
01:03
13
Overview
01:35
14
Booleans
04:27
15
(Unsigned) Integers
09:30
16
Integer Rollover - SafeMath
05:02
17
Strings And Bytes
07:28
18
Address Types
04:13
19
(Behind The Scenes) The Msg. Object
03:57
20
Writing And Reading Functions - View Vs. Pure
06:00
21
Understanding The Constructor
03:43
22
Section Wrap Up
07:30
23
The Blockchain Messenger Implementation
03:55
24
Congratulations
00:59
25
Overview
01:18
26
Installing And Configuring Metamask
10:19
27
Get Free Ether And Send Transactions
13:37
28
(Behind The Scenes) Metamask
06:23
29
(Behind The Scenes) An Ethereum Transaction
10:28
30
(Behind The Scenes) Hashing
09:22
31
Cancel Or Update Ethereum Transactions
05:03
32
Remix And The Injected Web3 Provider
05:55
33
The Payable Modifier And Msg.value
08:58
34
(The Fallback Functions) Fallback And Receive
11:56
35
Section Summary
10:48
36
The Smart Money Implementation
10:22
37
Congratulations
01:09
38
Overview
01:03
39
Solidity Mappings
09:51
40
Mappings: A Wallet Example
10:03
41
Structs Vs. Child Contracts
11:52
42
Structs And Mappings
14:24
43
(Exceptions) Require
07:27
44
(Exceptions) Assert
04:50
45
Try/Catch In Solidity
09:37
46
Low-Level Solidity Calls In-Depth
19:06
47
Section Summary
15:35
48
The Smart Contract Wallet Implementation
19:57
49
Congratulations
01:41
50
Overview
01:01
51
Web3.js Introduction
08:55
52
Understanding The ABI Array
11:09
53
Events As Return Variables
05:36
54
Metamask, Web3.js, And Event Listeners
19:33
55
(Behind The Scenes) Events
07:12
56
Modifiers And Inheritance
08:24
57
(Behind The Scenes) Modifiers
05:24
58
(Behind The Scenes) Reserved Keywords
06:45
59
Destroying Smart Contracts With Self-Destruct
05:36
60
Block Explorers And Source Code Verification
12:01
61
The ERC20 Token Explained
18:47
62
Implementing An ERC20 Token Sale
13:48
63
Congratulations
01:23
64
Introduction To The NFT Project
01:24
65
Deploy ERC721 Token From OpenZeppelin As OpenSea NFT On Goerli Using Remix
14:33
66
How To Get Truffle Prerequisites On Your System For Windows, Linux And Mac
08:06
67
Start A New Truffle Project Correctly And Understand The Folder Structure
11:13
68
Truffle Migrations And How To Run Them From The Command Line Interface
10:51
69
Using The Truffle Console To Interact With Smart Contracts On All Networks
05:04
70
Write Your First Truffle Unit Test & Understand Advanced Event Assertions
15:41
71
Deploy A Smart Contract Using HDWallet Provider Vs. Truffle Dashboard
17:27
72
Debug Smart Contracts #1: Using Console.Log Inside Solidity Using Ganache
12:23
73
Debug Smart Contracts #2: Using The Powerful Truffle Debugger And Chain Forking
13:01
74
Summary: Truffle and Smart Contract Development
24:16
75
ERC20 Vs. ERC777 And ERC721 Vs. ERC1155 Tokens Explained
08:43
76
Hardhat Setup And Configuration Overview
12:02
77
Deploying To Görli With HardHat And Verifying Smart Contracts On Etherscan
09:38
78
Unit Testing With HardHat And Console.Log In Solidity
11:59
79
Installing and Configuring Foundry and Forge
05:13
80
Adding our NFT Contract to Foundry
04:15
81
Writing Unit Tests for Foundry and understanding VM Pranking
11:27
82
Deploy Smart Contracts using Foundry Scripts and Seed Phrases with Verification
08:36
83
Outro and Thank You
01:33
84
Welcome To The Course
04:58
85
Ownership, Possession And The Double Spending Problem
04:50
86
We Install MetaMask And Get Ether Into The Wallet
07:41
87
Behind The Scenes: MetaMask, Infura, Blockchain Nodes And The Ledger
04:49
88
Send Your First Transaction Using MetaMask
03:21
89
Behind The Scenes: Ethereum Transactions And Signatures, Private/Public-Keys
10:31
90
This Is How Blocks Are Chained Together - Cryptographic Hashing Explained
07:01
91
Housekeeping - Get The Most Out Of The Course!
08:19
92
LAB: Create Your First Smart Contract
06:44
93
Create Your First Smart Contract - Explained
08:18
94
LAB: Understanding Blockchain Nodes
06:01
95
Understanding Blockchain Nodes - Explained
09:15
96
LAB: Variables - (Unsigned) Integers In Solidity
04:11
97
LAB: Variables - Booleans
01:12
98
LAB: Variables - Understanding Integer Wrap Around
01:58
99
LAB: Variables - Addresses And Balances
03:43
100
LAB: Variables - Strings In Solidity
03:15
101
Solidity Value Type Variables - Explained
09:52
102
LAB: Understanding Addresses And The Msg-Object Step-By-Step
11:47
103
Addresses And The Global Msg.object - Explained
09:10
104
LAB: Starting, Stopping, Pausing And Deleting Smart Contracts
12:08
105
Starting, Stopping, Pausing And Deleting Information - Explained
08:55
106
LAB: Introduction To Mappings
08:49
107
LAB: Understanding Mappings By Example
10:42
108
LAB: Understanding Solidity Structs Step-By-Step
05:12
109
Mappings, Structs And Arrays - Explained
10:19
110
LAB: Exception Handling In Solidity - Require + Assert
07:30
111
Exception: Require Assert Revert - Explained
10:52
112
LAB: Constructor, The Fallback Function And View/Pure Getter Functions
12:06
113
Constructor, Fallback Function, View/Pure Functions And Function Visibility
08:55
114
Lab: Modifier, Inheritance, Importing Of Files
08:47
115
Modifier, Inheritance And Importing: Explained
03:21
116
Lab: Events And Return Variables
05:50
117
Events And Return Variables: Explained
09:42
118
LAB: The ABI Array And Debugging Explained
10:10
119
ABI Array, Debugging And Gas Introduction In Solidity Explained
10:43
120
Understanding Gas And Gas Costs Step-By-Step
07:45
121
LAB: Libraries And Using ... For
09:49
122
Libraries And Using ... For Explained Step-By-Step
03:31
123
UPDATE: Solidity 0.6.0 Breaking Changes Walkthrough
17:54
124
Introduction To The Project We Are Developing
03:59
125
Step 1: Define The Basic Smart Contract
02:58
126
Step 2: Securing The Smart Contract
03:36
127
Step 3: Re-Using OpenZepplin Smart Contracts
03:59
128
Step 4: Add Allowance Functionality
08:37
129
Step 5: Add Reduce-Allowance Functionality
05:29
130
Step 6: Improve The Smart Contract Structure For Better Auditability
01:34
131
Step 7: Add Events For The Allowance Smart Contract
05:01
132
Step 8: Add Events For The Simple Wallet Smart Contract
03:36
133
Step 9: Add The SafeMath Library
03:34
134
Step 10: Remove The RenounceOwnership Functionality
02:30
135
Step 11: The Final Smart Contract From Our Project
01:45
136
Installing NodeJS To Get Our Environment Set Up
03:54
137
Use Web3.js In The Node Console To Send Ether From One Account To The Other
12:54
138
Use Web3.JS In The Node Console To Interact With Smart Contracts
11:30
139
Using Web3.js With Chrome To Interact With Smart Contracts - Step-By-Step
08:09
140
Behind The Scenes: Web3.js, Blockchain Nodes, RPC, IPC, WebSocket Connections
09:28
141
Project Introduction: This Is What We Build
05:42
142
A Demo Of The Final Smart Contract Functionality
04:02
143
Solidity Part: Implement Approach 1 For Payment Notifications
08:43
144
Solidity Part: Test Approach 1 For Payment Notifications
03:24
145
Solidity Part: Improve Approach 1 For Flawless UX For Endusers
12:06
146
Solidity Part: Add Ownable Functionality And Why I Didn't Choose OpenZeppelin
04:21
147
Truffle - Introduction To The Truffle Framework And Truffle Boxes
08:39
148
The Truffle React Box Explained Line-By-Line
12:58
149
Replace Smart Contracts In The Truffle React Box
04:50
150
Modify the App.js And HTML Part In The React Box
12:07
151
Implement The Add-Item functionality To Our Smart Contracts For Item-Tracking
10:38
152
Add Event-Triggers To Track Payments And Start The Delivery-Process
07:22
153
Create Unit-Tests In Truffle To Maintain Code Quality
15:49
154
Let Me Introduce The "Big Picture"
06:09
155
This Is Where You Can Download Geth And How You Install It
02:20
156
This Happens When You Open Geth Without Any Additional Parameters
06:44
157
Log-Output from Geth Explained
05:03
158
This Is Where The Data Is Stored By Default In Geth
01:41
159
This Is How You Attach To A Running Geth Instance
03:05
160
We Are Working With The JavaScript JSON-API
07:02
161
This Is The Difference Between Blockchains and Networks
02:42
162
This Is The Genesis.json File
04:11
163
Let's Create Our Own Private Network With Go-Ethereum
04:01
164
First Steps With The JSON API And Our Private Network
06:04
165
This Is How I Mine Ether On My Private Network
07:23
166
Let Me Show You Some Important Tips and Tricks With Geth
03:34
167
Project Introduction: This Is What We Are building
03:02
168
Fungible vs. Non-Fungible Tokens Summarized
04:14
169
This Is How We Approach This Project: The Implementation Path
07:06
170
We Install Truffle And Initialize Our Project Using Truffle Boxes
02:19
171
Let's Add In The ERC20 Smart Contracts From OpenZeppelin
04:08
172
We Add Migrations For Truffle For The OpenZeppelin Smart Contracts
04:20
173
Let's Add Unit Tests Using Mocha, Chai, Chai-Expect And Chai-As-Promised
11:20
174
It's Time To Add More Unit Tests For Full Testing Of Our MyToken Smart Contract
08:09
175
We Add A Crowdsale Smart Contract For Solidity 0.6.x From OpenZeppelin
04:24
176
This Is How You Use The Crowdsale Smart Contract From OpenZeppelin
02:38
177
Let's Add The Migration For The MyTokenSale Smart Contract
05:39
178
Let's Fix The Unit Test And Encapsulate It From The Other Tests
03:09
179
Let's Consolidate Our Configuration In Truffle Into One .env File Using dotenv
05:36
180
Let's Write A Crowdsale Unit Test Using Mocha And Chai
04:46
181
Fix Multiple Truffle Tests Using A Common Setup For Chai And Chai Expect
03:11
182
Let's Add The Remaining Unit Tests Into Our Crowdsale
06:56
183
We Add A KYC Smart Contract Solution Mockup For Our Crowdsale With Whitelisting
10:52
184
Let's Adapt The React Frontend For Our TokenSale App
09:54
185
Let's Add The KYC Whitelisting Functionality To Our Frontend
06:36
186
Fix Common Errors With Accounts, Contracts And Private Keys
09:14
187
Use Truffle HDWallet Provider To Deploy Smart Contracts
11:44
188
Buy Tokens Using MetaMask And The Send Functionality
05:42
189
Display Tokens Directly In MetaMask
02:43
190
Display And Buy Tokens Via The Website Using Web3.js
09:48
191
Deployment Of The Smart Contracts To Ropsten Using Infura
07:44
192
Introduction
02:04
193
Essential Soft Skills Recruiters Require
10:17
194
Conclusion
00:52
Unlock unlimited learning

Get instant access to all 193 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription