CF

Ethereum Blockchain Developer Bootcamp With Solidity (2023)

23h 38m 36s
English
Paid

Ethereum Blockchain Developer Bootcamp With Solidity (2023) is a 194-lesson 23 hours 38 minutes self-paced course by Udemy. Learn how to build real smart contracts with simple steps and clear code.

Course facts

Lessons
194
Duration
23 hours 38 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

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

Who teaches Ethereum Blockchain Developer Bootcamp With Solidity (2023)? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Ethereum Blockchain Developer Bootcamp With Solidity (2023)?

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

What courses are similar to Ethereum Blockchain Developer Bootcamp With Solidity (2023)?

Frequently asked questions

What are the prerequisites for enrolling in this course?
To enroll in this course, you should have basic skills in JavaScript or HTML. Having a computer running Windows, Linux, or macOS is also essential. While not mandatory, familiarity with C++ or Java, Git, and some exposure to Solidity can be advantageous for a smoother learning experience.
What project will I build during the course?
Throughout the course, you will work on creating a Blockchain Notary application. This involves writing a smart contract, testing it, and deploying it across local, test, and public Ethereum networks. This project is designed to provide practical skills that are applicable in real-world Web3 development.
Who is the target audience for this course?
The course is aimed at developers who possess general coding skills but have no prior experience with Solidity. It is also suitable for individuals familiar with Ethereum but unsure where to start, as well as those who have written simple Solidity code and wish to enhance their skills. Additionally, anyone interested in understanding how blockchain technology works will benefit from this course.
What tools and platforms will I learn to use in this course?
The course covers various tools and platforms, including setting up and using Remix for smart contract development, and working with Metamask for Ethereum transactions. You'll also learn about Web3 tools and how to work with Truffle for local development. These tools are essential for building decentralized applications (DApps) and interacting with the Ethereum blockchain.
What is not covered in this course?
The course does not cover advanced topics in Ethereum development, such as in-depth security audits or complex financial instruments like DeFi protocols. It is focused on providing introductory knowledge and hands-on experience with basic Solidity and Ethereum tools, suitable for beginners and intermediate learners looking to build foundational skills.
How much time will I need to commit to complete the course?
The course comprises 194 lessons. While the exact runtime is not specified, prospective students should be prepared for a significant time commitment to go through all the lessons, complete hands-on tasks, and fully grasp the material. The pace of learning can vary based on individual familiarity with the prerequisites and related technologies.
How will the skills learned in this course apply to other careers?
Skills acquired from this course are highly transferable to careers in Web3 and blockchain development. Understanding Solidity and Ethereum tools can open opportunities in various roles, such as smart contract developer, blockchain engineer, or DApp developer. Additionally, learning to work with decentralized technologies can be beneficial in fields like finance, supply chain, and beyond, where blockchain solutions are increasingly adopted.