Ethereum Blockchain Developer Bootcamp With Solidity (2023)

23h 38m 36s
English
Paid

Course description

Do you want to be 'coding the smart contract revolution', but don't know where to start? Want to learn everything there is to know about solidity, with a 'learning by doing' approach? Are you interested in the 'big picture' of the blockchain industry, but often overwhelmed by it all? If so, this is the course for you! You will not only learn the fundamentals, but also the safe handling of solidity and the current industry best practices!

Read more about the course

Rather than boring theory, this course is a direct lab entry where we Learn By Doing!

Our digestible HD video lessons will provide you a step by step framework on how to create, test, troubleshoot, deploy to various networks, and Use Smart Contracts in various scenarios and browsers.

We will illustrate the creation of a blockchain application from a to z!

Together We Will Develop A Blockchain Notary Office, test it, and then deploy it to different networks.

The steps we will be taking to build our blockchain application are...

  1. Solidity Basics

  2. Key Characteristics Of How The Blockchain Operates

  3. Our Notary Functionality in Solidity

  4. Understanding Tools & Ethereum

  5. Your Guide To Web 3.0

  6. Tools Of Web 3.0

  7. Understand The Different Blockchain Nodes

  8. Understanding Decentralisation At A Deeper Level

  9. Local Development With Truffle

  10. How to Develop Distributed Applications In HTML & JavaScript

  11. Publication Of Our Project

Requirements:
  • Basic Knowledge In JavaScript / HTML.
  • A Computer (Windows / Linux / Mac).
  • Advantageous: Basic Knowledge In C ++ / Java, Data Types.
  • Advantageous: Basic Knowledge With Git Repositories.
  • Advantageous: Basic Knowledge Of Solidity.
Who this course is for:
  • People Who Already Have Some Experience With Programming In General, But No Solidity Experience.
  • People Who Have Heard Of Ethereum, But Do Not Know How or Where To Start.
  • People Who Want To Know How This Technology Works.
  • People Who Wrote Simple Solidity Programs, But Want To Have A Deeper Understanding Of The Subject.
  • If You Heard About Blockchain Development But You Are Overwhelmed With The Ecosystem then Join This Course!

What you'll learn:

  • Understand The Tools Needed To Create Smart Contracts.
  • Write & Read Secure Solidity Code.
  • Avoiding & Understanding Of Costly Bugs And Blockchain Programming Errors.
  • Understanding Of The Development & Deployment Workflow.
  • Better Understand Of The Benefits & Disadvantages of Blockchain Technologies.
  • Use And Create Private Networks, Test Networks And The Public Main Network.
  • Understand How Transactions Are Structured.
  • How Gas & Gas Costs Can Be Calculated Correctly.
  • Write A Smart Contract On The Ethereum Blockchain And Be Able To Publish And Interact With It.
  • Understand The Difference Between Web3js And Truffle-Contract.
  • Write Tests With The Truffle Framework That Contribute To The Stability Of Smart Contracts.
  • Install, Configure & Use The Truffle Framework.
  • Deploy To IPFS.

Watch Online

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

Watch Online Ethereum Blockchain Developer Bootcamp With Solidity (2023)

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Blockchain from scratch with GRPC and Protobuffers

Blockchain from scratch with GRPC and Protobuffers

Sources: Anthony GG
Learn the basics of blockchain from scratch by step-by-step creating your own system. You will master public and private key cryptography, working with...
4 hours 56 minutes 12 seconds
Golang: How to Build a Blockchain in Go Guide

Golang: How to Build a Blockchain in Go Guide

Sources: udemy
Learn how to build a blockchain from scratch with Go Programming Language (Golang). With the emergence of Facebook's cryptocurrency, Libra, companies like Amazon, Microsoft, and...
5 hours 24 minutes 9 seconds
Ultimate Telegram Mini App Clicker Game

Ultimate Telegram Mini App Clicker Game

Sources: Nikandr Surkov
Create engaging clicker games on Telegram with a powerful, ready-to-use template. Easily boost user engagement. Key features...
Ethereum and Solidity The Complete Developer's Guide1

Ethereum and Solidity The Complete Developer's Guide1

Sources: zerotomastery.io
Learn Solidity from scratch, from an industry expert. You'll learn Solidity fundamentals all the way to advanced blockchain technologies so that you'll be able
12 hours 56 minutes 12 seconds
Python - The Practical Guide

Python - The Practical Guide

Sources: udemy
This is a highly practice-oriented Python course that teaches you Python from scratch - no prior programming experience required! Python is probably THE most trending programmin...
16 hours 26 minutes 30 seconds