Solidity, Blockchain, and Smart Contract Course – Beginner to Expert Python Tutorial

hello everybody and welcome to the free

code camp blockchain and solidity

beginner to expert full course python

edition we're going to go through

everything you need to know for

developing on a blockchain using

solidity and engaging in the future of

finance we're going to cover topics that

will teach you all the skills you need

to become a smart contract expert that

you can take with you no matter which

blockchain you're developing on

blockchain engineers are in extreme

demand and they're building billion

dollar applications almost every day at

this point at the time of filming

protocols like ave yearn.finance and

synthetics have billions of dollars of

locked value in them allowing people to

engage in decentralized finance or defy

this allows people to make censorship

resistant moves and so much more some of

these protocols with billions of dollars

are even less than a year old so whether

or not you're brand new to this space or

you've been in here a while hi my name

is patrick collins and i live in the

smart contract world i'll be taking you

through your journey to becoming a

blockchain and smart contract expert a

little bit of background on myself i'm

an engineer and developer advocate on

the chain link protocol and i also have

my own blockchain infrastructure company

called alphachain where i run different

nodes and different infrastructure for

blockchains including one of the main

technologies we're going to be talking

about today which is ethereum i love

being a pioneer in the smart contract

ecosystem and i love taking new users

like yourself along to the journey with

us and we are going to teach you to

become a smart contract expert building

blockchain and solidity applications is

building a world of more trust and

accountability it means building a

financially free future and we get to be

the ones that will go down in the

history books as the pioneers of this

space additionally blockchain and smart

contract engineering skills are some of

the most sought after in the world with

an average salary of a solidity

developer being between 150 and 175 000

in this video we're going to teach you

how to become one of these developers

and go out into the world and

participate in the world of smart

contracts in the world of blockchain

this course is ideally for engineers who

know a little bit of python programming

and you can have any level of smart

contract engineering whether you're a

complete beginner to blockchains and you

don't even know what one is or you're an

advanced solidity engineer and you're

looking to learn more this is the

perfect place for you having a little

bit of experience in other

object-oriented programming language

like javascript as well will be helpful

here too and if you're brand new to

coding in general that's all right

because we're going to take you step by

step through everything if you do want a

little bit more in-depth python coding

video there is a fantastic free code

camp video in the description if you do

prefer javascript we will also be

releasing a javascript edition of this

video as well but everything that you

learn here will be applicable there and

if you watch both you'll learn even more

you can find the entire itinerary for

this entire course along with all of the

code associated with everything that we

do and additionally discussions and

support and everything else in this

smart contract kit

full blockchain solidity course pi

github repository it has a table of

contents and then the entire itinerary

of everything that we're going to go

over in this course and like i said with

helpful tips resources for getting

support and resources for getting help

now for your convenience every single

piece of code that we're going to go

over in this video has a github

repository associated with it so be sure

to grab the link in the description grab

that github repository and look through

all the different repos that we're going

to give you if you ever get lost or need

to refer to some code or want to copy

paste some code all of it will be there

for you it'll also be a great place to

reference in the future when you're

working on some project and you want to

remember how to do something so be sure

to start and refer back to it as you

watch this video so let's talk a little

bit about some best practices for

watching this video this space moves

really quickly so if we show you some

documentation it might be a good idea

for you to open that documentation up as

well read through it as we do so you can

stay up to speed now we've packed a ton

of information in this video and studies

have shown if you try to digest a

massive amount of information in a short

period of time your retention isn't as

good so it's highly recommended that

every 25 minutes to half an hour you

take a five minute break and then every

two hours maybe you take an additional

30 minute or an hour long break you can

pause bookmark areas and come back later

and learn at your own speed there are

timestamps in the description that will

help you come back to where you left off

and you don't even have to go in order

if you want to bounce around from topic

to topic you're absolutely free to do so

we're also going to get really technical

with the fundamentals of blockchain and

if you want to just jump right into

solidity you can jump down the

timestamps below and get right into it

and if you're watching this on youtube

you can adjust the speed that i talk and

then i give this presentation so if i'm

talking way too quickly for you you can

slow it down or if i'm talking too

slowly for you you can have me speed up

so be sure to set me at the pace that

you like best you are highly encouraged

to pause come back and ask questions the

blockchain in smart contract world is a

very collaborative community so if you

have questions some of the best places

that you can go going to stack overflow

and tagging your question with the

specific technologies that you're

working on make an issue on the github

repo that we're working with go to stack

exchange eth and make a question there

as well jump into the discord of the

technology that you're working with or

even on github discussions if those are

there learning to become a blockchain

and solidity engineer is actually a lot

more than just learning solidity

becoming comfortable with all the tools

in the space is going to be just as

essential as becoming familiar with

solidity itself and continuing the

conversation on maybe twitter or reddit

or any of these other channels and maybe

even showing your stuff in the next

ethereum or chainlink hackathon are

going to be majorly beneficial to

increasing your skill as an engineer

now before we get actually coding a lot

of people want to understand what is

actually happening with all this

blockchain stuff what is blockchain what

is a smart contract how did this all get

started and understanding these core

fundamentals will actually shape the way

you code and architect your smart

contract applications so learning these

is really really critical

however if you're already familiar with

blockchain and you just want to jump

into the solidity feel free to grab a

timestamp from the description and jump

to that section

now since you're here though you've

probably heard of bitcoin before bitcoin

was one of the first protocols to use

this revolutionary technology called

blockchain the bitcoin whitepaper was

released by the pseudo-anonymous satoshi

nakamoto and it outlined how bitcoin

could be used to make peer-to-peer

transactions in a decentralized network

this network is powered by cryptography

and allows people to engage in

censorship resistant finance in a

decentralized manner due to some of the

features of bitcoin a lot of people took

it to be as a superior store of value

over another asset like let's say gold

and that's why it's commonly referred to

as digital gold similar to gold there is

a scarce and set amount of it on the

planet and people use it to buy and sell

similar to other assets you can read

more about the original vision in the

white paper and there's a link to it in

the description

now this was a fantastic breakthrough

and in a little bit we're actually going

to look through how blockchains can

actually work and how all of this is

possible but some people took this and

saw this technology and thought that

they could do even more a few years

later a man named metallic buterin

released a white paper describing a new

protocol called ethereum which used this

same blockchain infrastructure but

with an additional feature and in 2015

they released this project called

ethereum him and a number of other

co-founders took this blockchain

technology and applied it in ways that

people can make entirely decentralized

applications decentralize organizations

and build smart contracts and engage in

agreements without a third-party

intermediary or centralized governing

force their idea was to take the same

pieces that made bitcoin great and add

smart contracts to it and in fact this

technically wasn't even a new idea back

in 1994 a man named nick zabo proposed a

technology called smart contracts a

smart contract is a self-executing set

of instructions that is executed without

a third party intermediary they come to

life on a blockchain and these smart

contracts are really going to be the

core thing that we're going to be

working with and we're going to be

developing smart contracts are similar

to regular traditional contracts that

people make between each other but

instead of writing these contracts down

on pen and paper or typing that on the

computer it's entirely written in code

the terms of the agreement are written

in code and automatically executed by

the decentralized blockchain network

instead of being written pen and paper

and executed by the two parties or three

parties or however many parties involved

this is one of the main differentiators

between the ethereum protocol and the

bitcoin protocol now technically bitcoin

does also have smart contracts however

they're not touring complete meaning

that they don't have the full range of

capabilities as a turing complete

application like ethereum this is

actually an intentional move by the

bitcoin developers they view the bitcoin

network as an asset whereas ethereum and

the ethereum and developers viewed that

acid as an asset and also a utility for

people to build these smart contracts

now these smart contracts are

revolutionary technologies and we're

going to talk a little bit more about

what their advantage is in a little bit

but they actually come with a fatal flaw

with what's known as the oracle problem

these blockchains are deterministic

systems and we'll learn why they're

deterministic very soon and this

determinism means that they're a walled

garden meaning that everything that

happens in these smart contracts and on

this blockchain happens in this little

box now of course if you want these

smart contracts to actually be these

digital superior agreements then they

need some way to interact with the real

world and get real data and external

outside the blockchain computation this

is where oracles come into play oracles

are devices that bring data into a

blockchain or

execute some type of external

computation so great so oracles are the

solution now blockchains can talk to the

real world right

well not quite our blockchains and smart

contracts are these decentralized

applications and in order for them to

stay decentralized that means they would

also need to get their data and external

computation from a decentralized manner

as well your on-chain logic will be

decentralized on the blockchain but

you'll also need your off-chain data and

external computation decentralized as

well combining these on-chain logic

settlement layers and these off-chain

data and external computation

builds what's called hybrid smart

contracts and a large majority of d5

applications in the largest applications

today are these hybrid smart contracts

this is where the protocol chain link

comes into play chain link is a

decentralized modular oracle network

that allows you to bring data into your

smart contracts and do external

computation and it's these hybrid smart

contracts that can have this on-chain

settlement and interact with the real

world in some meaningful way chain link

is an incredibly powerful oracle network

because it allows us to get data get

randomness do some type of upkeep or

really customize our smart contracts in

any way we want and elevate them to do

anything that we want them to do now

throughout the course when we're talking

about smart contracts oftentimes we are

also talking about hybrid smart

contracts smart contracts is used a

little bit interchangeably with hybrid

smart contracts but just know that when

we say hybrid smart contract we're

talking specifically about smart

contracts with an off chain component

now throughout this video you'll hear

people say smart contract you'll hear

people say decentralized protocol

decentralized application or dap and

they kind of all are a little bit

interchangeable a decentralized

application is usually a combination of

several smart contracts

and when we start coding some solidity

you'll see what a singular smart

contract or singular contract looks like

smart contracts are going to be what we

code write and deploy for the majority

of this video and learning some of these

fundamental concepts will allow us to be

better smart contract and better

solidity developers now since its

inception the ethereum protocol has

given rise to many new paradigms and

industries including d5 nfts

dows or decentralized autonomous

organizations

layer twos and so much more

and a couple of other protocols have

taken this ethereum vision and gone in a

different direction with it like polygon

polka dot or avalanche if we learn the

core basics of smart contract

development on the ethereum platform all

these skills translate to these other

chains as well so don't worry about

learning a specific tool or chain

because most of them work together

pretty seamlessly

now there are a few exceptions to this

rule and there are some smart contract

platforms aka blockchains that don't use

solidity however learning the

fundamental skills here will still

translate to every single other

blockchain

and ethereum is by far the most popular

and most used smart contract blockchain

or smart contract protocol you'll also

hear those words used a little

interchangeably as well sometimes i'll

say blockchain or sometimes i'll say

smart contract platform smart contract

protocol and the like similarly chain

link is the most popular and powerful

decentralized oracle network and is

going to be the one that we're going to

focus on here chain link is also

blockchain and smart contract platform

agnostic meaning it'll work on ethereum

avalanche polygon polka or really any

blockchain or smart contract platform

out there

even in this introduction we've already

learned a lot so let's do a quick

summary of what we've talked about

bitcoin was the first application to

take the blockchain technology into the

limelight and into a meaningful way

bitcoin is a sort of digital gold able

to make transactions between users as

almost a sort of currency ethereum takes

this blockchain technology one step

further but you can also build smart

contract or decentralized applications

decentralized autonomous organizations

and more because you can code with smart

contracts these smart contracts can then

access external data and external

computation outside the blockchain using

what's called oracles chain link is the

most powerful decentralized oracle

network and allows us to build these

hybrid smart contracts which is a

combination of decentralized on-chain

logic settlement layer and any

decentralized external off-chain data or

computation hybrid smart contracts and

smart contracts are often used

interchangeably now you're probably

asking yourself a lot of questions right

now like what makes bitcoin so

interesting what makes it like a digital

gold and how are these smart contracts

going to add any value to the real world

and that's what we're going to go into

now so before we get into the

nitty-gritty of how these blockchains

and how these smart contracts actually

work from a low level let's go

high level and talk about some of the

features and massive advantages that

blockchains and smart contracts have

over our traditional environments the

first feature that these have is they

are decentralized and you'll hear this

term used a lot because it has a massive

benefit blockchains are decentralized

meaning there's no centralized source

that controls the blockchain the

individuals that make up blockchain are

known as node operators and they are the

independent individuals running the

software that connects the whole

blockchain together it's all these

different independent individuals that

make the blockchain and blockchain like

networks decentralized we'll dive deeper

into that concept later great example of

why this is so fundamentally

groundbreaking is if we go back to what

happened recently even with robinhood

and gamestop gamestop shares were no

longer allowed to be bought because a

centralized entity didn't want them to

be bought anymore so they

flipped a switch and nobody could buy

that stock anymore essentially having a

single entity controlling the entire

financial market the fact that a single

entity has the power to make these

choices for us is a travesty and

blockchain is here to solve that there's

a narrative here called the bankless

narrative where users can actually live

in a world where they don't have a bank

banks while good in their own right have

a history of doing some shady things

they also have the power to potentially

freeze your funds not letting you

withdraw or move or do anything because

they are a centralized entity that again

can

flip a switch and control how you

interact with your life every day being

free of these centralized entities have

this much power and this much control

over your life has widespread positive

ramifications transparency and

flexibility

everything that's done on a blockchain

and all the rules that are made can be

seen by everyone there's no backdoor

deals there's no shady happenings

everything that happens on chain you can

see this means that there's no special

information that a few have

everyone has to play by the same rules

and everyone can see exactly what those

rules are

now additionally this doesn't mean that

everything you do is tracked the

blockchain is pseudo-anonymous so you

can create different accounts and you

can interact with it in many different

ways this leads me to my freedom point

but i'll get there in a second speed and

efficiency have you ever tried to make a

withdrawal from the bank and it took

three to five days

all the bank is doing is adding and

subtracting numbers

basic first grade math

so why does it take so long because

blockchains are verified by a

decentralized collective the settlement

or withdrawal period in this case is

substantially faster and depending on

the blockchain that you're using it can

be from

10 minutes all the way down to just a

couple of seconds in the stock trading

or hedge fund world it can actually take

up to a week for your buy or sell of a

stock to go through security and

immutability blockchains are immutable

which means they can't be changed and

because of this it means that they can't

be tampered with or corrupted in any way

shape or form this allows us to have

massive security on our data on our

transactions and anything of the like if

your computer goes down and your backup

computers go down

in the regular world your data is gone

if all your data is on those two

computers you're out of luck on a

blockchain if several nodes go down it

doesn't matter because as long as one

node and the entire system is running

the data is safe and secure there are

thousands or hundreds of thousands of

nodes running these blockchain softwares

meaning that everything that happens

happens and is immutable and won't

change

hacking the blockchain is nearly

impossible and substantially harder than

hacking a centralized entity and this is

also much more secure in the asset sense

as well instead of having gold in a

vault or contract written on a piece of

paper or on your computer you have a

asset that is

locked on the blockchain forever and all

you need to do to access it is have a

private key or mnemonic

which is essentially a password so you

don't have to lug your gold around or

lug your contracts around with you it is

always on the blockchain smart contracts

in particular remove a massive conflict

of interest in the traditional world

when we engage with users or individuals

they don't always have our best

interests at heart

a lot of them are usually self-motivated

in some sense and there's nothing wrong

with that that's how a lot of people are

however when we make an agreement with

them this agreement can have a massive

conflict of interest with the user who's

supposed to execute that agreement

let's take insurance for example if i

pay an insurance provider 100 a month

i'm paying them a hundred dollars and in

the event that i get hit by a bus we've

made an agreement or a contract that

they're going to pay my medical bills or

bail me out however they have this

massive conflict of interest insurance

companies aren't in the business of

giving out money they're in the business

of making money so even though they've

signed this agreement when this event

occurs they still don't want to pay this

money out to me and if they can find a

loophole in the contract they will

because that is what they are motivated

to do so they sign this agreement but

it's not in their best interest to do so

so they have this massive conflict of

interest and this is native in all of

the agreements that we make today they

are the ones who decides whether or not

they're going to execute their agreement

giving execution power to the party that

doesn't want to execute something has

often led to frustration now the

follow-up is you can always sue them and

go through this process but now you're

wasting all this time going through this

long process to get something that you

should have originally gotten in the

first place

this leads me to one of the biggest

value adds to smart contracts smart

contracts allow us to engage in

trustless and trust minimized agreements

we currently live in a world of

brand-based agreements

if i engage in some agreement and i

don't like the service that i'm provided

my alternative to this is to waltz down

the street to another brand to another

service who's going to make the exact

same set of promises to me and then i

have to trust them that they're going to

execute faithfully smart contracts allow

us to move from this brand based

agreements to

math-based agreements these math-based

agreements we don't even have to trust

that they're going to do the right thing

hence the name trustless one plus one is

always going to equal two in a math

world whatever the code determines is

the input output that's exactly what's

gonna happen every single time

now for me these really all add up to

two major pieces

freedom

and trustless all these pieces allow us

to live in a world that's more

accountable more trusting more friendly

and

just better it allows us to work in an

environment and a universe where things

just

work

it allows us to do the freedom to engage

with other people how we wish because

there's no centralized controlling body

influencing every action that we make

all the rules are the same and nobody's

getting special treatment

this brings out this new world of

economic opportunity as well and as our

lives become more and more digital we're

constantly being bombarded with

centralized services that want us to use

their interface so they can profit on

how we interact and force us or push us

to making the decisions that they're

motivated for us to make smart contracts

decentralized applications and

blockchain

allows us to be free of these repressors

and live in an environment that's truly

free and trustless

so with all that high level being said

let's do a quick summary of what we just

learned blockchains are decentralized

meaning that they are not controlled by

a single centralized entity it is run by

a network of independent users

transparency blockchains are transparent

everything that happens on a blockchain

everybody else can see and everybody

else can work with and see that

everyone's playing by the same rules

blockchains are quick and efficient

especially when it comes to monetary

policy settlement on blockchains are

fast and easy immutability and security

blockchains can't be changed or tampered

with or corrupted and are incredibly

incredibly secure smart contracts remove

the massive conflict of interest

traditional agreements have smart

contracts allow us to move away from

political brand-based agreements to

secure

math-based agreements smart contracts

allow us to engage in trustless and

trust minimized agreements

smart contracts are a set of

instructions which when placed on a

blockchain are self-executing pieces of

code not run by any centralized

intermediary in addition smart contracts

are typically paired with some type of

oracle to get some information about the

real world when smart contracts are

paired with an oracle they're called

hybrid smart contracts chain link is a

secure decentralized modular oracle

network used to bring data into your

smart contracts and also make some type

of external computation i also briefly

want to mention dao's or decentralized

autonomous organizations you'll hear

this referred to a lot as well

decentralized autonomous organizations

are organizations that live online and

live in these smart contracts they're

similar to a regular organization in the

traditional world however they have

people who maybe hold governance tokens

to make voting decisions or they do all

their governance on chain

on this decentralized settlement layer

giving us the freedom to engage with

each other as we please

so now that we've taken our first dive

into blockchains and smart contracts and

at least from a high level understood

why they're so advantageous let's jump

in let's get an ethereum wallet and

let's make our first transaction on a

live blockchain are you ready now let's

jump into ethereum we're going to make

our first interaction with the ethereum

blockchain and once we do this

interaction once we make this

transaction

then we're going to go back and look at

what actually happened what were the

technical implications that allowed this

transaction to go through so in order

for us to interact with the blockchain

the first thing that we're going to need

is an ethereum wallet

so i'm going to go ahead and go to

metamask because it's one of the most

popular wallets and one of the easiest

to use we're going to go ahead and

download it

i'm using the brave browser but it works

for chrome firefox or really any other

browsers

and it's just going to be a little

extension in the top right hand

of your browser

this way we can really easily see at any

time what we have in our wallet

this will store all of our ethereum

based currencies

so i'm going to go ahead and install

metamask for brave

add to brave

add extension

and now we can go ahead and get started

with working with brave this is the

first step you absolutely need to take

when starting your journey and one of

the easiest steps to take so we're going

to go ahead and get started

and we're going to create a brand new

wallet so we're going to go ahead and

hit create wallet

if you already have a wallet you can

actually import it via i have a seed

phrase and we'll talk about the seed

phrase or secret phrase in a little bit

so let's go ahead and create a new

wallet

and sure we'll agree to help out

metamask now we will create our password

make sure that this is really secure

for the purpose of this demo my

passwords are just gonna be password but

please don't have that be a password now

when i'm doing my testing when i'm doing

my coding i actually use a separate

account from the account that i actually

have real money in however if you want

to use this account and actually put

real ethereum and put real money into it

you absolutely 100

need to back this up so we're gonna go

ahead and click reveal secret words i'm

showing you guys here because

uh this is just a demo and i don't

really care however if you show this

secret phrase to anybody else they will

have access to

all funds

so everything that we're gonna do in

this tutorial we're gonna use fake money

we're gonna use not real money so it

doesn't matter however if you're going

to actually put money in here you

absolutely need to have this written

down because if you lose access to this

and or your private keys which we'll

talk about in a little bit you will lose

access to your wallet and you will lose

access to all your funds

so they give some tips like store this

phrase and a password manager like one

password write this phrase down on a

piece of paper put it in a secure

location memorize it whatever you want

to do just make sure you have this

backed up somewhere

i'm just going to go ahead and hit

download this for now and i'm going to

save it on my computer it's not best

practice to save to your computer it is

much better to use a password manager or

write it down on a piece of paper or

something

but again because we're just demoing

here

i'm going to show you it here and we're

not going to put any real funds into

this

so we're going to go ahead and hit next

and we're it's going to ask us to

make sure we and it's going to ask us to

verify that we actually have it written

down

and we're gonna go ahead and hit confirm

and great and it gives us a couple other

tips remember definitely take these tips

very seriously especially if you're

gonna use this for real money like i

said for this demo we're just gonna use

test money so it's not as big of a deal

but if you put real money in you

absolutely need to back up this seed

phrase or secret phrase or we're going

to refer to it as our mnemonic phrase

awesome now we can see the user

interface of this wallet

and depending on your browser if you

actually go ahead and look in your

extensions you can pin it to your

browser and you can even just click it

and get the same interface here let's

take some inventory of what is actually

going on in here and what we actually

have our mnemonic phrase that secret

phrase that we got

has given us access to a new account and

here's the address of our account we can

use a tool like etherscan to view

different addresses and what's been

going on with them so if we look at this

address that we just created on

etherscan we can see that no

transactions have happened it's empty it

has zero ether in it it has zero dollars

worth of value in it and this address

here

is our unique address this address

represents

exclusively this single account that we

just created we'll talk a little bit

more about etherscan in a bit as it's a

tool that we're going to use more and

more now we can even click this

circle here and we can even create more

accounts and give it a different account

name

we'll call it account 2.

this one has a different address so if

we go ahead go back to etherscan and

look this up this one has a different

address here

so we can have multiple addresses in

here and now if i click this i have two

accounts account one

and account two

the mnemonic that we've been given

gives us access to create multiple

accounts with that same mnemonic so

having that mnemonic will give us access

to every single account that's ever

created with that mnemonic this is why

securing your mnemonic is so crucial

especially if you create multiple

different accounts

now each account

has a unique identifier with them as

well so so this right here is the public

address when we copy this this is the

public address of that account

however there's also a private key to

work with this account a secret key

and we can go ahead and view it by

clicking these three dots go to account

details and export private key

put our password in and confirm

so this is going to be our private key

so this is a single

password associated with this account if

you give somebody else access to this

private key they will have access to my

account too they won't have access to my

account one because the private key of

account two is only associated with

account two the mnemonic however is

associated with all accounts and this is

why when people say store your private

keys in a safe place or store your keys

in a safe face they're usually referring

to both your mnemonic and your private

keys

if you lose your private key you lose

access to this account if you lose your

mnemonic you lose access to all your

accounts so long story short back up

your mnemonic since it has access to

everything and back up your private keys

too but just keep in mind they only have

access to the individual accounts and

great those are some of the main

security pieces here

now what else is going on in metamask is

we can see this section here that says

ethereum mainnet if we click it we

actually see a bunch of other networks

in here

so when you buy eth and when you work

with eth you're working on the ethereum

mainnet when you interact with smart

contracts or d5 or any things that we're

going to talk about later on mainnet

with real value you're going to be

working on the mainnet

however since we're engineers oftentimes

we're going to want to test our

applications or do some type of

integration tests or just make sure our

code actually works

so there's also what's called test nets

these are networks that resemble

ethereum and work exactly the same way

as ethereum does

however they're not with real money and

it's just for testing your applications

so we can even go to ether scan and look

up

brinkp ether scan

we can see the rink be test on explorer

we look up at our address and it's the

exact same

information here

nothing has gone on on rink b and this

is totally different so when we make a

transaction these are all different

networks and it says test network it's

made to be made without real money later

on we're actually going to show you how

to work with other evm compatible chains

don't worry about what evm compatible

means for now but we can work with

avalanche polygon and other applications

through this networks interface as well

so remember a testnet blockchain is a

blockchain where the currency doesn't

have any real value but it resembles and

acts exactly like the ethereum mainnet

so we can test our applications

so we can test and practice our

applications

in fact what we're going to do right now

is make our first transaction on the

rink b test net and this will simulate

exactly what it's like to make a

transaction on the ethereum mainnet so

we're going to go to this application

called the rink b faucet this is where

we're going to make our first

transaction ring b is going to be one of

two test nets that we're actually going

to work with the other test net that

we're going to work with is going to be

coven it's important to know how to

switch between test nets and evm

compatible chains which is why we're

going to be working with both for now

we're just going to be working with rink

b

a faucet is a tested application that

gives us free test ethereum hence why it

has no value because anybody can get it

for free from one of these faucets so to

get tested ethereum with this

application we actually have to post a

tweet or a facebook post

with this tweet so i'm actually going to

i'm going to sign in real quick

and now that i'm signed in i can post

this tweet requesting faucet funds into

and this is where i'm going to put my

address

on the rinkby ethereum test network i'm

going to go ahead and tweet that out

now that i have this

we're gonna copy link to tweet

and we're gonna place it in here and

we're gonna hit give me ether and we're

gonna say 18.75 ether for three days and

it said funding request accepted for

patrick alpha c

into this

and what we can do then

is if we take this address again

we go over to rink b ether scan

we now see that the balance is 18.75

and we can even see that

in our wallet on the ringbeat network we

have 18.75 eth but again if we look at

mainnet we have nothing there if we look

at robson we have nothing there if we

look at rink b we have 18.75 right so

these are very different networks and

we've just made our first transaction

we've been given

18.75 eth and if we refresh this page we

also see that this is our first

transaction that was made

some account sent us 18.75 ether

from

this account to us and we can actually

even look at the details of this

transaction

etherscan is what's known as a block

explorer block explorers are

applications that allow us to see

details of things that happen on a

blockchain easily we can see the

transaction details of this transaction

here and whenever we work with smart

contracts we will also see them in a

transaction similar to what we're seeing

right here and again we'll talk about

that soon now we can see a number of

information here we see a unique

transaction hash this hash or this

unique identifier uniquely identifies

this transaction

as the key of what this transaction is

we see that it was a successful

transaction this is the block number

which we'll talk about in a little bit

we see it was from this unique account

which looks like they did a ton of

transactions because this is the faucet

account

to our account that we created

value was 18.75 ether

and then we have these transaction fees

gas price gas limit and gas used now gas

refers to the fee paid to node operators

for successfully including a transaction

in a blockchain

now exactly how this works is actually

going to change pretty soon but the

concept is basically anytime you want to

change the state of blockchain whether

this is sending some ethereum or making

any type of transaction

you actually have to pay a little bit of

ethereum or a little bit of that native

blockchain token to actually execute

that transaction whenever we do

something on the blockchain

it costs gas and if we do something that

would take a lot of energy for the

blockchain to do it will cost more gas

so if i send a single transaction that's

going to cost 21 000 gas however if i

were to do if i were to send a

transaction that called the smart

contract function and did a whole bunch

of other stuff it would cost more gas so

we see here when we got sent

18.75 eth whoever sent us that eth also

paid the blockchain miners or the

blockchain validators a little bit of

ethereum to include our transaction now

we actually get to pick how much of a

fee we want to send with our

transactions so let's look at another

example so

in our accounts in metamask let's even

expand the view here

we have two different accounts we have

account one and account two account one

has 18.75 account two has zero

we can actually send money from account

one to account two and again remember

this is all fake money so so we're gonna

go ahead and hit transfer between my

accounts so we're gonna send money to

account two

and here's where we can see some

transaction details and we see the asset

that we're going to send which we only

have ethereum in this wallet so we're

only going to send ethereum later on

we'll learn how to get different assets

into this wallet we're going to choose

an amount i'm just going to choose to

send one and then we have these pieces

here

associated with the transaction fee so

we have a gas price in guay and a gas

limit so when we send a transaction we

can choose a gas limit we can say hey if

this transaction is going to spend more

gas than

21 000 gas we're not going to do it

we also get to set a gas price in guay

but here's the quick example of guay

versus ethereum

[Music]

one ether is

this many gray

and one gray is this much ether because

if we just said hey could you send me

.00001

that would be

kind of really obnoxious so we just just

say send me one way or send me one way

so i know we've been throwing this gas

term around for a little bit but here is

it basically simplified gas is going to

be the measurement of how much

computation something uses the gas price

is going to be how much it costs per

unit of gas a gas limit is going to be

the maximum amount of gas that can be

used in transaction so for example if we

make a transaction that uses 21 000 gas

and each one gas is one way

in price that means we're going to pay

21 000 way

in transaction fee

so back in our transaction we have we're

saying the gas price

is going to be one way so the

transaction fee is going to be the gas

that we use which will be up to this gas

amount

times the gas price so it'll be 21 000

way will be the transaction fee so then

the question is well why would we ever

bump it up why would we want to pay more

gas price why do i even have the option

to pay more well and this comes down to

block space we'll talk about this a

little bit more when we get into how the

blockchain actually works but the

blockchain can only

process so many transactions at a time

and nodes and blockchain nodes can only

process so many at a time so when i make

a transaction a node has to decide why

they want to include my transaction into

the block and if there are a ton of

people

looking to make these transactions then

the nodes are going to be highly

incentivized to pick the transactions

that are going to give them a high price

that are going to give them a lot of

money for including that transaction

so this is what's called eath gas

station and it is a a gas estimator of

the blockchain it currently says that if

you want to get your

transaction in right away it's going to

cost you 31 way to do so if you want to

get it in less than five minutes it's

going to take you maybe about 21 gway

so the gas prices of ethereum fluctuate

with how much people use it and the gas

prices of all these blockchains

fluctuate with how much people use it

so this is an important concept so

typically when you're setting your gas

price in a transaction you can take a

look-see at you know gas station and say

okay if i want mine to go in right away

i'm going to do asap if i want to go in

fast maybe i'll do you know this fast

amount standard i'll do this standard

amount but it all depends on how many

people are looking to work with this

blockchain at the same time and and as

you can see it fluctuates pretty quickly

right it just went all the way up to 46

so maybe more people are using the

blockchain now this is obviously for the

eth main net and on the test net there's

not going to be that same competition

but we can still change it anyway so if

i go ahead and do 100 for the gas price

and i hit next and i hit confirm if i go

to activity

i now have

this transaction

in my

metamask but i can go ahead and view

this on etherscan as well

and we can see this is what it looks

like when it's still processing this

transaction and now we can see that it's

passed and now if we look at the gas

price we see it's a hundred gray and

this is what we set it as when we were

working with it before so gas prices 100

way here versus our first original

transaction was just one way

now if we look at our metamask we can

see that

the funds have indeed been

subtracted from this account and they

have been added to this account now

there's one eighth in this account

awesome and you can see the activity

there's one ethan here so again the

reason that these gas prices exist is

because nodes can only put so many

transactions into a block so they're

highly incentivized to input the

transactions that are going to give them

a higher fee so in times when a lot of

people are looking to use a blockchain

prices will get very high and when very

few people are using a blockchain prices

will be very low this ether scan tool is

incredibly incredibly powerful and we'll

be using it more and more as time goes

on now here's something that's

incredibly exciting with just this

little bit of information you now know

how to interact with blockchains and

interact with the ethereum protocol so

if you don't want to learn how to code

anything you can go and you can start

interacting with ethereum and interact

with protocols with just this much

information however i know most of you

guys are here to learn how to code so

let's look under the hood of ethereum

and what is actually going on with these

transactions

and with these gas and with these

blockchains and what's really going on

let's learn all the fundamentals of a

blockchain now if you want to just go

ahead and jump into the coding go ahead

and grab a timestamp from the

description however learning exactly how

the blockchain works is going to make

you an incredibly powerful developer so

let's take a look at that first so we're

going to be going through this

blockchain demo on this site right here

now the creator of the site has a

fantastic video and a fantastic

walkthrough blockchain 101 it is right

on their site so if you're looking for

another explanation definitely check out

his video it is absolutely fantastic but

the first thing that we really need to

do in order to understand blockchain in

order to find really anything and

everything that's going on here we first

really need to understand this shot 256

hash or hashing just kind of in general

let's first understand what a hash is a

hash is a unique fixed length string

meant to identify any piece of data they

are created by putting some piece of

data into a hash function

in this example

the hashing algorithm used is sha256 now

ethereum actually uses this this right

here for its hashing algorithm which

isn't quite um sha256 but is in kind of

this shaw family but it's it's really

just another way to hash things and uh

the specific hash algorithm doesn't

matter uh so much so uh this example

uses sha-256 but you can imagine it's

the same as the ethereum hash they're

just gonna you know result in a

different hash

so what's going to happen in this

application here is whatever

data or whatever information we put into

this data section here as you can see

below this hash

changes

so what's happening is this data is

running through the sha 256 hash

algorithm and it's outputting this

unique hash so this

hash is a unique fixed length string

that's going to identify like a blank

data piece here right so if i put in you

know my name like you know patrick

collins

this is the hash that's going to

represent patrick collins right and you

can see

even when i put you know tons and tons

of data in here the length of the string

doesn't change

right

so it's always going to be the same

amount we can put

almost any amount of data in here there

is an upper limit on the max size of the

data but for all intents and purposes we

can pretty much put any length in here

and you'll see too that you know every

time i type in patrick collins

this hash is always going to be this

7e5b right i'm going to delete i'm going

to do

patrick collins again

you know seven e5b it's always this this

unique hash is always going to be

unique right it's always gonna be this

fixed length string here so now we can

take this idea right of putting this

data in here and we can move on to

uh this concept of a block so with this

block concept we're going to take the

exact same thing with this hash this

this data section right but instead of

having everything just being this this

singular data area right here we're

going to split this data up into block

nuns and data so all so what we're going

to do is we're actually going to hash

all three of these to get to get this

hash right we're going to put all three

of these we're going to say all three of

these are combined uh together we're

going to put every all three of them

into this hashing algorithm uh to figure

it out so if i type a bunch of stuff

here

we can see that block one

with nuns you know this nonce and this

data we're gonna get this hash and as

you can see actually

the screen turns red this block turned

red now

what happens when i hit this mine button

when i hit this mine button it's

actually going to take some time it's

going to think for a little bit and we

can see that the nuns here actually

changed right the nuns is different from

what it was before and

this hash now starts with four zeros

okay and then it the the back turned

green when we're talking about mining

we're talking about miners solving some

type of very difficult problem that

takes a lot of time to do now in this

example here the problem that the miners

had to solve was they had to find a nuns

or or a value in this nun section that

when hashed with at block number one

with this data

it would start with four zeros

so the problem here the miners had to

solve was to start with four zeros and

the only way for them to really do that

is kind of this brute force you know

trying stuff so they tried one okay one

didn't work okay two nope two didn't

work three no four or five six okay five

well that started with one zero but it's

not four and they have to keep trying

all these numbers until they uh get to

this one where you know let's hit mine

again

where it has four zeros at the top at

the start

now

this specific problem changes blockchain

to blockchain right ethereum has a

different problem for miners to solve um

bitcoin has different problems for minor

itself but this concept is going to be

the same

so they have to take

one block is going to be this

uh this concept is going to be all this

data it's going to be the block number

and it's going to be this nunce right

and so this nunce is the solution um is

is going to be the the number that they

use to get like the solution to the

problem right so if i go to one

here you know when i do this again

i'm gonna hit mine

and the nuns has changed right it went

from one to

thirty three thousand one hundred and

twenty eight because this is the nuns

that allowed this hash to start with

four zeros and so that's what's

happening

when uh blockchain miners are mining

they're going through this process this

very computationally intensive process

of trying to find a nuns that fulfills

whatever the problem is so that's really

it actually so that's a block and that's

really what's happening when miners are

mining they're just looking there's

trial and error brute force trying to

find this nut so so now that we know

what a block is let's go to the next

step and figure out okay well what's a

block chain so here we have an example

of what a block chain is going to look

like right we have a combination you

know we have back here in the block

section we have one what one block looks

like now here we have multiple different

blocks right each one of these

represents a different block but we have

an additional column here or we have

additional uh variable here so like

before you know we have block nuns and

data

right we have block nun's data but we

also have this thing called previous

right and so this is actually pointing

to the previous hash of the last block

so for example if we go to the the last

block in this blockchain it says

previous is 008 and if we look at the

hash of block number four it's zero zero

zero zero eight e eight and then we look

at its previous it's uh four zeros b9 we

have four zeros b9 and so on all the way

back to our first block which has

previous of just all zeros right and so

the block with the previous of all zeros

is going to be known as the genesis

block so you've probably heard that

before the genesis block it's the first

block in the blockchain where the

previous hash points to a hash that

doesn't actually exist now as you can

imagine kind of the same as how this

block worked how the block nuns and data

all go through the hashing algorithm in

the blockchain the block nuns data and

previous hash all go through this

hashing algorithm to figure out you know

what the hash is okay so if we go to

over here you know for example if i type

in you know patrick

obviously this is now no longer valid

right because this nuns uh combined with

the block the data and the previous hash

aren't gonna solve you know our problem

of having four zeros at the start right

so i'm going to go and fix that and and

that's that's kind of an easy way to see

it being broken but

but let's take a look if i break

this block right here what happens if i

if i break the data in here if i do like

trick in here you can see that both of

these

are now red both of these are now

invalid right because the block hashed

with the nuns hash with the new data

which is my name patrick has worked

hashed with the previous block

is now a brand new hash right and this

block

is still pointing to this previous hash

right here right it's pointing to this

previous block and now it is wrong and

it is messed up and now um and now it's

nuns with this previous hash is also

wrong

right and this is where when we talk

about uh blockchains being immutable

this is exactly how it's immutable right

because if i go back and i change

anything you know if i've just

typed a right here the entire blockchain

is now invalidated because none of these

are going to have

nunses that solve this equation anymore

so this is why blockchains are immutable

is because anytime you change one thing

you ruin the rest of the blockchain okay

so however though you know if if an a

was here originally we can go ahead and

mine these

we can mine all these but as you can see

you know this is going to start getting

very

computationally expensive

because i have to go redo basically the

entire blockchain

and the farther and farther down the

line you get the harder and harder it

becomes to you know rehash and redo all

these different blockchains here now

this makes a lot of sense right so we

have this blockchain it's really hard to

change something in the past but if we

do we can just go ahead and remind it

now if i'm the one who controls the

blockchain right if i'm the one who

controls this you know and i want to

change something in the past well okay

great all i got to do is change this

data here and then you know mine each

one of these and you know obviously it's

going to be very computationally

expensive but it's something that i can

do right if i'm the one who owns the

blockchain

now here's where the decentralized

nature or the distributed nature really

uh makes it incredibly powerful so we're

gonna go to the distributed tab here

which i also refer to as the

decentralized tab here

it's going to show us what a blockchain

looks like

in a decentralized manner so we have

this exact same initial setup here we

have distributed blockchain we have you

know our first block chain which is kind

of exactly as the one from here but we

also have

more than one so we have peer a peer b

and peer c and when people are talking

about peer to peer appear to be your

transactions they're really talking uh

this is kind of that concept that

they're talking about right so we have a

number of different peers who are

running this blockchain technology

they're all weighted equally right each

one of these peers or each one of these

nodes each one of these entities running

a blockchain

has the exact same power as anybody else

right so the way that we can tell very

easily which blockchain is correct or

which ones are correct are by looking at

this end

hash here right or by looking at where

we are

in the blockchain because again remember

because again remember this this hash

that this this in this last block here

is going to encompass

all of the blocks from before right

because this last hash is going to have

the previous hash here which includes

the previous hash here which this hash

includes the previous hash here in which

so this last hash is encompasses

everything in here right and we can look

we can look at the hash of pure c which

is four zeros and then e4b we can look

at the latest hash of peer b which is

four zeros e4b

and then pure a which is for zeros e4b

so all of these peers all of these nodes

all of these decentralized you know

these independent

all these independent users running this

blockchain software they're all matched

up it's very easy for their nodes to

look at each other and say hey great we

are all matched up

now

what let's say that a decides that you

know something happened on the

blockchain that they didn't like and

they wanted to go back and change

something right so let's say they change

here you know obviously

the rest of their blockchain is

invalidated and they have to spend a lot

of computational power to catch up to

speed so let's go ahead and humor it

let's say that they they did they ended

up catching up

uh they ended up catching up you know

they ended up mining everything

and now they have a valid blockchain

right it solves the equation awesome

however

in block number three

there's something new

right this is here and it shouldn't have

been here this is something that pier a

put in by themselves

all that happens now

is we look at all the blockchains that

are running the software and we're

looking at all the hashes at hash at

block number five so pier a has this new

hash now 009 bc

but peer b has a different hash 0 e4b

right so who's right is it is it pier a

with their new stuff or is it peer b

well that's where the decentralizator

comes in because then we can look at

pier c and pierce c

also has e4b so

pure b and pure c both say hey pure a

you're wrong

get out right and peer a will stop being

able to participate in the mining

rewards because they have essentially

forked uh the blockchain and started

their own little blockchain right with

their own history because they're the

only ones with this this piece of data

in block three whereas peer b

and peer c have nothing in there so that

really shows why uh in these blockchain

worlds in this decentralized world there

really is no central identity you know

pier a you know might have been

maliciously motivated to change you know

this block number three however

democracy rules right the majority rules

in the blockchain peer b and pc both say

hey you know that's cute and all pure a

but

you're wrong right that that's not right

now it might be a little abstract that

you just look at data and you know us

typing kind of random stuff in here and

think okay yeah that's that's data right

that makes sense you know just kind of

random strings in here doesn't really do

anything for us so if we actually go

over to the token section here this is

where everything really starts to make a

lot of sense so we have the exact same

setup here with peer a peer b peer c

except the difference is instead of

having kind of this this data section we

have this

tx this transaction section right and

this represents all the transactions

that are happening in this block right

so we're we're sending 25 dollars from

darcy to bingle or to bingley uh force

uh four dollars and 27 cents here uh

1922 right and it's the exact same thing

so this all these transactions are going

to get hashed in the exact same way uh

that the data is going to get hashed and

and this is why it's so powerful because

again you know if i want to be malicious

right if uh if i want to say hey i

really wanted to give jane

a lot more money from elizabeth so i'm

pure a and i go back and i change it to

100 well now

you know not only do i does my whole

blockchain

get invalidated because that was so far

so long ago but i'm not going to match

any of these other chains right and so

my blockchain is going to be excluded

from the overall blockchain so and let's

let's go ahead and fix this and it's the

same thing if down here if i become

malicious and i want to send you know i

want

uh miss audrey to have less money maybe

i want to send a dollar and i go ahead

and mind it the same thing here

this hash now this 2a1 is not going to

match

peer b's

pre-b's hash of bba and it's not going

to match pc's hash of bba as well so the

two of them are going to say hey this

your blockchain isn't valid it's not

matching the majority you know you're

out right

so that's really how these blockchains

work at a low level and it all goes back

to this this understanding this hash

idea and using it in this very

sophisticated manner uh to kind of

cryptographically prove

um you know where where stuff lies now

the way the blockchain works is that

instead of random stuff put in this data

section it's actually going to be

solidity code in here to finding ways to

interact with different blocks and

different protocols that are on chain or

as we've said before different smart

contracts

now the next question that you might be

asking is okay well

how do i know how can i be sure that i'm

the one

uh you know let's say this is let's say

i'm darcy right how can i be sure that i

was that darcy was the one to actually

send this money here how do we know that

darcy sent 25

to

bingley well this is where we get into

uh private keys and public keys and

that's what we're going to go into now

let's just do a quick recap of what

we've learned in this section so far

right we've learned that

ethereum actually runs on this ketchup

256 but you know we used shot to v6 for

this demo it doesn't really matter we're

just talking about hashing algorithms so

again a hash is a unique fixed length

string meant to identify any piece of

datum a hash algorithm or a hash

function is a function or algorithm that

computes any type of data into a unique

hash

mining is the process of finding the

solution to the blockchain problem in

our example the problem was to find a

hash that starts with four zeros

whenever a node mines a block they get

paid a little bit of that gas we were

talking about earlier for doing

something a block in a blockchain is

basically a combination of a block nonce

transaction and previous hash to create

this unique hash for this block and

again depending on the blockchain

implementation this might have a couple

other fields or might have different

fields but this is essentially what's

going on blockchains are decentralized

and distributed because

many independent users are going to run

this blockchain software and they will

check and they will compare against each

other to see which blockchains are

acting honestly and which ones are

acting maliciously in the blockchain

world majority rules the nuns here is

the answer used or the number used to

get this hash now nuns is kind of an

overloaded term it's actually used for a

number of different reasons in this case

we're using it to solve this problem of

getting you know four or five zeroes at

the stop of the hash however in ethereum

it'll also be often used as the number

of transactions from a given address so

now we're going to talk a little bit

about signing these transactions and

private keys and some other cryptography

pieces right because in this blockchain

demo here we can see we hover these

these fantastic transactions right all

these things went through but how do we

know that it was darcy who was the one

to send 25

to bingley right how do we know that

actually happened and this is where

all those pieces that we just learned

about uh in our our test net in our

metamask account are really going to

start to to come to life here a little

bit here so here we have an example of

public and private keys okay at the top

we have this private key right that was

that was randomly generated a private

key is is you know as it kind of states

is a key that you really want to keep

secret because you're going to be using

this

as kind of your secret password for all

your transactions right i can really

pick you know any

any any private key anything that i want

and with it uh

this algorithm they're going to use an

algorithm you know for ethereum in

bitcoin they both use this elliptic

curve digital signature algorithm it's a

variant of just a digital signature

algorithm and it's going to create this

this public key right i'm really not

going to go at all into kind of this

digital signature algorithm but just

know it does use some of these some of

the hash

knowledge that we just learned combined

with some other pieces

to kind of get this this public here so

i'm not going to go too deep into it but

we have this private key that we create

and we get this public key now this

public key we want everybody to have

access to right this is yeah whole world

can see this this private key we really

want it to be uh private we don't want

people to see this we're going to use

this private key as like a password to

quote unquote digitally signed

transactions and then people can verify

them with this public key so let's let's

see what this actually looks like let's

pick a random key a more secure key

right because the longer it is the more

secure it's going to be

and if we go to signatures now

right

let's say we have this

this message that we want right we'll

say hi world right we want this to be

the message what's going to happen

is this private key that we've created

we can use to sign this data right

remember how in the blockchain demo you

know we were kind of we were hashing

stuff right we were we're using this uh

shay256 hash to to get this hash well

we're doing something similar but

instead of hashing we're we're using

this digital signature algorithm to

create this message signature

now what's really powerful about how

this uh this algorithm works is that you

can create this message signature with

your private key but somebody else can't

derive your private key from the message

signature and that's what makes this

really really powerful however if we go

to verify using this public key right

and so this is the

this is that o four zero three this is

that same public key using this using

this public key

anybody can verify let's go ahead and

sign again anybody can verify

that the signature

is yours right so you have a public a

private key

just for you so you can sign things and

a public key that anybody can verify

something right so anybody can verify

this and let's say somebody tries to

fake a transaction from you they say hey

you know this is this is this is their

transaction

all they have to do is verify

that this

signature against your public key and

very easily this whole thing turns red

because

it isn't verified right the the

algorithm says hey

that's wrong so we can go ahead and take

that into transactions in this exact

same way so if i want to send money

you know if i want to send

400

from you know my address to another

address using my private key i can sign

that transaction

and anybody else in the world can then

verify this transaction right and this

is why when people say

hide your keys you know protect your

keys this is what we're talking about

in our accounts here

right if we go to

uh settings and again the only reason

that i'm showing you guys

my mnemonic in my private key is because

this is a

uh this is a dumpster account i'm gonna

throw this away at the end of this video

or i'm just not gonna put any real money

in it

um

but

when we look at our our metamask here we

have this mnemonic phrase which allows

us to

easily get these different private keys

right so

demonic phrase combined uh with you know

whatever account number will get us a

private key so demonic phrase combined

with one we're going to get this private

key and this is when we look at account

details export private key

password confirm this is going to be the

private key that we're going to use to

sign our transactions right this if

anybody else gets access to this private

key they then can sign transactions for

us and they can send transactions for us

and that's why we want to keep these

private

so it works the exact same way right so

this is why it's so important to hide

your private keys and hide your

mnemonics now

your ethereum address is actually

a piece

is actually a piece of your public key

now to get our address in ethereum all

we have to do is take this public key

that we've created with our private key

hash it using that same ethereum hashing

algorithm and then take the last 20

bytes and that's how we'll actually

derive to our um to our address here now

knowing the exact methodology of how to

get the address doesn't really matter

because it could change blockchain to

blockchain and could even change an too

but just know that that is essentially

how kind of these addresses are derived

right there's some derivative of the

public key right because the public key

is public and you know using the public

key in kind of any public way is is

totally fine

but not the private key so that is how

we sign our transactions note though

this isn't how we send the transaction

so so this is just going to sign it

create a transaction for us to send

we'll learn later on how to send these

transactions

so that was a lot of information there

too let's do a quick recap your public

key is derived by using a digital

signature algorithm on your private key

right and you want to keep your private

key private at all times because you're

going to use your private key to sign

transactions

signing transactions with your private

key you are the only one who can

actually do this because you can't get

the private key from a message signature

however using your public key you can

anybody can very easily verify that a

signature that's signed by you is in

fact signed by you in our metamask our

private keys are located in this account

details section you just hit

show private keys and type in your

password and you'll get your private key

here

a quick note here is often times when

using your private key somewhere they

want it in hexadecimal form so if we're

going to use our private key

for something like brownie which we'll

go into later we need to actually append

in a 0x to the front but we'll get into

that later

and the address

of your account is derived from this so

if you think about it your private key

creates your public key which then can

create your address and there's a little

barrier

or a big barrier here

because your private key you want to

keep private and your public key and

your address can all be public

information awesome so now that we know

all the cryptography pieces and all the

little nitty gritties of how the

blockchain actually works and how our

signatures work and how everything

sticks together let's talk a little bit

about how this works in actuality and

what's really going on now for a lot of

this each different blockchain has

slightly different algorithms and

slightly different metrics and criteria

for doing a lot of the stuff so when

we're talking about these specific

implementations keep in mind the exact

algorithm might be a little bit

different but the concepts are all still

going to be exactly the same hashing and

hash function is going to be the same no

matter where you look a decentralized

blockchain is going to be the same no

matter where you look how it's actually

implemented is going to be a little bit

different now traditionally when you run

an application you know be it a website

or something that connects to some

server you are interacting with a

centralized entity and unlike how we saw

with the blockchain with multiple

different peers it's going to be run by

a single centralized group now it still

could be run on many different servers

but all those servers are still going to

be controlled by the same centralized

group blockchains as we saw run on a

network of different independent nodes

when we saw peer a peer b peer c those

were different examples of different

independent users running the blockchain

technology on their own node now when i

use the term node i'm usually referring

to a single instance of a decentralized

system so when i say a single node when

i'm talking about a blockchain i'm

talking about one of those peer a's peer

b's pcs running that blockchain software

i'm talking about one server running

this technology and again it's this

network it's this combination of these

nodes interacting with each other that

creates this entire blockchain what

makes this so potent too is that anybody

can join the network and that's why

there's decentralized the barrier to

entry is a little bit of hardware

requirements you're getting the correct

materials to run the software and then

you running the software anybody can

join these networks and participate and

that's what makes it truly decentralized

in fact you can go to github right now

and run your own ethereum node in a few

seconds now in the traditional world

applications are run by centralized

entities and if that entity goes down or

is maliciously bribed or decides that

they want to shut off they just can't

because they're the ones that control

everything blockchains by contrast don't

have this problem if one node or one

entity that runs several nodes goes down

since there are so many other

independent nodes running that it

doesn't matter the blockchain and the

system will persist so long as there is

at least one node always running and

luckily for us most of the most popular

chains like bitcoin and ethereum have

thousands and thousands of nodes and as

we showed in our demo if one node acts

maliciously all the other nodes will

ignore that node and kick that out or

even punish it in some systems because

they can easily check everybody else's

node and see okay this one is out of

sync with the majority and yes majority

rules when it comes to the blockchain

each blockchain keeps a full list of

every transaction and interaction that's

happened on that blockchain and we saw

if a node tries to act maliciously

then all their hashes are going to be

way out of whack and they're not going

to match everybody else this gives

blockchains this incredibly potent

immutability trait where nothing can be

changed or corrupted so in essence we

can think of a blockchain as a

decentralized database and with ethereum

it has an extra additional feature where

it also can do computation in a

decentralized manner now let's talk

consensus proof of work and proof of

stake because you've probably heard

these before and they're really

important to how these blockchains

actually work we went through that

blockchain example and we did that

mining feature this is what's known as

proof of work proof of work and proof of

stake fall under this umbrella of

consensus and consensus is a really

important topic when it comes to

blockchains consensus is defined as the

mechanism used to reach an agreement on

the state or a single value on the

blockchain especially in a decentralized

system i briefly alluded to this

consensus mechanism in our blockchain

example when i said if one changes

something and the other two

don't then majority will rule and kick

that one out this is part of that

consensus mechanism now very roughly a

consensus protocol in a blockchain or

decentralized system can be broken down

into two pieces a chain selection

algorithm and a civil resistance

mechanism that mining piece that we were

doing or or the proof of work algorithm

is what's known as a civil resistance

mechanism and this is what ethereum and

bitcoin currently use please note that

depending on when you're watching this

if eth2 is out then it's no longer proof

of work now proof of work is known as a

civil resistance mechanism because it

defines a way to figure out who is the

block author which node is going to be

the node who did the work to find that

mine and be the author of that block so

all the other nodes can verify that it's

accurate civil resistance is a

blockchain's ability to defend against

users creating a large number of

pseudo-anonymous identities to gain a

disproportionately advantageous

influence over said system

and in layman's terms it's basically a

way for a blockchain to defend against

somebody making a bunch of fake

blockchains so that they can get more

and more rewards now there are two types

of the civil resistance mechanisms that

we're going to talk about here namely

proof of work and proof of stake let's

talk about proof of work a little bit

more in depth first in proof of work

this is silver resistant because a

single node has to go through a very

computationally expensive

process called mining which we

demonstrated earlier to figure out the

answer to the blockchain's riddle of

finding that correct nonsore or whatever

the blockchain system has in place in

proof of work this works because

no matter how many pseudo-anonymous

accounts you make each one still has to

undergo this very computationally

expensive activity of finding the answer

to the proof-of-work problem or the

proof-of-work riddle which again in our

demonstration it was finding a nunce

with that first four zeros but again

each blockchain might change the riddle

work or change the problem to be a

little bit different in fact some of

these blockchains make this riddle

intentionally hard or intentionally easy

to change what's called the block time

the block time is how long it takes

between blocks being published and it's

proportional to how hard these

algorithms are so these problems

actually can change depending on how

long they want the block tone to be if

the system wants the block time to be

very very long they just make the

problem very very hard if they want to

be very short to make the problem a lot

easier we'll talk about civil attacks in

a little bit and how they can affect the

system but with proof of work it's a

verifiable way to figure out who the

block author is and be civil resistant

now you need to combine this with a

chain selection rule create this

consensus now there are some consensus

protocols that have more features but

very very roughly these are the two

pieces that we're going to look at the

second piece is going to be a chain

selection rule

how do we know which blockchain is

actually the real blockchain and the

true blockchain now on bitcoin and

ethereum they both use a form of

consensus called nakamoto consensus and

this is a combination of proof of work

and longest chain rule the decentralized

network decides that whichever

blockchain has the longest chain or the

most number of blocks on it is going to

be the chain that they use this makes a

lot of sense because every additional

block that a chain is behind it's going

to take more and more computation for it

to come up

that's why when we saw in our

transaction we actually saw

confirmations the number of

confirmations is the number of

additional blocks added on after our

transaction went through in a block so

if we see confirmations is two it means

that the block that our transaction was

in has two blocks ahead of it in the

longest chain now i do want to point out

that a lot of people use proof of work

as a consensus protocol and i do want to

say that this is a little bit inaccurate

but sometimes people use it

interchangeably proof of work is a piece

of the overall consensus protocol which

in bitcoin and ethereum one's current

case is nakamoto consensus nakamoto

consensus is a combination of proof of

work and its longest chain rule both

equally and very very important now

proof of work also tells us where these

transaction fees and these block rewards

go to remember how when we made this

transaction we had to talk about gas and

a transaction fee so who's getting paid

who is getting this transaction and this

transaction fee is going to the miners

or the validators in a proof of work

network they're called miners and in the

proof of stake network they're called

validators there are a little bit

different and we'll get into that when

we talk about proof of stake in this

proof of work system all these nodes are

competing against each other to find the

answer to the blockchain riddle remember

in our example it was to find a hash

that has four zeros at the start and

again depending on the blockchain

implementation that riddle is going to

be a little bit different but all the

nodes are trying as many as possible to

try to get this answer first why because

the first node to figure out the answer

to the blockchain rule is going to get

that transaction fee they're going to

get paid from that now when a node gets

paid they actually get paid in two

different ways one is going to be with a

transaction fee and another piece is

going to be the block reward remember

how we talked about alternating the gas

price or the way on our transaction well

that's the transaction fee that we're

going to pay to these blockchain nodes

for including our transaction the block

reward is given to these nodes from the

protocol from the blockchain itself

you've probably heard of the bitcoin

having before the having is referring to

this block reward getting cut in half

and it's supposed to be cut in half

roughly every four years this block

reward increases the circulating amount

of whatever cryptocurrency that is being

rewarded for example on ethereum the

block reward is giving out ethereum and

on bitcoin the block reward is giving

out bitcoin so these nodes are competing

against each other to be the first one

to find this transaction to be the first

one to find the answer to this problem

so that they can be the ones to win both

this block reward and your transaction

fee some blockchains like bitcoin for

example have a set time when they are no

longer going to give out block rewards

and the miners or the nodes are only

going to get paid from transaction fees

now this gas fee again is paid by

whoever initialized the transaction when

we got our funds from the faucet there

was some server and somebody else was

paying the transaction fee for us

however when we sent ether from one

account to another our first account

actually paid some transaction fee to

send that ether in proof of stake

there's also a gas fee but it's paid out

to validators instead of miners and

we'll talk about that in a little bit

now let's talk about two types of

attacks that can happen in these

blockchain worlds let's talk about the

first one being the sybil attack the

simple attack is when a user creates a

whole bunch of pseudo-anonymous accounts

to try to influence a network now

obviously on bitcoin and ethereum this

is really really difficult because the

user needs to do all this work in proof

of work or have a ton of collateral in

proof of stake which again we'll talk

about in a bit the other more prevalent

attack is what's known as a 51 percent

attack now as we saw as part of our

consensus protocol these blockchains are

going to agree that the longest chain is

the one that they're going to go with so

long as it matches up with 51 percent of

the rest of the network

this means that if you have the longest

chain and you have more than 51 percent

of the rest of the network you can do

what's called a fork in the network and

bring the network onto your now longest

chain now sybil attacks obviously are

when a single node or a single entity

tries to affect the decentrality of the

network by pretending to be multiple

different people although they're just

the same person or entity and like i

said it's really difficult to do in

proof of work and proof of stake so you

can see now that blockchains are very

democratic whichever blockchain has the

most buy-in and is the longest is the

blockchain that the whole system is

going to corroborate when nodes produce

a new block and add to the longest chain

the other nodes will follow this longest

chain that the rest of the network is

agreeing with add those blocks to their

chain and follow up so very small

reorganizations are actually pretty

common when a blockchain picks a block

from a different longest chain puts it

on and then has to

swap it out for another block and

continue with a different blockchain

however if a group of nodes had enough

nodes or enough power they could

essentially be 51 of the network and

influence the network in whatever

direction that they wanted this is

what's known as a 51 attack and it's

happened on blockchains like ethereum

classic which is not ethereum this is

why the bigger a blockchain is the more

decentralized and the more secure it

becomes so after you watch this video

and you become a blockchain engineering

expert i definitely recommend you run a

note as well because you are going to

increase the security of the network as

a whole by running a node so proof of

work is fantastic because it allows us

to very easily protect against these

civil attacks and keep our blockchains

decentralized and secure

however it has some drawbacks as well

proof of work costs a lot of electricity

because every single node is running as

fast as they can to win this race to get

the rewards this leads to obviously an

environmental impact now since proof of

work and nakamoto consensus a lot of

other protocols have taken this idea and

gone in a different direction with a

different civil resistance protocol a

lot of them with the intention to be a

lot more environmentally friendly and

the most popular one right now is proof

of stake there are some chains that are

already using this proof-of-stake

protocol and that are live and thriving

some of them are like avalanche solana

polygon polkadot and terra and

additionally ethereum has decided to

upgrade to eth2 which will have this of

stake algorithm as well it'll also have

some other features which we'll talk

about in a bit now as a quick aside all

the tools that we're going to learn here

are still going to work in eth2 so

depending on when you watch this

everything here is still valid so let's

talk about proof of stake now again this

is a different civil resistance

mechanism instead of solving this

difficult problem proof of stake nodes

put up some collateral that they're

going to behave honestly aka they stake

in the example of ethereum 2 nodes put

up some ethereum as a stake that they're

going to behave honestly in the network

if they misbehave to the network they

are going to be slashed or removed some

of their stake

obviously this is a very good civil

resistance mechanism because if you try

to create a whole bunch of anonymous

accounts

then each one of those accounts you have

to put up some stake and if you

misbehave you're going to run the risk

of losing all the money that you put up

as collateral in this system miners are

actually called validators because

they're no longer binding anything

they're actually just validating other

nodes now unlike proof of work which

every node is racing to be the first one

to find the block in proof of stake

nodes are actually randomly chosen to

propose the new block and then the rest

of the validators will validate if that

node has proposed the block honestly as

we saw with our cryptography lesson it's

usually very easy for other nodes to

verify if a proposal or a transaction is

honest now randomness is a really

important topic when we're talking about

blockchains because keep in mind these

blockchains are deterministic systems

they're walled gardens from the rest of

the world and as you know a determinic

system by definition can't have random

numbers so how do we choose the random

validators in the system well it changes

from blockchain to blockchain and

actually choosing the node will change

blocks you to blockchain but in eth2

they're using what's called randow at

least for the original implementation

this is a decentralized autonomous

organization that collectively chooses

the random number and collectively

chooses which node is going to run next

we aren't going to dive too deep into

this because there's a good chance that

this might change in the future but we

will go into randomness solutions in

blockchain later on in this course now

proof of stake obviously has some pros

and cons as well pros are that again it

is a great civil resistance mechanism

and a great way to figure out who the

author of a block should be the other

pros are that it's way less

computationally expensive to figure out

the new block because instead of every

single node on the network trying to do

this only one node needs to do this and

then the rest of the nodes just need to

validate it the cons are that it's

usually considered a slightly less

decentralized network due to the upfront

staking costs it costs to participate

now this gets into a little bit of a

philosophical battle on how

decentralized is decentralized enough

and i think that's up to the community

to decide and as we progress i think

we'll learn more and more about how

decentralized is decentralized enough

the general consensus amongst blockchain

engineers though is that proof of stake

is very very decentralized and very

secure this massive environmental impact

improvement is one of the two main

reasons why eath is shifting to eth2 it

reduces the environmental impact by up

to 99 percent now these are the main

pieces of proof of work and proof of

stake but i did want to talk about

another concept that's really important

in these ecosystems and that is

scalability when we were talking about

gas prices we were saying that the gas

prices can get really high if a lot of

people want to send a transaction

because a block only has so much block

space and the nodes can only add so many

nodes so when a lot of people want to

use a blockchain the gas price

skyrockets

this is not very scalable because if we

want to add more and more people to

these blockchains it's going to cost

more and more to use the blockchains

because more people are going to want to

get into these blocks this means that

there's kind of a ceiling to how many

people can use the system because of the

financial constraints that will get

imposed as gas prices keep rising

ethereum 2 is not only attacking the

environmental impact of proof of work by

switching to proof of stake but they are

also implementing this new methodology

called sharding and sharding is a

solution to this scalability problem a

sharded blockchain really just means

that it's going to be a blockchain of

blockchains there is a main chain that's

going to coordinate everything amongst

several chains that hook into this main

chain this means that there's more

chains for people to make transactions

on effectively increasing the amount of

block space that there is sharding can

greatly increase the number of

transactions on a blockchain layer 1.

now there's another term that might be

the first time you heard it a layer 1.

we're going to talk about layer ones and

layer twos in terms of scalability

really quickly as well a layer one

refers to any base layer blockchain

implementation bitcoin's a layer one

ethereum's a layer one avalanche is a

layer one these are the base layer block

chain solutions a layer two is any

application that is added on top of a

layer one added on top of a block chain

some examples of layer twos are going to

be chain link arbitrarily or optimism

arbitrary and optimism are very

interesting because they are layer twos

that also look to solve this scalability

issue arbitrary and optimism are what's

known as roll-ups and they

roll up their transactions into a layer

one like ethereum we're not going to go

too deep into rollups and how they

actually work but all you really need to

know is that a rollup is kind of like a

sharded chain they derive their security

from the base layer from the layer one

like ethereum and they bulk send their

transactions onto the layer one they

solve some of the scalability issues by

being another blockchain that people can

make transactions on still on kind of

this base ethereum layer

now they're different from side chains

because side chains derive their

security from their own protocols roll

ups derive their security from the base

layers so arbitrary optimism for example

is going to be just about as secure as

ethereum there's some fantastic guys in

there that go a little bit deeper into

rollups and i've left a link in the

description for you all right so we just

talked about a lot of stuff so let's do

a quick recap before moving on ethereum

and bitcoin are currently both

proof-of-work blockchains that follow

nakamoto consensus however ethereum is

moving to ethereum two which will be a

proof-of-stake sharded blockchain civil

attacks are prevented due to protocols

like proof of work and proof of stake 51

attacks grow increasingly harder with

the size of blockchain so you should run

a node consensus is the mechanism that

allows a blockchain to agree upon what

the state of the blockchain is sharding

and rollups are solutions to scalability

issues on layer ones

a layer one is any base blockchain

implementation like bitcoin or ethereum

a blockchain scalability problem is that

there's not always enough block space

for the amount of transactions that want

to get in them this leads to very high

gas prices and again gas prices are how

much it costs to interact with a

blockchain

so we've learned a ton in this video so

far

everything that you went over is going

to make you 10 times better as a

developer because yes being a good

developer means you understand the code

at a very technical level

but if you can understand the overall

architecture as well you can make the

informed decisions about how to

architect your design or how to build

your software in however you want to do

so so with all that being said it's

finally time to jump into some solidity

and jump into some code so let's do this

now again

in the description of this video there

is a link to this github repository

that's going to be the home base for all

the code that we work with in this

tutorial we scroll down to this main

section this readme there's a table of

contents in here

we can go to lesson one simple storage

and we'll have links helpful tips the

itinerary of what we're going to learn

and everything else that you need to

work with here all the code that we're

going to be working with is located in

this simple storage link that we can go

ahead and click it's in its own

different repository we can go ahead and

click the file to see all the code that

we're going to be working with so let's

jump into it additionally back in our

full blockchain solidity course right at

the top

there's this resources for this course

section if you have questions engaging

in github discussions stack exchange

ethereum and stack overflow are going to

be great places to get help and get

support i highly recommend making a

stack overflow

stack exchange ethereum

and a github account so you can

participate and engage with the

community

welcome to the remix ide or the remix

integrated development environment this

is going to be where we're starting to

teach you how to work with solidity and

work with smart contracts and deploy to

blockchains we're going to use remix to

get us up to speed as it has a lot of

nice features that allow us to really

see and interact with blockchains and

really see what's going on but

eventually we're actually going to move

off of remix to another platform

but all the solidity that we're going to

learn here obviously is going to apply

everywhere as well when you come to

remix there's a whole lot of different

plugins like solidity learn eth soul

hint linter and a whole bunch of other

plugins as well i'm going to go ahead

and start by clicking the solidity

plugin but we're not going to use any of

these plugins for now but later on you

can kind of go back and learn a little

bit more about what these plugins do so

let's start perusing let's start coding

some things on the left hand side over

here is where we're going to interact

with everything so let's go ahead and

click the files up here now you can

always go back and peruse this a little

bit more and in fact i highly encourage

you to because that's how you're going

to learn the most the quickest but for

us we're actually just going to go ahead

and start with our own brand new file

we're going to create a little

application that can store information

on the blockchain for us and this is our

first project that we're going to do in

solidity so we're actually going to

create a new file

and we're going to call it

simple

storage dot soul all solidity has an

extension of dot soul at the end stands

for solidity now let's take inventory of

what we're going to be working with here

this is the solidity compiler tab

it compiles all the solidity code down

to machine understandable code or

machine language here there's a whole

bunch of different parameters we can

choose when working with sliding we

choose the compiler version we can

choose the language which we're only

going to be working with solidity the

evm version don't worry about this for

now so let's code our first solidity

contract here

now we are going to use something a

little bit special here when we actually

deploy these we're going to use a

javascript virtual machine

so we're going to use a virtual machine

that's going to simulate actually

deploying to a test net or a real

network we're not actually going to

deploy on a real network we will

in a little bit but just to get started

we're going to work with a javascript vm

which is kind of a fake environment for

now okay

testing locally and understanding how to

test locally will make your

coding experience a lot faster as you

saw when we sent some transactions some

of them actually took some a lot of time

to actually deploy we don't want to have

to spend that much time waiting around

for our tests to actually finish so

we're going to use a javascript vm to

kind of dummy it for now but let's just

start coding and go from there

so the first thing that you're going to

need in any solidity program is the

solidity version so that's always going

to be at the top of your solidity code

it's defined by doing pragma solidity

and the version

we're going to be using some version

between

0.6.0

and 0.9.0

so we're saying we want to use anything

between 0.6

and 0.9 and and as a force of habit i

just automatically hit command s

whenever i write anything so that's why

you saw some of this pop up here we can

hitting command s or control s depending

on if your windows or not we'll hit this

compile button and we'll compile

everything for us

now if we want a specific version of

solidity we can also do 0.6.0

and if i go ahead and hit command s or

compile

our compiler will automatically convert

to 0.6.0

however if i try to do 0.8.0 with my

solidity at 0.6.0 it's going to give us

an error it's going to say the source

file requires a different compiler

version

we're using 0.8.0 and this is 0.6.0 so

we're going to go ahead and hit compile

and it's going to automatically move

down to 0.6.0

we can also

do carrot 0.6.0

and this will allow us to work with

really any version of 0.6

it'll work all the way up to 0.7 where

if we hit command s or control s there

it'll give us an error so this only

works with any version below 0.7 and

above 0.6 we're going to be using

version

0.6.6 however in future contracts that

we work with we're actually going to

work with different versions of solidity

the reason we're going to be changing

versions throughout this course is that

solidity is a constantly updating

language being good at switching between

versions is going to make you an

incredibly powerful smart contract

engineer the next thing that we're going

to do is we're going to define our

contract

so contract is a keyword in solidity

which stands for our smart contract that

we're going to create you can think of a

contract similar to a class in java or

any other object-oriented programming

language so we're going to give our

contract a name here we're going to call

it simple storage

and we're going to add this little curly

bracket to say this

is the contents of our contract simple

storage

and i went ahead and hit command s and

we can see it is compiling successfully

you could hypothetically deploy this

right now and this would be a valid

contract so great job for making it this

far now in solidity there are many

different types that we can work with

let's go into some of the types of

solidity we can have integers aka whole

numbers they can be uint as in an

unsigned integer meaning they're not

positive or negative we can also have an

int

and we would define a variable by doing

you in 256 favorite number

equals 5.

so we have

an unsigned integer you went 256 means

this is an integer of size 256 bits

so we can have this be upped this number

be up to 256. you can also do uint

favorite number equals 5 but if you want

to be a little bit more precise a lot of

protocols and a lot of smart contracts

will do the whole name like you and 256.

we can also have

booleans booleans are true false so we

can have boolean

favorite bool

equals

true so this favorite bool would be true

it could also be

false

we can have strings

string

favorite

string

equals

string

a string is a string of text here right

it's going to be some word or phrase or

really any of these keystrokes here

similar to the unsigned integer we can

have an int

256

favorite

int

equals negative 5

so it could be positive or negative we

can have an address

which is going to be some type of

ethereum address

so we could do address

favorite address

equals

and then we can even copy right from our

metamask

and just paste it right in here

this is going to be a valid address here

you'll also notice that we end all of

our statements with a semicolon

we can have a bytes object

size 32 bits

favorite bytes

for our example

we're just going to use the word cat

because cat is a string which can be

converted down into a bytes object by 32

means that there's 32 bytes in this

variable favored bytes we can also do

bytes 2 bytes 3 bytes 5 etc with the

maximum size of bytes 32

for example we can't do bytes 64. we're

going to be talking about some other

variables as well like arrays and

mappings but let's just stick here for

now if you want to learn more about the

different types and the different

variables that you can use head over to

the solidity documentation and there's a

link in the github and the description

to show you this section for now for our

simple storage let's say we only want to

store numbers we don't want to store

anything else

so we're just going to go ahead and

delete everything and just have uint256

favorite number

at the top now in solidity if i do this

favorite number actually does get

initialized even though i didn't have it

initialized to 5. if i leave it blank it

gets initialized to the null value in

this case it would be initialized to 0.

so for now let's just not initialize it

to anything that way it'll get

automatically initialized to zero this

means that when we deploy this contract

as of right now favorite number will

start off as zero if you get confused

you can also make a comment on this you

could say

this will get initialized to zero

this double slash here is the way to

make comments in solidity and it won't

get executed as code so we can write

whatever we want as long as it's

preceded by two backslashes

now let's go ahead and create our first

function

functions or methods are self-contained

modules that will execute some task for

us and in solidity it's the exact same

thing they're defined

by the keyword function

let's make a function called store

that will change the value of this

favorite number here

so we're going to call store and we're

going to allow it to be past a variable

so we're going to allow it to be passed

a variable of type unsigned integer 256

and we're going to call it underscore

fave

or it

number we're going to make this a public

function which we'll get to in a minute

and all we're going to do

is we're going to set

favorite number

equals to whatever variable we passed in

favorite number so this in its simplest

form is how you can define a function

now just to visualize what we're working

on so far let's go ahead and deploy this

contract so we can actually start to

interact with it so if we hit this

button this will bring us to the deploy

tab and will allow us to deploy our

smart contract here

using our javascript vm it's given us a

fake account with some ethereum in it it

has 100 ethereum in it to start and same

as before anytime we want to interact

with the blockchain we have to pay a

little bit of gas even in our fake

virtual machine here and we want to

simulate that so you'll see it has some

of the same parameters here as making a

transaction like gas limit for example

when we deploy a contract it's going to

cost a little bit of ethereum or a

little bit of gas to do so

so let's go ahead and hit this deploy

button and see what happens so once we

deployed with this virtual machine a few

things happened

we have

remix kicking out this section down here

saying great job you've deployed

something and if we scroll down it says

transactionsrecorded1 we can look at all

the transactions we've recorded

and we can see it says deployed

contracts and we have a contract here

that we've deployed now let's zoom out

just a hair here so we can see

everything a little bit better in this

simple storage contract we see this big

store button because there's one public

function that we can actually interact

with so we can add

this number here and we'll hit store and

you'll see again we have a completed

transaction

and if we look at our contract

we'll have paid a little bit more gas

right we'll have paid a little bit more

to interact with this function because

again anytime we want to make a state

change in the blockchain we have to pay

a little bit of gas the reason metamask

isn't popping up is because we're kind

of doing it in this simulated

environment so this is great however it

looks like we can't actually see

what our favorite number is we can't

actually look at it so how do we

actually make sure that we can view this

favorite number well let's add another

parameter to this as well

if we add public

to our favorite

number we recompile by hitting command s

or hit the compile button

we delete this contract and we redeploy

and scroll down

now we'll see two buttons pop up

this blue button to show us favorite

number which again is initialized to

zero

and we have the store function

so let's talk a little bit about why

this public variable allowed us to see

this new button this new favorite number

button this public keyword defines the

visibility of the variable or the

function there are currently four

different types of what's called

visibility in solidity there's external

public

internal and private we're mostly going

to be working with public for now but

it's important to know how the rest of

these work public functions can be

called by anybody including variables

so oddly enough variables are a function

call to just look at them and return

whatever that variable is an external

function means it can't be called

by the same contract it has to be called

by an external contract so if in this

contract

i had this be external

i couldn't call

the store function

i couldn't call the store function

inside this function

because the function is external it

means somebody outside of the contract

has to call this function internal

functions however can only be called by

other functions inside of this contract

or in its derived contract

and then private is the most restrictive

as private functions and state variables

are only visible for the contract they

are defined in and not derived contracts

now the reason that we didn't see

favorite numbers show up in our original

contract deployment is that if we don't

give a state variable a visibility it

will automatically get set to internal

so if we want other people to be able to

read it we have to change it to public

now let's see how this interaction

actually works

if we hit the favorite number button

right now we'll get this call thing that

shows up and it'll show us right here

that

the value of

favorite number is zero

now this function however is set so that

whatever value we pass it is going to

change the favorite number to whatever

we pass it as so if we pass one two

three hit store

that transaction goes through

and then hit favorite number we can see

the value is now one two three

now i will also be using transactions

and smart contract interactions and

function calls a little bit

interchangeably that's because on a

blockchain whenever you call a function

or whenever you make some state change

to the blockchain you're actually also

making a transaction that's what makes

this whole thing so powerful and again

that's why making a function call or

deploying a contract costs a little bit

of gas now the reason we can access this

favorite number variable inside this

function

is because favorite number has this

global or contract scope so even if we

made union 256 tests equals 4 or

equals equals 4 we wouldn't be able to

use this variable outside of this

function

right because it's self-contained it's

self-contained inside this bracket

and

if i were to make another function

store two perhaps

public

2 doesn't know that this test variable

exists

functions only know about the variables

that are in the same scope as them so

favorite number is in this global scope

because the only bracket that's above

them is simple storage and test is in

this store scope because it has two

brackets above it it has it's inside of

the store function and inside of this

contract simple storage

store two isn't inside of this store

function or this store scope so it can't

access this test variable

so let's go ahead and make this back to

public

and we'll compile again i'm hitting

command s to compile but you can go

ahead and click the button if you like

and let's get rid of this now as you saw

when we deploy this

there's this button here that we can

click called favorite number we can also

make a function called

retrieve and make it a public function

that is of type view

and returns

uint256

and all this is going to do

is return

favorite number so we're going to talk

about views and returns here

so i'm going to go ahead and compile

i'm going to go ahead and delete delete

this contract i'm gonna go ahead and

deploy it now

and we can see

now we have

two functions or two blue buttons here

we have retrieve and we have favorite

number

if i change favorite number by calling

the store function favorite number and

retrieve will both now say it's one two

three

so then the question might be well why

is this one orange and these two are

blue

and the key relies in this view function

or this view keyword there's two special

keywords that define functions that you

actually don't have to make a

transaction on

and those keywords are view

and pure

a view function

means that we want to read some state

off the blockchain so we're just reading

off the blockchain if we're reading off

the blockchain and we're not actually

making a state change then we don't need

to make a transaction

these blue buttons are blue because they

are view functions public variables also

have view functions that's why both of

these are blue

this technically is a view function and

when i click it i get to view and i get

to read the state off the blockchain

retrieve is the same way we could have

this without a return but it wouldn't do

anything pure functions are functions

that purely do some type of math we'd

have you in 256 favorite number public

pure and just have favorite number plus

favorite number

so we're doing some type of math here

but we're not actually saving state

anywhere

we're going to do this math but we're

not going to save this favorite number

anywhere we're not going to save

anything deploy this now this pure

function

we would have this retrieve function one

two three it's blue as well because it's

again not going to change the state of

the blockchain so view functions and

pure functions are both can have this

blue color

now the reason that nothing shows up at

the bottom is because we didn't return

anything

all we're doing is we're saying add

these two numbers together and that's it

in order for this function to give us

something back we need to have it return

something so if we go back

to this retrieve

to this retrieve function we have to

define what we're going to return when

we're defining this function so we're

going to say this is a public function

it's a view function because we're going

to read some state and it's going to

return a unit 256.

so favorite number is of u 256 so that's

what we're going to return

our public variable favorite name is

also a view function that returns a

un256

for now let's just remove that so we can

work with this retrieve function

so let's go ahead and deploy

so now we see we don't have this

favorite number button anymore because

it is no longer a public function

because again it gets initialized to

internal so we can't actually view it

now keep in mind later on we're going to

talk about how everything on chain you

actually can see

and we'll talk about that a little bit

later though so retrieve is going to do

0

we can call store

and now retrieve is going to be 1 2 3.

now this application is great so far it

allows a single person to store a

favorite number and then go ahead and

retrieve it

later which is fantastic but what if we

want a list of people or a group of

people

and store their favorite numbers or what

if we want to associate a favorite

number with a single person well what

can we actually do now we have a whole

number of different choices but the one

that we're going to talk about is using

a struct structs are ways to define new

types and solidity they're almost like

creating new objects as well

so we can create a struct

called type people

and allow it to start storing a favorite

number associated with a certain people

so inside of our struct we can have

different types as well

so we have a uin256

favorite number

and we could also have a string

name

now we have a new type of type people

that has a favorite number and a name

inside of it now what we could do

with destruct is we could say

people

public

person

equals

equals people

and then inside we add the variables so

we could say

favorite number

favorite number is

2

and name

is

patrick

and of course the semicolon at the end

and again i'm hitting command s to save

but you can also go ahead and compile

in the compile tab

so let's go ahead and delete this

contract and see what this looks like

now

so now we've deployed this new contract

and we have this person struct which at

the zero index

is the favorite number and the variable

stored in the first index is going to be

the name storing variables and solidity

always works in this numeric index

fashion in fact in contract simple

storage uint 256 favorite number is at

index 0. if we were to add another

object here like

boolean favorite bool

this would be at index one

if we were to add bool

favorite

bool2 this would be at index

two zero

one

two

and it works the same in structs this is

at index zero inside the struct this is

at index one inside the struct

so we can see the variables associated

with this person we're gonna go ahead

and delete this for now because

instead of just creating one person we

actually want to create a whole list of

people so how do we create a list of

people let's delete that contract

and what we can do is we can make what's

called an array an array is a way of

storing a list or a group of some object

so as you're starting to see the way the

syntax works for defining any type of

variable is going to be the type of the

variable

the visibility of the variable like

public or if you don't declare it it

gets initialized to internal

and then the name of the variable

it works the same with arrays so we'll

make a people array the people array

is the type

we'll make it public

and we'll call it people

now if we deploy this contract

we go and see we now have a people array

but if we click this button

you'll see that

nothing shows up

the reason is because it's an empty

array to start with right we don't have

anything inside of it

now this type of array that we've

created is what's known as a dynamic

array it's a dynamic array because it

can change its size right now it's a

size 0 and if we added something to it

it's of size one you can also create

arrays of a fixed size so if i were to

do people one public people this array

could only have a maximum of one person

inside of it

so we're going to work with a dynamic

array though because we want to add an

arbitrary number of people into here so

let's go ahead and create a new function

called add person where we can add a

person to this array

so we'll do function

add person

string

memory name i'll talk about this memory

keyword in a minute

uin256

favorite

number

and then we'll make this a

public function

and inside we'll do we'll add this

person to our array the way to add a

person to your arrays is using the push

method

so we're going to push

a new people or a new person

and we're going to give it

those variables again

so we're going to give it so we're going

to give it favorite number

is this variable that we passed in here

oops this needs a bracket

and then we're going to give

the name

going to be this underscore name

and then end bracket

oops

zoom out again here just so i can see

stuff

this needs a semicolon

and perfect

now in that last clip we saw this little

red box pop up whenever a little red box

like this pops up after you compile it

means you have a compile error this

means that there's something wrong with

your solidity code or your salinity

syntax and it won't compile and deploy

properly red is going to be this compile

error now we're going to see a bunch of

yellow warnings in the future if you get

a little yellow pop-up these are okay to

ignore but they usually have some

helpful tips about something that might

be going wrong in your code so to

summarize if it's red if it's red it's

broken if it's yellow you might want to

check it out but it could be okay so we

can see we have our new function add

person

where we pass a string memory name and a

unit 256 favorite number and then we

create

this people person

this people object here and then we push

it

onto our people array

and i'm going to show you another way we

can actually create a people person

is just by passing

favorite number and name

and getting rid of this other bracket by

passing favorite number and name

because we know

that

the zeroth index of people is favorite

number and the first index of people is

name so we can also create a new person

by adding it like this now let's talk

about this memory keyword here now in

solidity there's more or less two ways

to store information you can store it in

memory

or in storage

when you store an object in memory it

actually means that it'll only be stored

during execution of the function or of

the contract call

if we hold it in storage

that means that that data will persist

even after the function executes a

string in solidity is actually

technically not a value type a string is

actually an array of bytes a variable of

type string is actually a special type

of array that we can append text to so

because it's technically an object we

have to decide where we want to store in

memory or in storage and since we only

need this name during the execution we

can have it be string memory name and

then when we create this new people

object we will create a new copy of this

name variable into storage memory means

that after execution delete this

variable and storage means keep it

forever if this is a little bit

confusing for you just know that for now

when you use a parameter that's going to

be a string for one of your functions

you need to call it string memory so

let's go ahead and deploy this contract

and see what happens now

now we have this new function add person

and since we are making a state change

here we can see that this indeed

is a orange button instead of being a

blue button so we can add in here a

string name we'll add

patrick and we'll say his favorite

number is 2.

again right now if we look at people

we see people 0 there's nothing in here

if we retrieve there's nothing in here

so we're going to add person patrick and

now if we hit people of 0 we can see

that the person at the zerowith index in

this people array

is going to be

string patrick

if we try at one there's nothing in here

let's add another person

we'll add

becca and her favorite number will be

24.

let's add her now if we hit one we see

favorite number 24 string name is becca

and retrieve is so showing up blank

because we haven't touched favorite

number awesome this is great we can just

keep adding people

however there is kind of an issue here

what if i'm looking for a person what if

i'm looking to find

becca and find her favorite number in

this array

what if i know her name but i don't know

her favorite number is there an easy way

for me to find that favorite number

without having to triage the entire

array there's another data structure

called a mapping so let's create this

new data structure

so this data structure is going to be of

type

mapping a mapping takes some type of key

and spits out whatever variable it's

mapped to so in this case if we're

saying we want to use the name becca to

find her favorite number we would say

the string becca

is going to be mapped

to the uint 256 favorite number and

similar to

all the other variable declarations the

first part is going to be the typing so

this is going to be a type mapping of

string

mapped to un256

we're going to give this public

visibility and we'll call it

name

to favorite number and without adding

any other functions that work with it if

we deploy this we can see we have this

blue button because we're not making a

state change name to favorite number and

if we type in becca in here

obviously nothing's going to happen

because we haven't added this

mapping in yet

so in our ad person down here let's even

have this ad person also add to the

mapping so we can do name

to favorite number

and then the key is going to be this

name so of becca we're going to say

we're going to map the name becca

to

the favorite number

now we're going to go ahead and compile

again i'm hitting command s

deploy

we can scroll down here

if we look up backhand here

we're going to get nothing

however

if we add

becca

and her favorite number being 24

this add person is going to add it both

to the array

and to this mapping now if we look up

name to favorite number we see that

becca returns 24. now one other thing i

want to show you guys just because

compilers are going to yell you if you

don't have them is typically at the top

of these contracts you want to add an

spx license identifier basically

solidity and the ethereum community

found out that

trust in a smart contract can be better

established if source code is available

and

in terms of legality and copyright it

just makes life a lot easier if you add

that license identifier right at the top

of your solidity we're going to use the

mit license identifier because it's the

most open license out there it means hey

anybody can use this code and we don't

care so you'll see a majority of

salinity contracts have this spx license

identifier mit at the top and compilers

will yell you a lot less awesome we now

have a contract that we've decided that

we liked it's got mappings it enables us

to actually store people and their

favorite numbers this is fantastic we've

done all of our testing in this

javascript vm and we've decided you know

what we want to deploy this to an actual

test net or an actual mainnet how do we

actually deploy this so that other

people can interact with this contract

we are again going to use rink b because

that's what we use to make our first

transaction

now again you will need some type of

test ethereum in your test and wallet so

again if you get lost

you can always just google rink b

faucet

or ring b test net faucet

and find a faucet or a better

alternative would be to come to the link

token contracts in the chain link

documentation at

docs.chain.link and

scroll down or just look up rink b this

linked token contracts page has the most

up-to-date faucets for any test net that

it supports so for example we get a test

and eth faucet right here which also

just happens to be that exact faucet

that we used earlier the only thing you

need to change

in remix is we need to change from

javascript vm to injected web3

and metamask will actually pop up and

say hey would you like to connect to

this application

anytime you're working with a web3

application or a web application that

wants to access your funds or work with

your metamask metamask will pop up and

ask for authorization first this is

really good so that we know which

applications we're actually connected to

so we're going to go ahead and say next

connect and we can see here

that we've even connected here and that

our account on the main network

has zero eth

and remix even tells us hey you're on

the main network so let's go ahead and

switch

to the rink b network

and we can now see

we're on the rink b network and we have

17.74 eth on this ring b test network

injected web 3 means we're taking our

meta mask and injecting it into the

source code of the browser here and

that's the difference between injected

web 3 and javascript vm web web3

provider is if we want to use our own

blockchain node or our own web3 provider

when we do injected web3 we're saying

our web3 provider is our metamask which

will work perfectly for what we're

trying to do so since we already have

some tests on ethereum let's go ahead

and deploy this and see what this would

actually look like if we deployed to a

mainnet the process is going to be

exactly the same right the only

difference was we would be on the main

net instead of rank b so let's go ahead

hit deploy we'll uncheck publish

published ipfs

hit deploy metamask will pop up asking

if we want to do this transaction

because remember

we are deploying a contract we are

changing the state of the blockchain so

we have to pay a little bit of gas fee

for it so we're going to go ahead and

hit confirm

and we get

a link to ring the ether scan similar

exactly as we saw before when we made a

transaction the difference here

is that instead of sending ethereum to

somebody we're actually making a

transaction on the blockchain to create

a contract after a short while it will

show up here on etherscan with a success

the number of block confirmations which

again is the number of blocks appended

to the block that included our

transaction

we see from which is our account here

and we see two is this new contract that

we just created and we can even click it

and we see

that

there's this unique transaction hash

that created a new smart contract and

same as working with the vm we have all

the exact same functions in here and you

can see if i hit retrieve

these three functions since they're not

making a state change you can just click

them and no transactions will be made

however what do you think is going to

happen if i hit store

if you guessed metamask will pop up you

guess correctly

again we see the familiar pieces here we

have a gas price gas limit

go ahead and hit confirm

we get another transaction here and once

this transaction goes through

we should be able to call our retrieve

function and see a new number

if we call it now

nothing shows up because our original

transaction hasn't succeeded but i bet

if we look at it now

okay it's still indexing but it looks

like it's been included if we hit it now

we do indeed see this value here

and we can do the same thing with adding

a person we'll add becca we'll say her

favorite number is 24.

metamask will pop up we'll go ahead and

confirm the transaction and if i look up

becca and the name to favorite string

right now it's going to show nothing

because our transaction hasn't gone

through yet

but if we wait a little bit i should

probably spell her name right we do see

24.

and if we look at the zeroth index we

also see becca's been added here as well

now all the solidity code that we wrote

and when we interacted with this

blockchain here

all this solidity was compiled down to

the evm also known as the ethereum

virtual machine

a lot of the blockchains out there today

are what's called evm compatible

and that means that all this solidity

and all these functions that we're

creating

can still compile down to evm and

deployed on their blockchain you'll find

out a little later when we look to work

on a non-ethereum based chain that we

can still deploy our solidity smart

contracts to these other chains as well

but that's a term you'll hear more and

more the ethereum virtual machine or ebm

now take a break give yourself a high

five because you just deployed your

first smart contract and you learned the

basics the fundamentals of solidity so

huge congratulations on how far you've

gotten now in our second projects we're

going to take the fundamentals a step

further and start going into the more of

the intricacies of solidity but just as

a quick recap the first thing you always

got to do in your smart contracts is

name the solidity version

then you'll have to name your contract a

contract in solidity is like a class and

defines all the functions and parameters

of your contract

there's many different types in solidity

like unsigned integer 256 boolean and

bytes

we can create structs in solidity we can

create arrays in solidity we can create

mappings in solidity we can create

functions in solidity

view functions don't make a state change

memory and storage are two different

ways to initialize where a variable is

going to be saved

all the solidity code that we're working

with gets compiled down to the ethereum

virtual machine and last but not least

congratulations on taking your first

step in learning solidity let's move on

to the next project

all the code tips and links that we're

going to be working with can be found in

our course repository

we can scroll down to lesson two

storage factory

click it here and we can see all the

code we're going to be working with good

luck all right so we've done it we've

got our first contract out of the way

we're understanding some of the basics

of solidity now let's move onward let's

get a little bit more advanced with what

we're going to do

with our smart contracts and let's build

what's called the factory pattern of

smart contracts so we have our simple

storage contract here which is great it

allows us to store

numbers and store favorite numbers

associated with different people and

this is great what if though i want to

have a lot of these simple storage

contracts deployed i want to give people

the ability to generate and deploy their

own lists based off of this contract

this is where the factory pattern comes

into play so let's go ahead and create a

new contract so in this contracts folder

i'm going to do new file

we're going to call this

storage

factory

dot sol

and now we'll have a storage factory.sol

now the way that we're going to do this

is that you need simple storage and

storage factory in the same folder

i have both of them in this contracts

folder but if you have them outside or

in a different folder that's okay just

make sure wherever they are they're in

the exact same folder so let's figure

out how to get a contract to actually

deploy another contract we're going to

add those basic pieces that we added in

that simple storage.sol we'll add the

spdx

license

identifier

which will be mit

we'll choose our solidity version which

will be pragma

solidity

and we'll say anything in the six range

and then we'll create our contract we'll

say contract

storage

factory

and we'll create our brackets here and

i'm going to do command s or compile

whatever you want to do things are

looking good here great so how can this

contract

deploy a simple storage contract well

the first thing that we're going to need

to do is actually import this simple

storage into our storage factory

contract

we need to import it so that

our storage factory contract knows

what a simple storage contract even

looks like

the way that we can import it is by

doing the command import and then the

file path that the simple storage is

located so the file path for this is

going to be at dot slash

simple

storage dot soul

this means that simple storage is in the

exact same directory as storage factory

doing this line is equivalent to copying

everything in this contract bit

coming over to storage factory and

pasting it above

you can even save and compile and have

two contracts in the same file now

what's interesting about having two

contracts in the same file is that when

you go to deploy

you'll actually have a choice of which

one you want to deploy and it's the same

thing if i do that import statement so

if i delete all this

and i go back to import dot slash

simple storage dot sol in our deploy tab

still

you'll see that we still have our choice

of which contract we actually want to

deploy

so this is how we actually import a

contract or import any type of file that

we want so that our contract knows what

that contract looks like and can do so

if we want this contract to then be able

to deploy a simple storage contract

we're of course going to have to create

a function that can do that

so we'll do function

we'll call it create

simple

storage contract

we'll make this a public function

we'll do our little open and close

bracket in here the way we can generate

a contract of simple storage type is by

using a new keyword so let's create a

simple storage variable

we'll say a variable of type

simple storage contract we'll name this

variable

simple storage

with a lowercase s

equals

new

simple

storage

what this line is saying is we're saying

we're going to create an object

of type simple storage contract

we're going to name it simple storage

with a lowercase s

and we're going to say this is going to

be a new simple storage contract and

we're saying this simple storage

contract takes no input parameters of

course if we deploy this contract as is

by going to our deploy tab

choosing the storage factory

staying on a javascript vm

deploying

scrolling down

we have this function that doesn't

return anything

so we're creating new contracts but we

can't really read where those contracts

are being created we'd have to look on a

block explorer like etherscan or

something

so let's make a way for us to keep track

of all the different simple storage

contracts that we deploy

let's put them in a list or in an array

so what we can do

is we can say

simple storage

array

of visibility public and we'll call it

simple storage

array

we'll initialize this symbol storage

array

and every time we deploy we create one

of these new simple storage contracts

we'll add it to our simple storage array

so we'll do simple storage array dot

push

and we'll push

this simple storage variable

so again i'm compiling or hitting

command s

delete that most recent contract

we'll choose the storage factory and not

the simple storage

and we'll hit deploy

now if we scroll down to our storage

factory

we have this blue button which stands

for our simple storage array

if we try to see what's at index 0 we

get an error of course because we

haven't added anything to it yet

if i click this create simple storage

contract

orange button here

now i've created a transaction that's

going to create a new simple storage

contract and push it onto our simple

storage array

now if i try to access the zerowith

index or the first index of this array

i'm going to get this address here

this is the address that this simple

storage contract was deployed to so

we've successfully deployed

a contract

to the blockchain from another contract

and this of course is really exciting

now we can actually do more than just

deploy the contracts we can actually

deploy contracts from another contract

and then call those functions as well

so let's create a new function where we

call

this store

function and we'll also create a

function where we call the retrieve

function from our storage factory so

we'll do function

storage factory store

we're going to shorthand it by saying sf

store we'll have it take unit 256

simple

storage

index

and a uint256

underscore simple

storage

number

we'll make this a public variable as

well in our little brackets here

and the reason i'm choosing a simple

storage index is because we're going to

choose which simple storage contract in

our list that we want to interact with

and then we're also going to pass a

simple storage number

to call

on the store function which of course we

need to pass a favorite number to any

time that you interact with a contract

you need two things

you need the address of the contract you

want to interact with and you also need

the abi for us we figured out that

we're going to push and get this address

from this simple storage array

we can get the abi or the application

binary interface from this import

we'll explain the application binary

interface a little bit more later

for now just know that in order for us

to interact with this simple storage

contract we can just do

simple storage

and then

we'll pass this simple storage the

address of that simple storage

contract

to get the address of that simple

storage contract

we'll say

grab the address

inside the simple storage array

at index simple storage index this will

return that contract that we want to

interact with

so we could even say

simple storage

simple

storage

equals simple storage

at that address in the array

once we get this contract we can then

call

any and all of its functions

so we could call

simple storage

dot store

this simple storage number

now if we compile this

we go to our deploy tab deploy the

factory

hit deploy

open this up we can see we have a couple

different functions here we of course

have our create simple storage function

which creates the contract and adds it

to our array

we now have this sf store

which stores

a number

to one of those contracts on this array

and then we have

a lens

into that simple storage contract

so if i create a simple storage contract

i can now store

on that zerowith contract on that first

contract any number that i want like 55.

of course i can't really see that 55

because we didn't add a retrieve

functionality we didn't add a way to

actually listen or read or retrieve that

favor number that we got

so let's add that now so

we'll create a new function

called

sfget and this will take a uint 256

simple storage

index

and as a parameter and we'll choose one

of these contracts on this array and

return

its favorite number

calling the retrieve function on that

contract

so since we're just going to be reading

state

this can be a public

view function

that will return

a uint256

to do this

we need to access that contract once

again

so we'll say simple

storage

simple storage

equals

simple storage

at that address

of

simple

storage array

at index

underscore simple

storage index

and we can return

return

simple storage

dot

we call this retrieve function

i'm just going to copy paste it so i

don't spell it wrong

simple storage we'll put the semicolon

here too

and here

now if we compile this go to our deploy

tab delete the most recent

choose the storage factory and hit

deploy

we can see we now has have an sfget

function

so let's go ahead

create a simple storage contract we'll

store a function on the zeroth contract

we'll store 55 as its favorite number

and we'll hit that

and then for s of get we'll see if we

can get

the favorite number of the zero with

contract

and we do indeed get 55.

awesome we can actually even refactor

this code to be a little bit simpler

here

we don't need to save

this simple storage contract is a

variable here we can actually just call

retrieve

on this whole section here

paste retrieve at the end

and just

return

like this

the same goes for our sf store

we can delete saving it as a variable

we can copy this dot store

paste it at the end here

and delete this as well

now we'll compile

delete the most recent

we'll deploy the storage factory

and if we go into it create a simple

storage

store the number 55

see what's at the zeroth index and we do

indeed see 55.

so

this is really cool this is a way for us

to actually deploy contracts and

interact with contracts from another

contract now to deploy a contract we do

need all the functionality of that

contract

imported however to interact with the

contract we don't need all of the

functionality we'll learn about

interfaces in the next lesson which will

allow us to actually interact with the

contract without having all the

functions defined and now i'm going to

show you something really cool now i'm

going to show you something really cool

simple storage has got a lot of really

cool functions and maybe i want all

these functions inside my storage

factory i want my storage factory to be

able to create simple storage contracts

and i want it to be a simple storage

contract itself

well what i can do

is my storage factory can actually

inherit

all the functions of simple storage

without me having to copy paste all

these functions and all these variables

over to storage factory what i can do

is i can do solidity's version of

inheritance

i can say contract storage factory

is of type

simple storage or is of contract simple

storage

and just by doing this line right here

my storage factory contract now will

have all of the functions and variables

of simple storage so it'll have

a store function a retrieve function an

add person function

a people array a name to favorite number

mapping it'll have everything because i

will inherit it with this is syntax

so if i go to my deploy tab now

[Music]

let's look at what our last storage

factory was

all we did to change this was add is

simple storage and we can see just the

four functions that we originally added

if i delete this now

if i save and compile the storage

factory let's go ahead and deploy

storage factory

if we open this up now

we can see

not only do we have all the functions

originally defined in our storage

factory but we additionally have all the

functions from our simple storage and

awesome you've completed the second

lesson we've learned about some

incredibly powerful tools here we've

learned how to import entire chunks of

code from other files into our files

we've learned how to do inheritance

we've learned how to deploy contracts

from our contract

and then we've learned how to interact

with different contracts from outside of

our contract well done now is a great

time to take a breath take a breather

and review what you've learned

the github repository associated with

this course also has all the code for

this lesson so let's jump into it so

we're back in remix now and we're going

to go to contracts and same as before

we're going to create a new file we're

going to call this fundme.sol

now same as last time we're actually

going to add this spdx license

identifier mit right at the top and then

we're going to choose our solidity

version

so we're going to go pragma solidity

and for this we're just going to do

greater than equals to

0.6.6

and less than 0.9.0

and great

this should look pretty familiar

now we're going to do contract fund me

and we're going to start working so what

again do we want this contract to do we

want this contract to be able to accept

some type of payment so let's create a

new function that can accept payment

we'll call it fund

so we'll do function

fund

public and we'll add a new keyword in

here called payable when we define a

function as payable we're saying hey

this function can be used to pay for

things when you call a function

every single function call has an

associated

value with it whenever you make a

transaction you can always append a

value

this value

is how much whey or gray or fini or

ether you're going to send with your

function call or your transaction

as we mentioned before

whey way and ether are just different

ways to talk about how much ether you're

going to send

so if we look at a way to ethereum

converter one each is

this much way

one way is the smallest denomination of

ether you can't break up ethereum into

anything smaller than one way this is

why when you're talking about how much

something costs everything always

defaults to whey or the smallest unit of

measure in ethereum so again for us to

test we're going to stick with the

javascript vm for now if we hit deploy

we get a new contract and this button is

now red it's red because it is a payable

function so now if i hit this fun button

[Music]

i can add

a value associated with it so what do we

want to do with this funding what do we

want to do when people send us something

well let's keep track of who sent us

some funding so what we can do is we can

create a new mapping between addresses

and value

so let's do a mapping

of address

to

uin256 which will represent the value

we'll make this a public mapping

and we'll call it

address to amount

funded

now in this fun function let's keep

track of all the people who sent us

money or all the addresses that sent us

some value

to do this we can use some keywords that

go along with every transaction so we'll

say address

to amount funded

of message.sender

equals

or

plus equals

message.value message.sender and

message.value are keywords in every

contract call and every transaction

message.sender is the sender of the

function call and message.value is how

much they sent

so whenever we call fund now somebody

can send some value because it's payable

and we're going to save everything in

this address to amount funded mapping

so if we deploy this now

in our javascript vm

we now have again a new view function

called address to amount funded and we

can even hit the drop down to see the

full name

now if i hit fund nothing's going to

happen right because my address is going

to be sending zero

in order for me to send something i have

to add some value along with my

transaction

so let's send for example one way

which is going to be equal to

1

1 2 3 4 5 6 7 8 9 this much way so

before i hit fund here if i copy this

fake account which is up here

and i put it in this address to amount

funded

it's going to return zero

but now if i add

1 1 2 3 4 5 6 7 8 9 in here

and we go ahead and hit fund now we've

now just called this fun function with a

value of one gray associated with it

so if i call

this address to amount funded now with

the same address i can now see

how much we've funded this smart

contract and we can even add more gray

we'll add

we'll add 11gway for example we'll call

fund and if we call this now we can see

that even more has been added when we

send our funds to a contract this

actually means that this contract

wherever this is deployed now is the

owner of this

amount of ether

so this is fantastic we now have a way

to fund our smart contracts now here's

the thing

in this smart contract in this funding

that we're doing we want to create a

minimum value for people to be able to

fund our endeavors which whatever they

may be we want to set some minimum value

here

and ether is great but for whatever

reason we want to work in usd or maybe

we want to work in some other token so

how are we going to get the conversion

rate from that currency to a currency

that we can use in this smart contract

well the first thing that we're going to

need to do to set this value is we're

going to need to know

what the eth

to usd

conversion rate is

because if i want to

accept ethereum as the token but i want

it in its usd currency well then i'm

going to need to know what that

conversion rate is so how are we going

to get this data into our smart contract

where are we going to get this data from

now remember how we talked about

blockchains being deterministic systems

and and oracles being the bridge between

blockchains and the real world well this

is exactly where oracle's come in when

we're talking about these systems you

know these blockchains they can't

connect to real-world events they can't

connect to external systems they can't

do external computation they're

intentionally these deterministic

systems these walled gardens so in order

for us to make this connection we need a

blockchain oracle we need some type of

network here now just to get a little

bit more technical for you if we look at

a blockchain a blockchain can easily say

one plus one

equals two and every other node can

easily verify this

however a blockchain can't easily say

okay let's all grab the same random

number because each node is going to get

a different random number they also

can't say hey let's make an api call

because if one node calls the api at a

different time another node calls it or

specifically an http get there could

potentially get very very different

results

and if another node tries to replay

these transactions by calling these apis

again

maybe 10 years in the future there's a

good chance that that api is going to be

depreciated

and they could be hacked they could be

malicious et cetera et cetera

the other reason that blockchains

intentionally can't make api calls is

because then they would be making

assumptions about the real world and

layer ones typically don't want to have

an opinion on any political or

geopolitical issue whereas an oracle

network on the other hand can make those

assumptions the other main thing we need

to talk about here is centralized

oracles being main points of failures if

you or i say hey i'm just going to be

the oracle i'm going to be the one to

put this data on chain we now have this

massive centralized point of failure

we've done all this work to make our

decentralized computation decentralized

and on chain but we ruin all the

decentrality by having a single point of

failure remember one of the whole

purposes of blockchain is so that not a

single entity can flip a switch and

restrict our freedom to interact with a

centralized oracle a single entity can

flip a switch and restrict our freedom

to interact with each other we also need

to get data from many different

decentralized sources or do any type of

computation in a decentralized manner

this is where chain link really shines

chain link is a modular decentralized

oracle infrastructure and oracle network

that allows us to get data and do

external computation in a highly civil

resistant decentralized manner it can be

as customizable as you want as you can

run with one node or many nodes or do as

many nodes as you like

now currently one of the most popular

features of chain link is their data

feeds or their price feeds we can even

go check them out

over at data

dot chain dot link

we can see a number of different price

feeds and the networks that are

providing the prices for these specific

pricing powers

we can see here by looking at the ui

there is a whole number of decentralized

different oracles returning data for

different price feeds this one for

example is fusd and it's also exactly

the price view that we're looking for

having a decentralized network bring

this data on chain and have it as a

reference point of definitive truth

allows users to all collaborate and use

this common good and it will be cheaper

more secure more efficient than anybody

even running their own centralized

oracle so these price feeds are

incredibly powerful additionally they're

being used by some of the top protocols

in the defy system right now

like synthetics which at the time of

recording is securing around 2 billion

sushi swap for leveraging trades set

protocol commodity money ave for

understanding the price of an underlying

collateral now this is an example of an

out of the box decentralized solution

that's already been packaged in the

decentralized manner for you to consume

and for you to use this makes going to

production a thousand times easier than

building everything yourself

however if you want to make api calls

and build your own decentralized network

you absolutely can with the chainlink

api calls

we're not going to go into that here

because using the chainlink price feeds

chainlink vrf keeper network and all

these other pre-box decentralized

services are going to make going live

and going mainnet a lot easier you can

always make a chain link http get call

as well we're not going to go over this

though because putting this into

production is a little bit trickier and

working with chainlink vrx if you ever

want to try them out by themselves you

can always head over to docs.chain.link

and head over to get the latest price

feed there's usually a remix button

actually that we can click and it will

kick us out to a remix edition with all

the code already ready to go for us if

we just hit this just right here this

will include all of our code which we'll

go into in a second

but let's go ahead and compile it

we're going to deploy it

to a real network here

this one looks like it's actually for

covin so we're going to go ahead and

switch to coven looks like i don't have

any covent ethereum so we're going to

grab

a covent faucet we can usually find

different faucets in the chain link

documentation

let's look up kovin here

there is a coven faucet here

it looks like in order for us to get

some covent ethereum here we have to log

in with github then we can add our

address in here and get the ethereum in

the interest of time i'm going to skip

ahead for me doing that

great it looks like i've got some covent

test that now being able to switch

between test nets is going to make you a

lot more effective as an engineer as

well because you're going to be able to

understand how each network actually

works so now we've compiled this

let's deploy this

again metamask is going to pop up

and let's go ahead and click to get the

latest price and we can see that this

function does indeed return the latest

price of ethereum

now you might be asking

why does this number look so big

well remember how we talked about whey

and gray and ether

well the reason that those exist is

because decimals don't work in solidity

so we actually have to return a value

that's multiplied by 10 to some number

so this value is actually 2614

times

10

raised to the eighth now the next

question you might ask is well why did

we work with this on a test net why

can't we do this on a local network and

the answer to this is because there is a

network of nodes looking at this test

net and delivering data onto this test

stem when you spin up a local network or

do a simulated vm there are no nodes

actually doing that we'll learn later

how to actually mock these interactions

and mock a chain link node returning

data onto our blockchain but for now

let's head back over to the contract

that we're working on so we can learn

how to implement this in any contract

that we ever want to another contract

called in this case called price feed

has a function called latest round data

which returns a lot of data it returns a

round id which defines how many times

this price feed has been updated it

returns a price which is the actual

conversion rate between the two assets

it returns a started at which defines

when this was last updated

it returns a time stamp and it returns

an answer in round don't worry about

answered in round for now if you want to

dive a little bit deeper into what these

rounds mean and what answered in round

means you can definitely check out the

chain link documentation and some of the

faqs to learn more now how do we

implement this data feed into our fundme

application well the first thing we're

actually going to need to do is we're

going to need to import the chain link

code

so we're going to do import

at chain link

contracts

source

v 0.6

interfaces

slash aggregator

v3

interface

dot soul

now let's talk about what this is

actually doing

oops looks like i spelt aggregator v3

interface wrong

all right great now it's actually

compiling

so let's talk about what imports

actually do

as we know an import will take whatever

code you're importing and stick it at

the top of your project so when we

import from at chainlink contracts we're

actually importing from the at chainlink

contracts npm package

we can look up at chain links contracts

in npm

and we can see and read more about this

repository

this links us back to the github which

will tell us a little bit more about

what's really going on if we follow that

import path that we got from the

documentation we'll end up on this file

in front of me now we have what's called

an interface you can see these contracts

don't start with the contract keyword

but they start with the interface

keyword they have the exact same pragma

solidity at the top but the main

difference is that you can see that

their functions aren't completed they

just have the function name

and its return type

now just to be a little bit more

explicit here i'm actually going to go

ahead and delete this import statement

on the top and replace it with that

interface code from github just to show

you exactly what's going on however if

you've already typed that at import

syntax feel free to leave it in there

and just remember that it's going to be

the exact same as me copy pasting the

interface code in our code here solidity

doesn't natively understand how to

interact with another contract we have

to tell solidity what functions can be

called on another contract this is where

interfaces are actually going to come in

similar to structs what we can do with

interfaces to find a new type so if we

copy all this code

from this section and place it at the

top of our code here

above where we're declaring a contract

we can actually then

interact with contracts that have these

functions

if we go ahead and even compile this we

can see this does indeed compile

correctly remember how we said before we

talked a little bit about abis well

interfaces actually compile down to

what's called the abi or the application

binary interface the application binary

interface

tells solidity what functions can be

called on another contract

we need solidity to know what functions

it can use and what functions it can

call other contracts with and if that

was a little bit confusing just know any

time you're going to interact with

another contract in solidity or smart

contract programming in general you're

going to need that contracts abi we'll

go into what these apis look like a

little bit later anyways to simplify it

interface compiles down to an api we

always need an api to interact with the

contract so how do we actually work with

this contract here to interact with an

interface contract it's going to work

the exact same way is interacting with a

struct or a variable let's define a new

function called getversion and we're

going to call this version function on

this other contract

so we'll start out doing function

get version

public

remember it needs to be a view since

we're just going to be reading this

state and even in the interface it even

defines it as a view returns

so we'll even grab

this whole bit right here

view returns unit 256. now the exact

same way we define variables and structs

we define working with other contracts

and interfaces so the first thing is we

name the type which in this case is

aggregator v3 interface

then we'd name the visibility but since

again we're inside of this contract

we're going to skip it then let's give

it a name

we'll call it

price feed since this aggregator v3

interface is going to be giving us a

price fee then we can do equals and this

is where we're going to initialize the

contract so how do we actually choose

where to interact with this contract

well we just type aggregator v3

interface and then we put in here the

address of where this contract is

located in order to find

where this fusd price feed contract is

located on the rink b chain we can look

at the ethereum price feeds chain link

documentation

it has a ton of different price feeds

and even more not price related data

let's scroll down to rink b

because again

on each different chain

the contract address that has all this

price feed information is going to be

different

let's scroll down and find fusd which is

right here

and we'll copy it

and we'll paste it into here

now what is this line saying

it's saying that we have a contract that

has

these functions defined in the interface

located at this address if that's true

then we should be able to call

price feed

dot

version

and we should be able to return it

whoops looks like we forgot to add

those here

and we need a semicolon here

i hit ctrl s or command s compiled it

looks like we're compiling successfully

and we do need to deploy this on a test

n

remember this address here is located on

an actual test tent it's located on an

actual network it's not going to be

located on our simulated chain here so

we do need to deploy this to injected

web 3. we do need to deploy our contract

to rink b because the rink b chain has

this address

we'll learn later on how we actually can

work with a simulated chain and work

with these price feeds but that's much

later in this course so let's go ahead

and save

we'll deploy

make sure we're on injected web 3.

now we can go ahead and hit deploy

metamask is going to pop up per usual

confirm

we're going to get a transaction link to

etherscan showing us our contract

and once it actually is confirmed we can

see we have our contract right here now

we have our familiar functions with one

additional function

we have our fund button which is red

because it's payable we have our address

to amount funded mapping which is blue

because it's a view

and we also have this get version button

that's also blue if we go ahead and

click it we can see that the version of

our aggregator v3 interface is version

3. this is the third version of the

aggregator interfaces hence the name

aggregator v3 interface so we just made

a contract call to another contract from

our contract using an interface this is

why interfaces are so powerful because

they're a minimalistic view into another

contract so this is great we have a get

version function but this still isn't

the function that we want we want to

call the get price function which if we

look at our interface we can see there's

a latest round data function that

returns

an answer this is the function that

we're going to want to call on this

contract so let's go ahead and make a

function that calls that instead

so we're going to do

function

get price

public

view

returns

uint 256.

uh oh

this latest round data function though

returns

five variables so how do we actually

work with that well let's find out to

work with this contract we're gonna do

the exact same thing

we're gonna do aggregator v3 interface

because this is the type of the contract

price feed

equals

aggregator v3 interface

we'll do this same address in here

because this is the fusd address

then we'll do price feed

dot

latest round data

now since this is going to return

five different values

we can actually have our contract also

return these five different values

we can copy paste like this

and literally do

this

these five values equal price feed that

latest round data

and you can see

that even compiles correctly let's

adjust the formatting a little bit here

so it looks a little bit nicer a tuple

is a list of objects of potentially

different types this is the syntax for

getting a tuple we can define several

variables inside one of these tuples

although our compiler is going to give

us some warnings it's saying unused

local variable because we're not

actually using these for anything we'll

come back to this

now we can go ahead and do return

and we can pick one of these variables

that we want to return answer is going

to be the price so we're going to do

return

answer but uh-oh we're going to run into

an error return type argument in 256 is

not implicitly convertible to expected

type answer is an int 256 and we want to

return a uint 256 so how do we rectify

this we can fix this by using what's

called typecasting if we just return

answer we're going to be returning the

wrong type however integers and solidity

are really easy to cast into each other

so we can just do uint 256

and wrap it around this answer

and then compile and save that instead

as you can see now our compiler is happy

because we've changed this answer into a

unit 256

awesome so now this get price should

return the latest price of ethereum in

terms of usd let's go ahead and deploy

this new contract with this new function

so same thing we're going to come to our

deploy section

hit the deploy button up remember we got

to go to the fundbean.sol

let's deploy it

confirm with metamask here

and let's scroll down to our newly

deployed contract

as you can see we have our get version

function which still works exactly the

same but we have a new function too

called get price and this should return

a uint 256 answer let's go ahead and

click it

amazing we've actually returned an

answer now again if you're a little

confused on why this number looks so big

you have to remember that this actually

has eight decimals we could call this

decimal's function on the contract to

learn that one two three four five six

seven eight and we know that the current

price of ethereum in terms of usd

is two thousand four hundred and

eighty-two awesome so now that we have

the price we can actually get the

conversion rate but let's clean up this

function a little bit before we go on up

there as you can see one thing that the

compiler is complaining about is we have

a lot of unused local variables

but latest round data returns

five different variables

so how do we actually return the five

variables but make our compiler happy

with us well we can actually just return

blanks for each one of these sections

with commas in between each other to say

hey there is a variable here but we're

not going to use it

this will also make our code look a lot

cleaner

because now this function's a lot

smaller

we say

something's here we're ignoring it

in 256 answer we're going to use some

things here ignore it something here

ignore it and ignore this too and we can

even test this out by compiling it

deploying it

checking on rank b

scrolling down

hitting this

and hitting get price and you can see

indeed it's the exact same as before

awesome so now we're all done cleaning

things up right not quite yet

see the other thing that's really

annoying here we have this massive chunk

of code at the top

that is probably a little redundant

there's a good chance that a lot of our

contracts are going to want to use this

aggregator v3 interface so let's just go

ahead and add that at chain link

contract syntax back in because it's

going to look a lot cleaner here and do

at chain link

contracts if you ever get a little bit

confused with what you should be

importing to work with their contracts

we can see right in the documentation at

the top this at syntax is what this is

going to use

now you can also go ahead and browse

that npm package of at chainlink

contracts see what other applications

are in there and what other files are in

there

or you can just peruse around the github

now the third way we can actually do

imports is we can import from contracts

that are in the same file system as our

contracts well awesome our contract is

starting to look more and more put

together now one other thing that i

usually like to do with these is i

usually like to put everything into the

gray

way standard so as we saw

this get price had eight decimal places

however

the smallest unit of measure aka whey

if we look at it has 18. one two three

four five six seven eight nine ten one

two three four five six seven eight

so typically in these i like to try to

make everything have 18 decimals as well

you don't have to do this and it'll save

some gas if you don't but i usually like

to multiply everything so that

everything has 18 decimal places so

since i know this has 8 i can just do 1

2 three four five six seven eight nine

ten

and now this will return

the price with eighteen decimal places

instead of ten now we have the price of

ethereum in us dollar which is fantastic

so we could set the price of our funding

function to anything that we want here

for example let's say 50

we could convert whatever value that

they send us to its us dollar equivalent

and see if it's greater than or less

than fifty dollars

all we have to do is make a new function

that converts that value that they send

to its us dollar equivalent so we could

do function

get conver

generate

and it will take a u 256

f amount let's get this out of the way

for the rest of this

it'll be a public view function since

again we're not actually going to have

it make any state change

we'll do returns you want 256

and then in this function

we can do uint 256

f price

equals

get price

and we can call

this get price function up here

now we have the price in here

what we want to do is we want to convert

whatever value that they send

as f amount let's say they send one way

or again that's going to be this much

way

what how do we convert this

to fusd

well

we can now do unit 256

s

amount

in usd

equals

this f price

times

the f amount that they sent

this is actually going to

result in a much bigger number than

we're looking for and then of course

we're going to return it

let's test this out and see why we have

to do one more thing here

so let's again

fund me we'll deploy

rank

b we'll scroll down and we have this new

function called get conversion rate

let's grab this one gray and put it in

here whoa

this seems like it's a really big number

we're saying that

one gray

is equal to one two three four five six

seven eight one two three four five six

seven eight nine ten

this many dollars

now i don't know about you but i don't

think the price of even one ethereum is

that many dollars maybe in the distant

future but definitely not right now the

reason that it's off is we have to then

actually divide by

this number the reason that we have to

do this is because both f price and f

amount

have an additional

10 raised to the 18th tacked on to them

so now we have to divide it out in order

to get the right number

so we're going to compile

compile

deploy

confirm

we can scroll down

and now let's try this one way

we'll get the conversion right here

and we can see we get a number that

makes a little bit more sense now

remember this has 18 decimals as well so

the real number is 1 2 3 4 5 6 7 8 1 2 3

4 5

6 7 8 9 10.

and we know that this number is actually

accurate because we can go ahead and

pull up a calculator

pop that into here

and we know that this is one way in us

dollar

if we get the conversion rate

we're saying that this many gray equals

one each

so we can check it back by multiplying

this number by that and we see that we

do actually get the price of one

ethereum in us dollar

so our math here checks out

awesome now since we're on the topic of

math i do want to talk briefly about

some of the pitfalls of solidity

especially when it comes to math prior

to solidity 0.8 if you added to the

maximum size a uint number could be it

would actually wrap around to the lowest

number that it would be and in fact you

can even demo this with a contract here

now you don't have to follow along with

this contract but just watch to see the

example we're going to call this

overflow

dot sol

now in here we're going to add all kind

of the normal stuff

contract

overflow

and we're going to add a function

called

overflow we'll make a public

view and we'll have it return a uint 8.

i'll show you why in just a minute a

union 256 is a really really big number

and it's hard to kind of imagine going

over the maximum cap of a u and 256

but a uint 8 is a lot smaller with the

maximum number actually being 255. so if

we create a uint 8 and we call it

big

equals 255 and then we just do return

big

what do we think we're going to get here

for this we can go ahead and use

javascript vm because we're not

interacting with any other contracts

let's deploy this

and we'll see in our contract if we call

overflow now we're just going to get

255.

however what happens if we add 1 to this

number or try to add 1 to this number if

we do it just like this solidity

actually knows that there's an issue

here and says hey

try not to do this

but if we typecast this as a uint eight

solidity gets a little bit more confused

and goes ahead and lets us do this

now what do we think big is going to be

it should be 256 right

but big is the uint 8 and this is the

maximum size that it could be so what

happens when we deploy this

we look down

we actually get zero

what happens if we do 100 and we deploy

that

we actually get 99

and this is because integers can

actually wrap around once you reach

their maximum cap they basically reset

this is something we need to watch out

for when working with solidity if we're

doing multiplication on really big

numbers we can accidentally pass this

cap luckily as a version 0.8 of solidity

it actually checks for overflow and it

defaults to check for overflow to

increase readability of code even if

that comes a slight increase of gas

costs you can use this unchecked if you

want to have it keep that wrapping

functionality so just be aware if you're

using a lower version than 0.8 you're

going to have to do something to make up

for this and we could write a whole

bunch of code here basically to check

all of our math

or we could just import something called

safe math from another package

similar to how we imported chain link we

can go ahead and

import a package called

safe math

from a tool called open zeppelin

now open zeppelin is an open source tool

that allows us to use a lot of already

pre-built contracts

we can go ahead to the documentation and

go to their utilities and see safe math

and they even have a little sticker here

saying safe math is no longer needed

started with solidity 0.8 safe math is a

tool and a way for us to avoid some of

these problems with doing math and

solidity now i'm not going to spend too

much time on the contracts that actually

fix this but we can actually import

right from the chain link directory as

well

a solidity file called safe math chain

link and what we can do is right after

our contract

we can do using

safe math chain link

for

uint256

and what this will do

is it will use safe math chain link for

all of our unit 256

and safe math chain link doesn't allow

for that overflow to occur libraries are

really similar to contracts except that

they're isolated code that can be run in

a reusable context

in this case we're attaching the safe

math chain link library to uint256 so

that these overflows are automatically

checked for just keep in mind if you're

using anything less than 0.8 you're

going to want to use some type of safe

math just to check for your overflows

now this is for those of you who are

familiar with safe math and integer

overflows and underflows we are not

going to be calling the functions that

safe math provides us like div add mole

you know all those functions simply

because in 0.8 moving forward we no

longer have to use those and we can just

use our regular operators like plus and

minus so this is great our contract is

coming along really well we now have a

way to get the conversion rate of

whatever f is sent and turn it into us

dollar

now we can set a threshold in terms of

us dollar but how do we guarantee that

whatever amount that the users send when

they call fund is going to be at least

fifty dollars well first we might want

to set a minimum value so we can do unit

256

minimum usd

equals

let's say 50

and again since we're using everything

in way terms we want to then multiply

this by 10

raised to the 18th

and just want to take a pause for a

second because this line is actually

wrong this should be raised to the 18th

so this line should really look like

this where it has the double star so

apologies the rest of this has that

single star but it should be the double

star here if you do have the single star

though the rest of the contract will

still work fine so this will be the

minimum value it'll be 50

times 10

raised to the 18th so that everything

has 18 decimals now that we have a

minimum amount how do we actually make

sure that this minimum amount is met in

the value that they send us well if

you're familiar with if statements we

could do something like if message.value

is less than minimum usd

then

revert

or

we could do something a lot easier and

better practice and much cleaner we do

what's called a require statement when a

function call reaches a require

statement it'll check the truthiness of

whatever require you've asked so in our

case the converted rate of message.value

needs to be greater than or equal to

our minimum usd

this line

says that if the conversion rate of

message on value to usd if they didn't

send us enough ether

then we are going to stop executing

we're going to kick it out we're going

to say hey this doesn't count and we're

going to do what's called a revert we're

going to revert the transaction this

means that the user is going to get

their money back as well as any unspent

gas and this is highly recommended we

can also then additionally add a

revert error message something like

you need to spend more eath

so now let's try this out as we saw one

way

is going to be way less than fifty

dollars so if we send one way along with

this fund contract call it should kick

out and say you need to spend more eth

so let's actually try this let's go to

the deploy tab

we'll get rid of our overflow

we use injected web 3 because again we

are working with the chain link

aggregated contracts that are on chain

we're going to move to

fund me

and we're going to hit deploy

metamath's going to pop up and we're

going to hit confirm

now if i try to hit fund

let's see what happens we're getting a

gas estimation

failed since gas estimation error failed

with the following message

execution reverted you need to spend

more eth

so

the contract isn't even letting us make

the transaction we can go ahead and try

to send the transaction but here's

what's going to happen

on ether scan

once this goes through

you can see that once this transaction

finished we got this status fail with

error you need to spend more eth we

don't want to force these transactions

to go through if we look at our metamask

we can even see this failed bit here

so whenever you see these gas estimation

failed errors usually that means

something reverted or you didn't do

something that was required however if

we go to value here and we spend a lot

more

let's say

0.1 ether

which if we take out our calculator 2500

times point one it's going to be 250

dollars this should easily be well and

beyond past our 50 threshold

so let's add 0.1 ether remember we got

0.1 by adding it in the converter and

grabbing the way again the way is the

smallest denomination now if we change

this to way and hit fund this should go

through we're gonna hit fun now you'll

see men and mass pops up because

metamask goes oh yeah this transaction

isn't going to revert and that's what we

want so we can go ahead and hit confirm

and now we'll finally have sent some

funding to our contract

now that this is confirmed we go ahead

and grab our address here

pop it into our address to amount and we

can see that indeed our funding has gone

through

now we can be part of this crowdsourcing

application with our minimum value which

is fantastic awesome great job

awesome so now we can fund this contract

with a certain minimum usd value in this

case it's going to be 50

now you'll notice though that right now

we don't do anything with this money so

we're going to fund this contract

however that's it and we don't have a

function in here to actually withdraw

the money so there's no way that even

though we just sent this contract some

money there's no way for us to get it

back so how do we fix this well we can

add a withdraw function in here so let's

go ahead and add that

function

withdraw

and this is also going to be a payable

function because we're going to be

transferring eth

we'll make this public

and we can do

message

dot sender dot transfer transfer is a

function that we can call on any address

to send eth from one address to another

this transfer function sends some amount

of ethereum to whoever it's being called

on in this case we're transferring

ethereum to message.sender so all we

need to do now is define how much we

want to send well we're going to send

all the money that's been funded so to

get all the money that's been funded in

this contract

we can do address

this

dot balance

now there's a couple of special things

going on with this line

first we're saying address of this

this is a key word in solidity whenever

you refer to this you're talking about

the contract that you're currently in

and

when we add address of this we're saying

we want the address of the contract that

we're currently in whenever you call an

address and then the balance attribute

you can see the balance in ether of a

contract so with this line we're saying

whoever called the withdraw function

because whoever calls the function is

going to be the message.sender

transfer them

all of our money so let's go ahead and

try this let's deploy fundme

and now let's fund this with a lot of

ether so that we can see it we'll fund

it with one whole ether

so that we can see it go into the

contract and get pulled out of the

contract

we'll hit the fun

button and you'll see we're sending one

whole ether into this contract

now if we look at our balance it's gone

down from 17 to 16. or if you're still

at 18 it went down from 18. so let's try

to get it back

if we call this withdraw function now

confirm

once this transaction goes through we

should get all of our ether back

let's look at our metamask and boom

indeed we have got all of our eth back

however looking at this contract we can

see that hmm well maybe we don't want

anybody to be able to withdraw all the

funds in this contract that seems like

it might be a really bad idea maybe we

only want the funding admin to be able

to withdraw funds so how do we set this

up in a way that only the contract owner

can actually withdraw funds well we

learned before

that the require function can actually

stop contracts from executing unless

some certain parameters are met we can

do the same thing here with require

message.sender

equals

the owner

but we don't have an owner to this

contract yet so how do we get an owner

to this contract the instant that we

deploy it well we could have a function

called create owner but what happens if

somebody calls this function right after

we deploy it

well then we wouldn't be the owner

anymore

so we actually need a function to get

called the instant we deploy this smart

contract and that's actually exactly

what the constructor does so typically

at the top of your smart contracts

you'll see a constructor

and this is a function that gets called

the instant your contract gets deployed

you don't even need to do add function

here we can literally just call it

constructor

because it's what constructs the smart

contract so we'll make constructor

public and whatever we add in here will

be immediately executed whenever we

deploy this contract so one thing that

we could do

is we could have an owner be set the

instant we deploy the smart contract so

in the top we could add address

owner

and in our constructor

we could say owner equals message.sender

because the sender of this message is

going to be us it's going to be whoever

deploys this smart contract we can even

test this out in the javascript vm to be

a little bit quicker because we're not

actually going to be calling the fund

or the getprice function for now oops

let's also make this public so that we

can interact and see this owner variable

so now if we go to fund me we deploy

this in the javascript vm we should be

able to see who the owner of this

contract is and it should be our address

because this constructor function should

have been immediately called the instant

that we deployed the smart contract

awesome we can see the owner of this

smart contract is indeed our wallet

because remember we're working with the

javascript vm our wallet is these fake

wallets that they kind of give us

we can even try this with an injected

web 3

with deploying this

and the owner

should be this

ox 757 etc address

let's go ahead and look at fundme see

the owner and we do indeed see the owner

is us okay great

now we have an owner

we can go down to our withdraw function

and use that same require

so we can call

acquire

message.sender

equals equals

owner equals equals is the way that

solidity understands true false we're

saying that message.sender has to equal

owner now let's go ahead and try this

and we'll try with the javascript vm

again for speed reasons

let's deploy this funding

and if we go down here

we try to call the withdraw function and

it looks like it is successful because

currently

this is the address that deployed the

contract and it's also the address that

is calling withdraw

however

if we switch to a different account

and call withdraw you'll see

that remix actually freaks out down here

it says uh oh something wrong happened

and this is essentially the require

statement kicking out if you want to try

it with injected web 3 as

well can absolutely do that too and

remember the way to switch accounts in

metamask is to either create a count

right here or just switch like this

and then we'll connect with account two

so if i try to withdraw

from this

second account

that didn't call the contract and i hit

withdraw now

it's going to give us gas estimation

failed because the required statement is

going to kick out but again if we switch

back to account 1

and we call withdraw

metamask is going to pop up and it's

going to allow us to withdraw now

obviously there's nothing in this

contract right now so we're going to

withdraw nothing but we can still call

it it's going to do message.transfer

0.

so this is great

we can now require this withdraw

function is only callable by the owner

now what if we have a ton of contracts

that want to use something like this

they require the message.sender to be

some owner or maybe it's more

complicated than this is there an easier

way to wrap our functions and some

require or some other executable well

this is where modifiers come in we can

use a modifier to write in the

definition of our function

add some parameter that allows it to

only be called by our admin contract

modifiers are used to change the

behavior of functions in a declarative

way let's create our first modifier

we'll call it modifier

which is a keyword

only owner

and we'll add this require statement in

here

require message.sender equals owner

then after this we just add an

underscore and a semicolon

what a modifier is going to do

is it's going to say hey before you run

this function do this require statement

first and then wherever your underscore

is in the modifier run the rest of the

code

so we could also do a modifier where the

underscore is up here and then this is

afterwards but but we want to run the

require first

so now what we can do

is we can make this function withdraw

payable

only owner public

and what's going to happen

is before we do this transfer we're

actually going to check

this modifier we're actually going to

run this require message.sender equals

owner and then again where this

underscore is that's where we'll add the

rest of the function

so again

for speed reasons and since we're not

actually going to be interacting with

the chain link data contract we can go

to javascript vm

switch to funding

deploy

and we can call withdraw

obviously we can call withdraw from our

account but if we switch accounts and

try to call withdraw

we're going to get an error which is

perfect because that means our modifier

is working correctly

awesome now we have a fantastically

succinct fund me contract here

the only thing that we're really missing

is that when we withdraw from this

contract we're actually not updating our

balances of people who funded this

so even after with we withdraw this is

always going to be the same so we need

to go through all the funders in this

mapping and reset their balances to zero

but how do we actually do that we can't

actually loop through

all the keys in a mapping when a mapping

is initialized every single key is

essentially initialized now we obviously

can't go through every single possible

key on the planet

however what we can do is create another

data structure an array something we're

already familiar with so let's go ahead

and create a new funders array that way

we can loop through them and reset

everyone's balance to zero we'll do an

address array

because it's going to be an array of all

the funders addresses

we'll make it public

and we'll call it

funders

now when somebody funds a contract

what we're going to do is we're going to

do funders

now whenever a funder funds this

contract we can go ahead and push them

onto our funders array

so we can do funders

dot push message dot sender

now if somebody funds multiple times the

funders array is going to be a little

bit redundant but we're going to ignore

that for now now that we have an array

of funders when we withdraw everything

we're going to want to reset this to 0.

when we withdraw everything we want to

reset everyone's balance in that mapping

to 0. so we're going to do what's called

a for loop a for loop is a way to loop

through a range of numbers to do

something so we're going to say

4

you and 256

funder index

equals zero because we want to start

with the zeroth index

we're going to give it a max size to go

to we're going to say the funder index

has to be less

than funders dot length

dot length is how we get the length of

our array

and then we're going to say funders

index

plus plus this means that we have an

index variable called funder index

and it's going to start from zero

this loop is going to finish whenever

funder index is greater than the length

of the funders

every time we finish a loop we're going

to add one to the funder index that's

what that funder index plus plus does it

adds one to the funder index and every

time whatever code is in this for loop

executes we're going to restart at the

top and all we're going to do in here is

we're going to grab

the address of the funder

from

our funders array

funders

so the funder

at the index in our funders array

we're going to use this

as the key in our mapping

so we're going to take

address to amount funded

of funder

and we're going to set it equal to zero

so now our mapping is going to be all

updated to people having xero funded in

there

we do have to do one more thing as well

we have to reset our funder array as

well

now there's a couple ways to do this but

a really easy way is just to

set funders equal to a new array so we

could do funders

equals a new

blank

address array

so all right it looks like we've got

everything in here we need right away

when we deploy this we are set as the

owner

we can allow anybody to fund whatever

public good that we're doing

and they have to fund it with the

minimum usd value that we actually set

whenever they fund we'll keep track of

how much they're funding and who's been

funding us we can get the price of the

ethereum that they send in the terms of

usd

and we can convert it to check to see if

they're sending us the right amount

we have our only owner modifier so that

we're the only ones who can withdraw

from the contract and when we do

withdraw everything from the contract we

reset all the funders who have currently

participated in our crowdsourcing

application

awesome let's see if everything works

end to end

so we're going to go to fundme

we're going to deploy it

we're going to confirm from metamask and

remember if you're ever confused about

what's going on or or something weird is

happening in your transactions or your

deployments you can always go into

etherscan and read more about your

transaction and what's going on

now that our transaction has been

deployed let's go ahead and just take

inventory as what's going on

we have our owner

which is our address right here

we have the aggregator v3 interface

version which is version 3 which we can

kind of ignore

we have the price of ethereum in terms

of usd

with 18 decimals instead of 8. we have a

function that allows us to get the

conversion rate of any ethereum amount

to its us dollar equivalent

we have an array of funders which right

now starts out as empty

we have a mapping of addresses which

also right now starts out as empty let's

go ahead and try to fund this contract

we'll use way just that we're always on

the same page

and we'll fund it with 0.1 away

remember everything has 18 decimal

places so if we want to do 0.1 we just

do 17. so we can do one one two three

four five six seven eight one two three

four five six seven eight nine and

that'll be 0.1 ethereum now we can go

ahead and hit fund

and we're going to send 0.1 eth to this

contract

great so if we look at the zeroth index

of funders we can see that indeed

we have funded this contract

let's even have

our second account fund this contract

so all we got to do is switch

to this contract in metamask

we can go ahead

and put point one eth back in here

for value

and hit fund

now as you can see we're deploying this

from account two

let's go ahead and hit confirm

funder at index zero is going to be our

admin and the funder at index one is

going to be our second account

and if we go ahead

and we add

this funder in here we can see we've

indeed sent point one ether with this

account if we go back to our count one

and put this in here

we can see that that address also has

0.1 ether

fantastic

so let's try to be malicious let's try

to have account number 2 actually

withdraw all the funds in here

let's hit this withdraw function

uh-oh

the transaction has failed we're

relentlessly malicious we want to send

this transaction regardless so even

though i'm not the admin of this

contract i've gone ahead and still tried

to send those withdrawal so what happens

now

we can see that remix is saying hey

something went wrong

and again if we look at ether scan we

can see that there is a fail here since

in our modifier we didn't give a reason

here

nothing shows up but we could have

always put a reason in there and

something would show up

so all right let's go ahead back to the

actual admin

and now let's try to withdraw everything

so if we hit withdraw now

we can go ahead and confirm what should

happen is everything in here should be

back to zero and this array should be

back to zero as well and if we watch our

address we can see it literally just

went from point four to point six

because it got point one from the

original funding that this account put

in

and the 0.1 that our second account put

in

so now if we look at funder 0 we can see

it actually errored because it is now a

brand new array and there is nothing at

index zero if we try to see how much

this address now is funded it's back

down to zero awesome you've now learned

how to deploy a relatively simple yet

effective crowdsourcing application

where users can fund and an admin can

withdraw those funds to go spend them on

things

now we've been working with remix so far

to start our smart contract in our

solidity development journey remix is an

incredibly powerful what's known as a

web ide or an integrated development

environment and in my opinion remix

should always be the starting ground for

anybody looking to start their smart

contract journey because it is a

wonderfully friendly way to really show

what's going on behind the scenes and

it's really easy to see everything we're

doing with ethereum with chain link and

with our smart contracts now it does

have some limitations though it's really

hard to integrate other parts of

different projects it has some limited

support for testing or custom

deployments it's a little tricky to save

files locally you need an internet

connection to actually interact with it

and it doesn't have python so in order

for us to deploy test and automate

everything about our smart contract

development cycle we want to connect our

solidity and our smart contracts with a

more traditional programming language

like python this way we can customize

our entire development environment in

any way that we like we're first going

to teach you all how to work with what's

known as web3.pi which is an incredibly

powerful python package for doing

everything that we want to do with smart

contracts then once we learn some of the

basics of web3.pi then we'll move on to

browning which is a smart contract

development framework built on top of

web3.pi which makes our lives even

easier however it's still really

important to learn web3.pi first because

this will teach you what's going on

behind the scenes of brownie

now for the rest of this course i'm

going to be working with visual studio

code which is an incredibly powerful

text editor that will give us a lot of

formatting and a lot of really nice

tools to work with deploying and

interacting with our smart contracts if

you've already got vs code and python

and your entire coding setup set up the

way that you like it feel free to use

the timestamps in the description to

skip ahead to the next section you'll

often hear people referring to this as

vs code or visual studio code but just

to point out this is not what you're

looking for right in front of you here

visual studio is a different application

make sure you're on visual studio code

if you want to be a total hardo and just

work with vim or emacs or whatever else

you want to do you absolutely can but

i'm going to go through setting up

visual studio code the way that i like

it and if you guys want to follow along

i highly recommend it because it's going

to make your life a lot easier there's a

link to download visual studio code in

the github repository basically all you

have to do is come to the site right

here and you can hit this big download

button it should recognize what

operating system that you're on be it

windows be it mac or some other

operating system and if it doesn't you

can go ahead and hit this little drop

down and pick one there so let's go

ahead and download visual studio code

and open it up

awesome once you've downloaded visual

studio code this is approximately what

you should be seeing

there's a fantastic getting started

section here where if you're brand new

to vs code and you want to learn a

little bit more quickly you absolutely

can and we have some links as well in

our github repository giving you a crash

course in vs code if you want to learn

more let's set this up though so it's

going to be really friendly for us to be

doing our smart contract development

here so first we want to go to this

extensions tab it looks like these

little blocks thing right here

and first we're going to look up python

and you want to install this python

extension right here this is going to

make our lives a lot easier for

interacting with python and doing a lot

of things with python

then you're going to want to go ahead

and download this and install this

solidity extension this is going to make

formatting our solidity a lot easier now

we want to download python if you

haven't already so go ahead to

python.org

let's go to downloads and it should

recognize what operating system that

you're on and you can just go ahead and

hit the download button and then follow

the steps to download this i've already

got it download so i'm not going to walk

through this

okay great now that we have python

installed one of the other amazing

things about vs code is you can actually

open a terminal up inside a visual

studio code the way you can open your

own terminal if this is your vs code

you can go over on this top bar to

terminal

and select new terminal

and you'll see something that looks like

this

it might be a bash it might be a zch it

might be a powershell there's a lot of

different types of terminals that you'll

be able to see by looking right here we

can now test to see if python is

installed correctly if we type in python

space

dash dash

version

we should get something that looks like

this the exact version of python doesn't

really matter here but ideally you're at

least on python 3.8 if python dash

version doesn't work you can also try

python

3-version now if neither one of those

works we actually have a number of

troubleshooting tips in the github

repository for this course and

oftentimes a quick google search on

whatever error that you have you'll get

a link which will lead you to the answer

but if that google search doesn't lead

to the answer then just go ahead and

drop an issue or conversation associated

with your issue on the github repo

associated with this course in

particular there are a couple of common

errors that i've definitely seen a

number of times so if you see an issue

on your instance that matches something

on the screen here definitely 100 be

sure to check out those troubleshooting

tips sometimes just installing some of

these applications is really the hardest

part of doing the entire coding journey

here so please make sure you have python

and vs code installed correctly before

moving on and don't be discouraged if

this doesn't work exactly the way that

it should right away now if you're on a

mac you can actually hit control back

tick and it will toggle back and forth

between having the terminal open and

closing it i find this really helpful

and i use it all the time instead of

hitting

the buttons a key tip for productivity

is going to be using keyboard shortcuts

instead of clicking around all the time

you'll be much faster okay great we have

python installed we have python and

solidity extensions of visual studio

code installed let's start working on a

new project so in our terminal so in our

terminal we can create some folder i've

already created a demos folder here

you can create one as well if you'd like

by doing mkdir

demos

since i've already done it the file

already already exists

and then cd into demos

you can type clear or if you're on a mac

command k to clear the terminal now

here's what we're going to be doing

we're going to be working with

simple storage again the exact same

contracts but instead we're going to be

using web3.pi

so we're going to make a new directory

inside of our demos folder slash

directory called web3

pi

simple storage

and we're going to cd

into this new

folder right here now again all the

completed code is going to be in our

github and there's going to be a link to

everything that we do in this folder in

this github so you can always refer to

that if you get lost and the next thing

that we want to do is we want to have

our visual studio code know that we're

in this folder so we can go ahead and

click this files icon and hit open

folder

and i'm just going to go to this web 3

pi simple storage and hit open and

another vs code will actually pop up we

can see on the left hand side here

we have a folder this will show all the

different files and folders in our web 3

pi simple storage directory let's go

ahead and create a file

dot sol we can right click on this area

and select new file and do

simple

storage

dot soul and then we can go back to our

simple storage dot soul in remix copy

everything and then paste it into here

if you don't have it up remember you can

always refer back to the github

repository which will have it in there

for you awesome now we have our solidity

in its own file called

simplestorage.soul you'll notice that

some of the words are actually

highlighted different colors this is

known as syntax highlighting and it's

due to the fact that we added the

solidity extension in it makes reading

this code a lot easier now this file is

in here we'll see that we have this

little dot here

whenever you see this little dot this

means that your vs code file isn't saved

so we want to always save it otherwise

when we compile or we go to write a

script things might not work correctly

so we can save it by going up to file

and then selecting save or again you're

going to want to learn how to do the

keyboard shortcuts because you're going

to want to hit save often for mac it's

command s and for windows it's ctrl s

now the other thing that you'll see is

you get this red line here this is vs

code's way of telling us it thinks that

there's an error at this position so

this is really just the extension being

a little bit confused here and we can

safely ignore this and normally when i'm

coding i do just ignore it we're often

going to be flipping back and forth

between compiler versions so oftentimes

this isn't really a helpful warning here

but if it is really bothersome you could

right click it and do something like

solidity change global compiler version

or we can go to code

preferences

settings

let's close this so we can see some more

things in here we'll look up solidity

and we'll come to this solidity

extension config what we can do then is

scroll down

and we can see solidity compile using

remote version this will allow us to

choose what version we want to compile

with if we do 0.6.0

and hit save

and go back to simple storage you'll see

the red line is now gone while we have

this up another really helpful piece

that we can do here is we can add what's

called a formatter so if we scroll down

to solidity formatter you'll see that

this enable slash disables the solidity

formatter we can go from none to

prettier then we'll also look up format

on save and we want to make sure we have

this editor format on save check marked

what we can do then is we can come over

to simplestorage.sol

and

maybe i've got some bad formatting in

here we'll move over favorite number

string name and put a whole bunch of new

spaces in here or something

now if i hit save it automatically

reformats our file to look a lot nicer

so to recap we want to turn on format on

save and if you get issues with a red

line under pragma solidity you can just

change the compiler version in your

settings here now while we're in here

we're also going to go ahead and set up

our python formatting as well

so the first thing that we're going to

do is we're going to install the black

python formatter so we're going to open

up our terminal here

and whenever you install python it comes

pre-installed with this package called

pip to check to see if you have pip

installed correctly run pip dash dash

version

now we can install the black formatter

by running pip

install

black

i already have it installed so it's

going to be pretty quick for me

then we'll come to our settings

and we'll look up

python

formatting

and we'll scroll down

to python formatting provider you might

have autopet bait or none in here you're

going to want to change it to black

this way whenever we save our python

files now they will also get

automatically formatted to be very

readable and really nice and just to

note for my demos in solidity i don't

always have format on save for solidity

i do have format on save for my python

but i'm still going to highly recommend

you have format on save for both your

python and for your solidity anyways so

how are we going to actually deploy this

well this is where our python is going

to come into play

let's go ahead and create a new file on

the left here

and we'll call it

deploy dot pi now let's go into this

deploy.pi file and let's start actually

figuring how we can deploy this in

python and this is the part of the

course where we start using python here

if you're unfamiliar with python or a

little bit weaker on python there is a

fantastic free code camp course that

goes through all the basics of python if

you want to learn more i definitely

recommend checking it out however we are

going to walk you through all the

scripts that we write anyways so don't

be afraid to just jump in and follow

along with what we're doing here even if

you have no experience so the first

thing that we're going to want to

actually do is read this simple storage

solidity file we need to get this into

this deploy script so that our python

file knows what it's going to deploy so

how do we do this well we're going to

type with

open

quote dot slash

simple storage dot sol

comma r

as file

simple

storage file equals file dot read now

what is this actually doing

well it's saying that we're going to

execute some code

inside this indented area

after the colon and then once this code

is finished we're actually going to

close this file because right now we're

opening it we're going to close it once

it's done

the file that we're going to open is

going to be this simple storage.sol

which is located right here in this same

directory that we're in we're going to

only read from it and we're going to

call it file and then we're going to

read all the contents of this file and

place it in a variable simple storage

file

so then we can go ahead and write a

print statement print simple storage

file and if you hit save here you'll see

that it automatically gets formatted

which is really nice if you want to run

black yourself you can just type black

dot and it'll automatically format all

the python files in your folder here

you'll know that you're doing it right

if you add a whole bunch of new lines

and then save it anyways enough on

formatting let's head on down to the

terminal and let's call python deploy.pi

and we can see

our terminal printed everything in

simple storage file

which is perfect now our python script

has what it needs to actually get

started working with our solidity now

something you'll see i do a lot is i

save a lot and if you're looking for

some keyboard shortcuts you can always

do command p add a little bracket here

and look

up keyboard shortcuts reference

and click this

it'll bring you to this keyboard's

reference page based off of what

operating system that you have all right

great so now that we can actually read

from our simple storage.soul file we

actually have to compile it because

remember back in remix every single time

we did anything with our files we had to

compile them first

so we need some compiler in python

luckily there is a fantastic python

package called pi silk x that does

exactly this now i also want to point

out though that pi silk x is actually a

fork of this package called pi silk now

you can still use pysol however i'm

going to highly highly recommend that

you use pi silk x instead as pike sulk x

is a lot more actively maintained than

ethereum pixel we can install it with

pip install pi sulk x we could even hit

this little copy button move back on

over here paste it in and hit enter

again i've already installed it so it's

pretty quick for me the way that we can

use it now is by importing it into our

python here so we'll say from

sulk x

import

compile

standard compile standard is going to be

this main function that we actually use

to compile this code so let's go ahead

and compile

our solidity

we're going to save our compiled code to

a variable called

compiled soul

this is going to be equal to

us calling this compile standard

function

but we're going to add a lot of

variables and a lot of parameters into

this function here first we have to add

is a language

which in this case is

solidity we're going to add in some

sources

which we're going to say our sources are

going to be simple

storage.soul

and it's going to have some

content which is equal to this simple

storage file variable that we made

oh excuse me this all has to be in a

bracket piece as well

and see if i hit save here it auto

formats which is really nice and another

quick tip you can see how even my

brackets are highlighted in these fun

colors if we go down to extensions and

look up

bracket

you can add this bracket pair colorizer

which will help make the brackets look a

little bit nicer kind of as you see here

you can go ahead and install that as

well anyways then we'll add some

settings

and a lot of this is a little bit lower

level stuff than what you're really

going to have to know or use so i'm not

going to go too deep into everything

that's actually going on here for now

but in our settings

we're going to choose an output

selection

which is going to choose what we output

when we compile this

we do a little star here

and in the star we're going to do

another star

we're going to choose our output list

we're going to get an abi out that's

incredibly important which we've talked

about before

we're going to get some metadata

we're gonna get an evm dot byte code

we're gonna get an evm dot

source map

that's pretty much it again i'm not

gonna go too deep into what this output

selection and what these settings are

actually doing but if you want to learn

more you can go to the home page of pi

sulk x

scroll down to the documentation section

and read more in the docs on what you

can actually put and all the different

features that this actually has the last

thing we're going to do is we're going

to add a sulk version or solidity

version we're going to say

sulk

version

equals and then we'll choose the version

that we want to use so we'll put in

0.6.0

and then what we should be able to do is

print out

this compiled soul

and we'll see just a whole bunch of

really really low level stuff

so let's go ahead and run this we'll run

python

deploy.pi

and you'll see we get this

massive object here which has a whole

bunch of basically unreadable pieces but

this is a lot of the low-level code that

actually gets compiled whenever we use

the compiler in remix or now in python

remix actually does the exact same thing

once we compile something on remix you

can actually copy the bytecode if you

hit this little

copy button and copy the bytecode and

come back to your vs code and create a

new file a keyboard shortcut to create a

new file is command n and we paste

everything

we can see there's a whole bunch of

stuff in here these op codes are the low

level code that our contract is actually

doing that actually governs how this

code works this is what our written code

is getting compiled down to so solidity

can actually read it and understand

what's going on you'll also see this

thing called abi which is in remix and

we're even going to output it right here

we have this abi thing now in remix if

you hit copy the button on the api

come back

create new file paste it you can see we

have this long json object this is that

application binary interface that we've

talked about so much you can see that

it's actually describing all the

functions and variables

so for example

we have a function

called add person

and it takes two parameters a name

and a favorite number

so we have this input section for the

function and we have this section that

describes what the function can is

actually doing so the name is ad person

it doesn't have a return type it's

non-payable and it's a function and we

can see that for pretty much everything

in here this is the lowest digestible

way to say hey here's where all the

functions are here's what the parameter

types are here's what the return types

are going to be and everything like that

so we're going to close it out for now

though so this is fantastic we've now

compiled our solidity typically i

usually also like to output it and print

it out to a file as well so to do that

we'll do with

open

compiledcode.json

and this time instead of reading we're

going to write

and we'll call this as file as well

instead of doing file.write we're going

to do what's called a json.dump

compiled soul file

we do need of course to import

json also just a note i know it says

we're using sulk here but please use

sulk x still i ended up filming a little

bit of both versions so i did a little

bit of a mix and match but please use

sulk x even if you see seoul what this

line is going to do

is it's going to take our compiled soul

jason variable and just dump it into

this file here

but it's going to keep it in the json

syntax so it's still going to be json e

so now if we run python deploy.pi we'll

see we have a new file in here called

compilecode.json

the other reason that i wanted to do

this was because

if i hit control s

it actually formats this into a readable

way now again we can go into these

settings here

we can look up

json and we can do enable json formatter

and this will automatically make it so

that we format this json so it's a lot

more readable again the reason i like to

output this is because this abi is so

important and we're going to use it so

much that i like to kind of be able to

see it and and read through it really

quickly the rest of this lower level

stuff like evm and byte codes and op

codes we don't really work with so much

however as you learn more and more about

solidity you'll probably see more and

more of opcode so if you really want to

learn a lot of really low-level stuff

look into opcodes but for the purpose of

this tutorial we're not going to be

going too deep into it okay awesome so

we've compiled our solidity we've even

stored our solidity code to this

compiledcode.json file

now what do we do we probably want to

deploy it and test it out

so how do we actually do that well first

we actually have to get the bytecode we

need the bytecode of the file so that we

can actually deploy it so we're going to

do

bytecode

equals

compiled soul

contracts

simple storage dot sol

simple storage

evm

white code

object

all right great there we go so now we

have our byte code we also need to get

our abi so we need to get the api so

what we're doing here when we're typing

in all these words like contract simple

storage simple storage

is we're walking down the json here so

when we say we want to get the byte code

in this compiled solidity json we want

to go to contracts

simple storage symbol storage evm byte

code

so contracts inside this contracts json

you got to go to simple storage inside

this simple storage dot soul there's

another simple storage

inside that there's an avi but that's

not what we want we want the evm so

we're going to scroll down

we're going to get the evm then what do

we want then we want the bytecode great

and then we want the object so this

is the bytecode of our contract

it's the really low level stuff that

the ethereum virtual machine or the evm

is going to understand now we also need

the avi when we deploy this to a chain

this is what we're going to need we need

the byte code and the abi the abi we can

of course get from this kind of same

method here so to get this we can do abi

equals

compiled soul

same thing

contracts

simple storage dot soul

simple storage

and as you can see

we're right here and then we can just

grab this api object

avi

and we can even do print api we'll do

python develop.pi

and indeed our abi is printed here

awesome so now that we have our two main

pieces to deploy this now all we have to

do is deploy it but the question then

becomes is where are we going to deploy

it to which blockchain are we going to

deploy to in remix

when we were first playing around

we were using a javascript vm

or a fake or a simulated environment we

absolutely could and we absolutely will

learn to deploy this to a test in

because that's going to be the same way

that we're going to deploy to a mainnet

but before we do that we should learn

how to deploy this on a simulated

environment or something similar to that

javascript vm so it's much faster and

easier to test things and this is where

ganache is going to come to the rescue

ganache is a simulated or a fake

blockchain that we can actually use to

deploy our smart contracts to and have

it interact like it's a real blockchain

ganache is going to allow us to spin up

our own local blockchain

and it'll look something like this now

the user interface is really nice

because it allows us to kind of do this

one-click blockchain to create our own

local blockchain

that means that this blockchain isn't

connected to any other blockchain out

there but it'll act like a blockchain

but it'll be a lot faster than us having

to interact with a testnet and we

control the entire blockchain because

it's only one node we're the only node

so ganache great way to test things

quickly now we're going to mainly we're

working with the user

but i'm also going to show you how to

work with the ganache command line you

can really use either one depending on

what you want to do but a lot of the

tools actually have built-in ganache

command lines so it's definitely really

useful to learn that as well so again

ganache is going to be our simulated

environment here so what we're going to

do

once we get into ganache we can just go

ahead and hit quick start this will

automatically upload and get started

with our own local fake blockchain you

can even see it gives us some accounts

this should look pretty familiar it

should look very meta-masky right we

have an address here

and each one of these addresses has a

private key in your ganache you can go

ahead and just click the key and hit

show keys and it'll show you the account

address and the private key but of

course these are for development

purposes only each one of these accounts

has a balance associated with it we can

see a mnemonic or your secret phrase you

can see blocks transactions and a whole

lot of other really useful features here

and it even tells us

how to connect to this blockchain

and these are the connecting features

that we're going to want to use let's

learn how to connect to this ganache

blockchain from this user interface

first and then we'll learn how to do the

command line version this is when we

finally start working with web3.pi you

can just do pip

install

web3

and now we can start working with

web3.pi right at the top a little

confusingly

we're going to do import

web3

from

web3 whoops and this should be

from web3 import web3 sorry about that

now to connect to this blockchain we

choose what's called an http provider if

we look at this ganache instance we have

this rpc server which has this url http

0.0.0

this is the url that we're going to use

to connect to this blockchain in remix

we're actually using our metamasks

directly to connect to the blockchain

however we want to connect directly to

our simulated our fake blockchain right

here so what we're going to do is we're

going to do

w3

for

connecting to ganache

w3 equals

web3 web3.http

provider

of http

0.0.0.0

and it was on port

845.

port 845. now with everything that we

show you you're probably going to want

to get really familiar with the

documentation because even after being a

pro you're going to want to use it more

and more if you want to learn more about

other providers you can go to the

providers page of the documentation the

next thing that we're always going to

need as well is we're going to need the

chain id or the network id what is the

id of this blockchain

and for ganache it's one three three

seven

supposed to be a funny leat reference so

we'll do chain id

equals

one three three seven

now

we're also going to need an address

and address to deploy from

we can go ahead and grab one of these

fake addresses in here to work with

similar to how in remix when we were

working with the javascript vm we were

given a bunch of fake addresses we're

doing the same thing but with ganache

and then we're also of course going to

want a private key

we need the private key of course to

sign our transactions

so we'll do private key equals

this

now just note whenever you import a

private key in python you need to add an

ox to the front python is always going

to look for the hexadecimal version of

the private key awesome now we have all

the parameters that we need for

interacting with and connecting to our

ganache local chain it's time to finally

deploy our simple storage.soul contract

let's do it so the credit contract that

we're going to deploy with web3.pi we're

going to do simple storage

we're going to call this variable

w3

dot f

dot contract

and we're going to give it abi equals

abi

and byte code equals byte code great

does this mean we've deployed it well no

this just means we have a contract down

so we can do print simple storage and

you'll see if we run python

deploy.pi

we'll see we have a new type here

class web3.utils.datatype.contract

this is another type that if you want to

learn more you should definitely check

out the web3.pi documentation so we have

a contract object

awesome how do we actually deploy this

well we need to actually build our

transaction

because again whenever we interact with

the blockchain whenever we make a state

change and in this case we'd be

deploying a contract we're going to make

a state change so we first need to build

a transaction sign a transaction

and then send a transaction and to do

that we need to talk about that nuns

thing again remember way back in our

blockchain demo when we used a nuns to

solve the answer to that really

difficult mining problem well the

definition of nuns is just a word coined

or used for just one occasion and in

cryptography it's an arbitrary number

that can be used just once in a

cryptographic communication so this nuns

that's used to find the answer is going

to be different from another nuns that

we're actually going to need to make our

transaction see if we look at our meta

mask and we look at our activity

and we look at one of the transactions

we've made recently on etherscan

if we scroll down we'll see nuns

here as well this nunce is the number of

transactions that our account has

actually made every time we make another

transaction our transaction is hashed

with a new nuns this is what's going on

behind the scenes with our transaction

and we need this to send our transaction

we can actually get our nuns by just

grabbing our latest transaction count

get

the latest

transaction we can do

nonce equals w3

dot eth dot

get transaction count and we'll put in

my address

this will give us the number of

transactions and it'll effectively give

us our nuns

we can even test it out with a print

python

deploy

we can see we can see that the answer is

zero because on our local blockchain

this address that we're using hasn't

been used before we can even go to the

transactions tab we can see that there

are no transactions that have ever

occurred on our local blockchain now to

deploy this contract we need to make a

transaction remember everything that we

do every time we change the state of a

blockchain we're going to do it in a

transaction let's create a transaction

object to do this we can do

transaction

equals

symbol storage which again is this

contract object

dot

constructor

dot build transaction

now as you might have pointed out our

simple storage.sol doesn't actually have

a constructor every contract technically

has a constructor this one's is just

blank we're not telling our simple

storage.soul to do anything

we saw back in our fund me

example that the fund me example does

have a constructor so now we want to put

in some parameters for the transaction

in web3.pi we always have to give at

least a couple of parameters

we always have to give the chain id

which we already got from above which is

one three three seven

so we can just do chain id

we need a from

address in this case

my address

and then

we need a nuns

which in our case is just nuts

great now we have a transaction object

let's even print this out and see what

it looks like

whoa what's this we can see there's even

more parameters in here than just what

we made

so we have value which is the ether or

the ethereum that we're going to send we

have gas we have our gas price which we

could arbitrarily set if we'd like

we have the chain id we have from

address we have the nuns

and then we have this giant data object

and then two is just empty because it's

sending it to the blockchain this giant

data object here is encompassing

everything that's happening in this

simple storage dot sol now that's just a

transaction and anybody could actually

send this transaction as long as it's

signed by them so we have this

transaction but we need to sign it from

somebody since we're sending it from our

address

our private key is going to be the only

key that's going to work to sign this

remember back when we were talking about

public and private keys we right now

have a message that is defining how to

deploy simple storage but it's not

signed yet so we're going to need to use

our private key to sign it to create

this unique message signature that we're

the only ones that can create the

private key but anybody else can verify

that it was us who signed it so now

signed

transaction

equals web3

dot eth

dot account

dot sign transaction

and the parameters it takes are going to

be transaction

and then private key

we're gonna say the private key equals

private key because above we've actually

gone ahead and added our private key in

here now guys a really really important

note about putting a private key in your

code this is really bad practice if you

push this to source or you push this to

github somebody else can see your

private key and steal all your funds so

we don't want to hard code our private

keys in our code like we're doing here

so let's take this time to talk about

environment variables and how to set

them environment variables are variables

that you can set and that we set in our

terminal and in our command lines the

following is a way to set an environment

variable in macos and linux only don't

worry we'll show a way to make an

environment variable in windows as well

you can set an environment variable by

running something like export

private key

equals

and then adding whatever variable that

you want

now if you type echo

dollar sign private key

this variable actually shows up to set

environment variables with windows the

process that we're going to do is

actually a little bit different

i've left a link in our github to

actually set environment variables in a

windows setting

and we've left a couple of really

helpful links for working more with

environment variables you should

definitely check them out it's important

to note that this export method that

we're doing here for creating

environment variables only works for the

duration that our shell is live so if we

were to close out of our shell and then

reopen it our environment variable that

we set would be gone so we'd have to

re-run that export command we're gonna

show you a way to set environment

variables so that you don't have to keep

doing that now it's also not great to

have in plain text on your computer

however it's a lot better than hard

coding it into our script here now

remember if you're using an account that

has real money in it which i highly

recommend you do not do don't send this

environment variable or this private key

or any of this code anywhere because

then people can steal all your funds

once we move to brownie we'll show you a

more effective way for private key

management but for now be cautious here

but if you followed along and set up a

brand new account that has no real money

and only test that money in it then

great who cares because it's test and

it's fake money anyways

i think i've talked about it enough

anyways let's get back to it we can

actually access this environment

variable in python using os.get env

we just need to import os

and now we can access our private key in

our script without actually hard coding

it in

let's see what happens if we do print

private key python deploy to pi

you can see our python script was able

to pull our private key from our

environment variable the other thing

that we can do is create a dot env file

a dot emv file is typically where people

store environment variables it's

important to not push these to source if

this is what you're going to do in this

dot envy file in python we can just do

export

private key and then same as what we did

before

add the 0x at the start and then private

key so we could put 100 environment

variables in here

export

some

other var equals

seven

if you're going to do it in this way

please please please

always set a dot git ignore

and make sure dot env is in here this

will help make it harder for you to

accidentally push your env folder or

your emp file to github python actually

has a way of loading directly from a env

file without having to export our

environment variables or run source.env

or export or really anything and we can

do it with this python.env package

if we close our shell and then reopen it

if we run echo

some other var

we're going to get none here and in fact

if we run

python develop.pi when we print this

environment variable we're going to get

none

however we can use this.env to have it

pulled directly from our.emv so we just

do pip

install

python.env

i've already downloaded it so it just

says requirement already satisfied and

then

what we can do at the top of this we can

do from

dot env

import

load.enb and we can run

a load.enb function right at the top

this load.env looks for this.env file

and automatically imports it into our

script so if we run this now you'll see

that the environment variable was

successfully imported into our script

and now we can use it so let's let's use

it for example with our private key

private key

equals os that get

private key now we can even print it out

just a test

we'll run our script

and awesome

we can see our private key is being

successfully pulled in and we didn't

hard code it into our application

all right let's get back down to our

signed transaction here now let's go

ahead and print this out and take a look

at what this looks like now we can run a

script and great what we see here is an

example of a signed transaction remember

this is exactly what's happening when we

were looking back at public private keys

we are signing a transaction that is

actually deploying a contract to the

blockchain that anybody can easily

verify all right so we finally have our

signed transaction now we want to send

this to the blockchain so it actually

can deploy let's send

the signed transaction

we can do transaction hash

equals

web3.eth

here's a little helpful tip if you see

this little box underneath with

suggestions show up and you just hit tab

it'll auto complete the rest of your

text here that's send raw transaction

and we'll give it

our sign transaction

dot

broad transaction this will send our

transaction to the blockchain now if we

look at our local ganache and we look at

transactions right now it'll be empty

but let's see what happens when we run

this script

okay so we didn't print anything out but

if we go to our ganache we can see that

a transaction actually did go through

it was from the address that we put in

here we created a contract at this

address

this is how much gas it used

and this is how much value was sent with

it we can even click on it to see more

information about this now this is the

other advantage of doing this locally is

that the transaction automatically went

through we've sent our first transaction

to a local blockchain and this

transaction is deploying a contract

great work you can already see how much

faster this is than working with a test

net one other thing that's really good

practice whenever sending a transaction

is we wait for some block confirmations

to happen

so we can do

transaction

receipt

equals web3 dot eth

wait

for transaction receipt

txhash

this will have our code stop and wait

for this transaction hash to go through

awesome so i just ran it again and if we

go to transactions

we can now see that there are two

transactions here

and our code waited a little bit longer

for this one to complete so of course

we've deployed a contract but how do we

actually interact and work with the

contract let's start doing that so when

working with contracts and we're working

with on chain whenever we work with a

contract we always need two things

we need the contract address and the

contract abi often times if you're

looking for a specific abi of a type of

contract you can usually just google it

so we need to make a new contract object

to work with contracts let's go ahead

and create this simple storage contract

so we can actually interact with it

so we'll do simple storage

equals

dot w3.eth.com now we need our address

which we can get from ganache

but that might be a little bit hard to

always be checking the blockchain for a

transaction

it's actually also in this transaction

receipt address

equals transaction receipt dot contract

address

and then since we've compiled this we

also have our abi already

abi

equals abi

sometimes you'll see people have a file

called

abis.pi or abis.json or something like

that and they'll load apis in directly

from there and great now that we have

the address and the api we can start

interacting with this contract exactly

as we did in remix so let's do a print

statement to get that initial value that

is returned from our retrieve function

remember it should be initialized to

zero

so if we do print

simple storage dot functions

dot retrieve

let's see what happens here

huh what's this

we get this function retrieve bound to

in these parentheses here

so what's going on when making

transactions in the blockchain there's

actually two different ways that we can

interact with them we can interact with

a call

or we can interact with a transact when

we use a call

this is just to simulate

making the call

and getting a return value

calls don't make a state change to the

blockchain and it's similar to how in

remix we would call these blue buttons

and nothing on the blockchain would

actually change we can actually also

call these orange buttons or these

non-view functions and just not actually

make a state change remix defaults these

blue buttons to be calls and these

orange buttons to be transacts in python

we can actually pick which one we want

to do a transact a transact call is when

we actually

make a state change

and this is when we actually have to

build a transaction and send a

transaction you can always just call a

function no matter what that function is

but just keep in mind you won't make a

state change you can also always

transact on a function even if it's just

a view and this will attempt to make a

state change

something like retrieve even if we

transact on it it won't make a state

change so for something like retrieve

where we don't actually want to make a

state change

we just use the call function so we'll

just do dot call

now

if we try to run this

you'll see we do get the zero because

now we're actually calling this

transaction awesome so now we have our

initial value for our retrieve function

let's keep going let's try to update

this favorite number using this store

function this we'll just keep in mind is

our initial

value of

favorite number we know that this store

function is orange and we'll actually

make a transaction

but if we wanted to we can even just use

call on it

we'll do simple storage

dot functions

that's store

we'll put that 15 in here

call

let's see what happens when we send this

you can see it returned a blank that's

because this store

function has no return type if we give

this returns

unit 256

and then we say return

favorite number

and now we go back here

and we run this again

you'll see now that we get a 15 back if

we go to ganache you'll see that we keep

making a whole bunch of different

contracts but none of these are contract

interactions that's because when we call

a function we just simulate working with

it if we call retrieve again right

afterwards you'll see that it's still

zero

it's because calling is just a

simulation now let's delete all that so

let's actually build a new transaction

to actually store some value

into this contract since we want to make

a transaction we got to go through the

same process as when we deployed this

contract

let's first create a transaction

called store transaction

equals

simple storage

dot

functions

about store

and we'll give it some number in this

case 15

and then we have to do dot

build transaction

and we'll put those same pieces in here

from before we're going to have

chain id

be the chain id

we're going to need from

give me my address

nunce

is going to be the nuns

plus 1.

we're going to need to do nuns plus 1

because we actually use this nuns

already

when we create our initial transaction

remember a nuns can only be used once

for each transaction

so this transaction is going to have to

have a different nuance than the nuns we

use to deploy the contract now that we

have the transaction let's go ahead and

sign it

we'll do signed

store

tx

and

we'll do web3

that eath

dot account

dot sign transaction

store transaction

and then private key equals

private key and we'll go ahead and save

then of course we need to send it so

we'll do

transaction hash

equals w3.eth

dot send raw transaction

signed

store transaction

dot raw

transaction

and let's grab that transaction receipt

again

by doing transaction receipt

equals w3

dot eth

dot wait for transaction receipt and

actually let's call this

send

store

tx

that way for receipt

send store tx awesome it looks like

we're following the same steps here as

we did above

we created the transaction

we signed the transaction

and then we send the transaction

down here

we create a transaction

we sign the transaction we sent the

transaction and then we waited for the

transaction to finish

so let's run this

all right great we still have this print

function printing out the current value

of retrieve let's go over to ganache and

see if there's anything different here

there is instead of all these contract

creations here we now have a contract

call

we can see there's some transaction data

that was sent

a different amount of gas same gas

prices

however

this

actually updated and sent the

transaction to our blockchain

now if we call this retrieve function

again

this should print out our newly updated

value which in this case was 15.

let's go ahead and run

python deployed up high

and we can see it started at zero

and then it turned to 15. awesome we've

made our first state change to a

contract that we've deployed on our

local blockchain great work sometimes

it's nice to put some lines in here to

tell you what's going on to make it a

little bit more clear so i'll put

something like

deploying

contract dot dot

right before we deploy our contract

after we do it i might do

deployed

then

right before we update our contract

we'll print out something

like updating contract

and then right after it's done

maybe something like

updated

now if we run this now

you'll see as this goes along we'll get

these things printed out saying

deploying contract contract deployed

updating contract updated this will make

those moments when waiting for these

contracts to actually finish a lot

easier you're doing fantastic so ganache

user interface is really nice because we

can see a lot of things that are going

on here however it's a little tricky to

do a lot of programmatic stuff

oftentimes engineer will use what's

called a command line interface of

ganache instead of the ui so we're going

to go ahead and close this out and we're

going to use the ganache cli instead of

that user interface that we just saw and

this is what and this is what brown is

going to use on the back end when we

move to brownie let's learn how to

actually do that so in order to use the

ganache cli or command line interface

the first thing that we need to do is

download node.js yes i know this is a

python video however we do need to

install node.js to work with the ganache

cli you can come to this download page

and choose your operating system and

download it accordingly we will link to

a video showing you how to do this in

the github you'll know you've done it

right if you can run node

dash version in your command line and

you get a version it might be 12 might

be 14 might be something else depending

on what version you downloaded next

we're actually going to install yarn

yarn is a package manager similar to pip

and will allow us to actually download

pieces and packages like the ganache cli

from the package repository we can

install it with npm install dash dash

global yarn and you'll know you've done

it right

if you can run yarn

dash dash version in your command line

and you get the version outputted here

then we want to install the actual

ganache cli we're gonna be installing it

with yarn so to install this we're gonna

yarn global

add

ganache cli

this will install our ganache cli as a

global command in our terminal we can

test to see if we've done it right if we

can run

ganache

cli

dash dash version perfect we now have

the ganache cli let's spin up a ganache

chain with the cli

if you have your ganache ui open right

now please close it otherwise it'll

conflict so to run a local blockchain

from the command line all you need to do

is run

ganache

cli

and the node will start running directly

in your terminal

if you scroll up you can see a lot of

familiar pieces

we see the available accounts just like

on the ui

these are the different addresses

and then we see a whole bunch of

different private keys this ganache

spins up with a bunch of random

addresses and random private keys if we

wanted to always spin up with the exact

same private keys so we don't have to

update our private key every time

we can do ganache

cli

dash dash

deterministic

this way we'll always get the exact same

private keys

and the exact same addresses you can

check out the documentation to see a

bunch of other flags that you can use to

run this and you can see it's listening

on 127.2

127.0.0.1 is also known as the loopback

address or localhost now to work with

ganache in the command line

all we need to do now is update our

private keys and our addresses let's

also update the http provider since now

we're going to be looking at the

loopback address for my address

we'll scroll up

to this top address here

and we'll place it in

for our private key

we're going to copy this

and put it into our dot emv file

it already has the ox at the top here

great now let's open up a new terminal

you can open up a new terminal by

hitting this plus button here

and you can flip back and forth by

hitting this drop down and flipping back

to the ganache terminal now let's go

ahead and run

python

deploy.pi

we can see

the exact same output as we got when

working with the ui and if we flip over

to the command line we can see we've

made a whole bunch of different calls to

our blockchain each one of these calls

is a specific json rpc call to our

blockchain that we're making to interact

with it we can see information about the

transactions that we send this one

creates our simple storage contract

this one updates our simple storage

contract and great you now know how to

work with the ganache cli and the

ganache ui fantastic so how do we

actually deploy this to a test net or a

real network we were working with remix

all we had to do was switch to injected

web 3 and we used our meta mask as our

blockchain connection well in our script

here we don't have metamask natively

with our script so we need some way to

connect to the blockchain we can see

that when we're connecting to our own

local blockchain we just use an rpc url

that connects to our local blockchain to

connect to a test net or to a mainnet we

can actually do the exact same thing all

we have to do is swap this out with the

url that connects us to a mainnet or a

test app we can also run our own

blockchain node similar to how we're

running our own local blockchain node we

can run a node that actually connects to

a real blockchain however it's not

always practical or really easy to do

this so sometimes we want to use an

external or a third-party client that

actually will run a blockchain for us

let's learn a little about inferior

inferior.io is an application that will

give you a blockchain url for you to

connect with for you to run whatever you

want to run and you can get started for

free let's go ahead and register

then we just check our email

confirm email address and awesome now

we're inside of infira there's a couple

other services out there that you can

also check out like alchemy which is

another fantastic blockchain as a

service platform fura is a freemium

service it starts out as free if you

make too many api calls or too many

calls to the url they'll start charging

you

but we can create a project for free for

now let's go ahead

hit the ethereum tab

hit create project we'll call

this free code camp

brownie

hit create now we'll have a whole bunch

of project keys and project secrets we

also have this endpoint section as well

this is how we're going to be deploying

to the different networks we can see we

have an ethereum mainnet connection as

well as robson coven rink b and gorilla

testnets there's also polygon in here as

well since we want to test and deploy to

a ring b chain we can go ahead and move

to ring b and then

we can copy this url back in our

application all we have to do is swap

this out

for the new url we also have to change

the chain id

our address and the private key if you

ever are confused as to what is the

chain id of the chain that you're

working on you can always check this

chain id dot network or you can usually

ask somebody let's look up ring b we see

the chain id is four so we'll grab four

and we'll place that in our script now

this address and the private key that we

gave it now this address and the private

key that we gave it aren't going to have

any testnet ring be in them so we need

to go in our metamask and grab the

address place it in for address and then

account details

export private key

type in our password

and grab the private key go into our dot

emb file

leave the 0x and replace the rest with

our private key since i have my private

key stored as an environment variable i

need to then run source.env so that my

private key is now updated the reason

we're using this is because again since

we're making transactions to a testnet

we need some test and eth alright so now

we have everything updated for deploying

to rinkeby let's go ahead and run this

now

as you can see it's going a lot slower

this is because we actually have to wait

for the contracts to get mined and for

everything to happen

on the test net deploying to a tesla

will result in nearly the exact same

experience that you'll get when

deploying to an actual main net so it'll

take a lot longer but you can see we got

the exact same responses here now if we

take this address

and we go to the rink be ether scan

we can verify what just happened

we can see that 38 seconds ago

we made this transaction

and then 23 seconds ago we made this

transaction

we can look at all the different details

of this transaction that we just made

from our python script

we can see it even tells us we created a

smart contract

and then

we made this call

which called this store function on this

contract

we've learned a lot so far this is

fantastic now is a perfect time to take

a break and take a quick breather and

reflect back on what we've just learned

we've learned a lot about python

deploying to our own local blockchain

deploying to a test net and deploying to

a mainnet working more with private keys

creating transactions

signing transactions and then sending

transactions

now as you can see there's going to be a

lot to actually managing all the

contracts that we work with having to

write our own compile code our own

storage code is going to take a lot of

work and what if we wanted to interact

with one of the contracts that we

deployed in the past well we'd have to

keep track of all those addresses and

manually update our address features

here with an address maybe we didn't

want to deploy a new contract every

single time maybe we want to work with a

contract that we've already deployed

what if we want to work with a whole

bunch of different chains what if we

want to work with rink b and mainnet and

our own local network there seems to be

a lot to manage here and we still

haven't even talked about writing tests

this is where brownie is going to come

into play brownie is currently the most

popular smart contract development

platform built based on python it's used

by d5 giants like yearn.finance

curve.phi and out each having billions

of dollars currently locked in value and

the reason that we learned a little bit

about web3.pi first is because brownie

heavily relies on web3.pi so let's do

all this again but in brownie and we'll

see how much easier it is to actually

interact with in our shell

let's go back one directory and let's

make a new one we'll call it

brownie

simple

storage

now another really cool trick that vs

code has is instead of us having to go

to file and open up this folder in this

explorer here

what we can do is we can type code

and then type the directory that we want

to work with in our case

this directory so we can just type code

dot

and we'll get a new vs code pop-up

inside of this brownie simple storage

folder let's get learning about brownie

and this is where you're going to spend

the majority of your time move forward

brownie is incredibly powerful and makes

our lives fantastically easier so get

ready to learn one of the most powerful

tools in the smart contract developing

ecosystem let's go ahead and open up our

terminal and let's get started

installing brownie it's recommended to

install brownie via pipex pepex installs

brownie into a virtual environment and

makes it available directly from the

command line once installed you'll never

have to activate a virtual environment

prior to using browning which is really

good to install it with pipex we can go

ahead and run python dash m

pip install dash dash user pipex

once we've run that we can then run

python3-m pick at pipex in surepath

then we'll want to close the terminal by

hitting the little trashcan and then

reopen it and then we just need to run

pipex install f brownie i've already got

it installed so that's why we see this

here and then just one more time we're

going to close and reopen the terminal

you can tell you have brownie installed

correctly if you run brownie dash dash

version

and you get some output that looks

something like this

or you just run straight up brownie

and it'll output a bunch of commands

that we can run let's create our first

brownie project

we're going to be using the exact same

simple storage code that we just went

through except for we're going to use it

in brownie this is going to make our

lives a lot easier when working with

simple storage to create a sample folder

with everything we need with brownie we

can just run brownie

init

and we will get a new brownie project

initialized in the directory that we're

currently in

if you type ls you'll be able to see all

the folders that are created or you can

just see them on your side panel in vs

code let's talk really quickly about

what each of these folders is going to

do the build folder tracks a lot of

really important low-level information

it's going to track any interfaces that

we're working with or deploying it's

going to keep track of all of our

deployments across all of the different

chains so we no longer have to manage

that ourselves

and it's going to store all the compiled

code remember how in our simple storage

code we actually saved everything to

this compile code.json well brownie is

actually going to do all of that for us

into this contracts directory so we can

always reference it later this contracts

directory outside the build folder is

where we're going to put all of our

contracts brownie knows to look inside

of this folder when looking for new

contracts to compile deploy or anything

else interfaces is where we can save and

store different interfaces remember how

when we were working with chain link

working with interfaces makes it really

easy to interact with a blockchain

application reports are to save any type

of report you run scripts or we can

automate tasks like deploying calling

different functions or really anything

we want and then we have a test folder

which is incredibly powerful and we're

going to be using a lot we also have git

attributes and get ignore which are

helpful when working with version

control like git so let's go ahead and

start working with brownie and really

understand what's going on here so let's

go ahead and add our simple storage

contracts to the contracts folder so in

here we're just going to make a new file

we'll call it simple

storage.soul and i'm just going to copy

and paste the code i have

from the simple storage that we've been

using this whole time let's go ahead and

save that with command s okay great now

that we have our contract in here we can

already start working with brownie and

even compile this code without even

having to write or work with our own

compiler all we need to do

is run brownie

compile

brownie will automatically read the

version of solidity and then store all

of the compile information in this build

folder so if we go to contracts we can

see we have a simple storage.json and

there's a lot of familiar pieces in here

for example we see the abi opcodes

section which is the low level language

we'll see a pc map and we'll see a lot

of useful information and great

obviously deployments and interfaces are

still empty so great we've already

compiled our smart contract so why don't

we actually deploy this to a blockchain

to do this we do have to write a script

which will allow us to do whatever we

want so we're going to create a new file

and we're just going to call this

similar to last time deploy dot pi this

is where we're going to define working

with and deploying our code brownie can

run scripts by running brownie run in

fact if you want to take a quick minute

to familiarize yourself with all the

different commands that brownie has just

run brownie and you'll see we can do a

lot of different things we do brownie

init which will create a new brownie

project we will do brownie bake which

allows us to pull from the brownie mix

which we'll talk about later we can

compile we can go into a console test

run we do a lot of wonderful things in

here if we do brownie run it'll run a

script for us and we can define that we

want to run this deploy all we have to

do is add a def

main

so def in python is the way to define a

function we're going to call this

function main and for now let's just say

print

hello

and we can run

brownie

run

scripts deploy

and as you can see it automatically does

this launching thing

so brownie defaults to always working

with a local ganache cli blockchain it's

running the exact same command that we

ran earlier and it has a bunch of

different flags like accounts 10 a

certain hard fork a certain gas limit

etc so at the beginning of all of our

scripts if we don't give brownie a

network to use it'll spin up a local

ganache and at the end of the script

it'll tear it back down typically what i

like to do is actually put all the logic

of our deployment in its own function

def

deploy

simple storage

and we'll do pass for now and then our

main function we can just call

deploy symbol storage now in order to

deploy our contract let's look back at

our web 3 pi version of deploying this

and see what we did so first we compiled

it great brownie does that automatically

then we jumped into a file great brian

does that automatically

we got a byte code and an abi

great brand does that automatically we

added a local blockchain to use great

brownie automatically spins up a local

ganache we'll learn how to do test nets

in a little bit aha we do need an

address though and a private key so how

do we actually get our private key get

our account into brownie brownie has an

account package that actually natively

understands how to work with accounts

and we can import it into our script

here so we can do from

brownie import accounts

and with this accounts keyword

we can add an account a number of

different ways if we're going to work

with our local chain as you see here the

ganache cli will spin up 10 fake

accounts for us and brownie

automatically knows that we can work

with that account so we can do something

like account equals account zero and

then just do something like print

account so we're going to take the

account that's spun up at the zerowith

index because this accounts object is

just an array so if we run this now

brownie

runs scripts

deploy

it's going to spin up us an address and

a private key that we can just work with

without having to define a private key

or do anything it does all of that for

us which is fantastic we do of course

still want to know how to add our own

private keys so that we can work with

the test net so this is great and works

when we're working with a development

network or working with brownie's

automatic ganache cli if we want to work

with a test net though we have to do

something else another way to add your

accounts in brownie is to use the

command line and actually add them

natively into brownie we can do brownie

accounts

new and we'll give it a name free code

camp account

this will then prompt us and say enter

the private key that you wish to add

let's go ahead and grab our private key

from metamask account details export

private key

put your password in

grab the private key and then we just

add ox and paste it in

brownie will actually password encrypt

your private key in this way

so we'll give it a password and now we

have a new account natively integrated

into brownie to see it we can do brownie

accounts list and you'll see that we

have a free code camp account with this

address and also a testing account i

made this a little bit earlier we can

get rid of it

by running brownie

accounts delete

testing helpful terminal tip time so if

you hit up or down on your keyboard you

can actually toggle through the history

of the commands that you've written so

if you hit up it'll actually bring you

to the most recently run command which

can allow you to run previous commands a

little bit faster and if we run browning

accounts list again

we'll see it's now just free code camp

if we want to work with this free

codecamp account that we've added to

brownie via the command line

we can get it with account

equals accounts dot load

free code camp account

and then we can do print account let's

run this script again

this time when we on the script it's

going to ask us for the password we need

to enter the password to decrypt the

account because right now it's password

encrypted so we're going to type in the

password and it's going to go ahead and

execute with our unlocked private key we

can see the address it printed out was

right here

and if we copy the address and we go

back we can see that that is correct

now if we're going to talk about safety

and you want to safely secure your keys

this is one of the safer ways to do it

because it's not going to store it in

git

you're not going to accidentally push it

up to github or show it to anybody and

it's going to be password encrypted this

is going to be one of the ways that i

highly recommend you store your keys