►
From YouTube: Devcon VI Bogotá | Workshop 2 - Day 1
Description
Official livestream from Devcon VI Bogotá.
For a decentralized version of the steam, visit: https://live.devcon.org
Devcon is an intensive introduction for new Ethereum explorers, a global family reunion for those already a part of our ecosystem, and a source of energy and creativity for all.
Agenda 👉 https://devcon.org/
Follow us on Twitter 👉 https://twitter.com/EFDevcon
A
But
instead,
let's
do
like
a
different
required
statement.
Let's
do
require
message:
dot
value
is
equal
equal
to
some
kind
of
variable,
we're
going
to
set
we'll
set
price,
okay
and
then
otherwise,
we'll
say
not
enough.
A
Okay,
so
there's
that
and
then
what
we
can
do
is
set
that
variable,
so
we
can
say
units
US,
public
price
equals
0.001
ether.
Okay,
you
can
see
like
it
tells
me
exactly
how
much
weight
is
equal
to
Ether,
but
we
can.
You
could
Define
it
as
way
there
or
you
can
Define
it
as
ether.
A
It's
just
it's
going
to
work
either
way
right,
so
we
can
set
that
save
it,
and
then
we
have
to
also
because
we're
trying
now
we
have
a
function
where
we
want
to
accept
some
value
there
and
we're
going
to
check
against
the
the
value
that
comes
in
that
transaction.
So
now
we
want
to
make
this
payable
right.
A
So
let's
do
that
so
now
that
it's
payable
and
we
are
requiring
some
value
there.
So
our
deploy
is
successful
and
we
can
come
back
and
now
we
can
see
we
get
a
new
variable
right.
We
got
this
new
variable
for
price
it's
in
way,
so
you
know,
obviously,
if
you're
like
building
an
app,
you
don't
want
your
like
user
to
have
to
like
type
in
these
crazy
long
amount
of
ways.
So
you
want
to
like
in
your
UI,
you
would
kind
of
like
do
that.
A
Calculation
with
like
ethers,
because
ethers
is
part
of
the
component
and
we'll
get
to
react
in
a
little
bit
and
I'll
kind
of
show
you
guys
around
what
that
looks
like,
but
we'll
see
that
our
our
purpose
now
is
here
like
you
can
set
up
a
a
name,
but
you
also
have
this
new
value
for
the
for
the
value
right.
You
have
to
send
some
value.
A
So
if
I
come
over
here
and
say
like
Foo
like
this
and
I
put
in
0.00001
right,
the
wrong
amount
you'll
see
there's
a
little
green
button
which
is
kind
of
cool.
It
just
does
the
math
for
you
to
like
convert
to
way.
So
you
just
it
it's
going
to
do
time,
basically
to
the
10th
10
to
the
18th
power
or
times
10
to
the
18th
power.
Sorry,
and
it's
going
to
convert
it
for
you.
A
So
if
I
was
to
try
to
do
that,
it's
going
to
tell
me
that
not
enough
right,
I
didn't
add
enough
value,
so
you
could
just
copy
paste
the
price
that
we
know
exactly
what
it
is
right
and
then
it
lets
me
right.
So
we're
able
to
do
this
kind
of
like
cool
like
vending
machine
right,
we're
actually
our
contract.
Now
you
can
see
it
has
some
value
right.
A
It's
got
a
dollar
29
in
there,
so
you
can
start
thinking
of
like
your
smart
contract
is
like
this
way
for
people
to
be
incentivized
to
interact
with
your
function
and
then
it
can
store
value,
but
there's
a
problem
here.
The
problem
is
now:
the
money
is
locked
in
the
smart
contract
because
we
don't
have
a
withdrawal
function.
So
the
next
thing
you
would
do
is
probably
do
a
withdrawal
function
right,
and
so
we
could
do
something
like
that.
A
We
could
do
function,
withdraw
public
and
then
we
say
only
owner
for
that
one
right,
because
we
only
want
to
set
the
owner
right
and
then
we
can
do
something
like
we
set
up
Bool
success.
A
C
B
A
A
Anyways,
but
let's
just
keep
going,
but
you
get
the
idea
you
would
have
well
next,
you
would
have
a
function,
we're
not
actually
going
to
worry
about
that.
Let's
keep
going,
though
so
I
want
to
show.
Let
me
reset
real
quick
I
want
to
show
a
little
bit
of
like
the
kind
of
react
code
so
that
you
kind
of
can
get
a
feel
for
like
what
that's
like
inside
of
the
The
Source
directory.
We
have
the
app.jsx
file.
This
is
kind
of
again.
A
This
is
like
well,
you
have
like
your
app
GSX
is
kind
of
like
where
you're
gonna
like
have
like
the
main
component.
Sorry
earlier
I
said
it
was
app.jsx.
App.Jsx
is
actually
like
the
main
component.
It's
also
where
you
can
change
like
your
network
right.
So
if
you
want
to
deploy
to
a
test
net
eventually,
you'll
you'll
also
want
to
update
your
UI.
So
it
reflects
that.
So
you
can
just
come
in
here.
You
could
do
something
like
type
quarterly
and
it
would
update
as
well
just
save
that.
A
So
we
can
save
that
and
then
inside
of
the
views
directory,
we
have
like
the
example
UI
which
I
didn't
get
to
yet
I'll
show
you
and
then
there's
the
home
GSX.
So
actually,
this
is
where
in
home,
jsx
is
where
you
would
build
your
dap
inside
of
scaffold
thief
and
then
there's
also
a
subgraph
support
as
well.
So
if
has
anyone
heard
of
the
graph
right,
I'm
sure
you
guys
heard.
What's
really
cool
is
there's
a
built-in
kind
of
installation
of
that
runs
in
Docker.
A
But
once
you
spin
up
the
graph,
it's
like
a
local
graph
node
and
then
you
get
access
to
the
graph
API
and
then
you
can
actually
access
the
API
data
through
like
this
kind
of
like
graph
iql
like
internal
kind
of
browser,
and
then
you
can
kind
of
like
toy
around
with
like
using
the
graph
as
opposed
to
using
like
events,
because
it's
if
the
minute
you
start
getting
lots
of
events
in
your
smart
contract,
it
can
get
kind
of
clunky,
and
so
the
graph
is
a
good
solution.
A
So
I
highly
recommend
too,
if
you
guys
are
like
looking
at
ways
to
optimize
the
graph
as
a
good
as
well.
The
hints
is
just
like
kind
of
going
to
walk
you
through
and
like
explain
to
you
like
some
of
the
stuff
that
I've
been
explaining
to.
You,
tells
you
where
to
go
and
certain
things
so
your
front
end
is
going
to
be
here
in
app.
Gsx
tells
you
like
to
explore
the
hooks,
because
there's
inside
of
let
me
go
back
to
that
real
quick
inside
of
Home
app
jsx.
A
You
can
see
that
there's
a
lot
of
inherited
stuff
already
available
to
you.
One
of
those
is
ethics,
which
is
also
built
by
Austin
Griffith
and
the
build
Guild,
and
it's
got
a
lot
of
components
that
allow
you
to
like
really
just
easily
access
your
your
smart
contract
and
then
the
example.
Ui
has
like
kind
of
examples
of
how
you
would
like
to
react,
like
my
crutches
react,
I'm,
not
really
great
with
it
so
like
this
is
great.
A
If
you're
like
building
something
you
can
like
kind
of
copy
and
paste,
it's
got
like
ens
support
like
it
shows
you
what
to
do
like
an
ens
ens
example.
How
to
like
get
your
address,
how
to
see
the
balances?
A
You
know
how
to
do
like
those
little
buttons
that
allow
you
to
call
certain
functions
right.
So
if
I
wanted
to
set
the
purpose
to
Cheers,
I
didn't
set
any
value,
but
yeah
you
get
the
idea
it's
this
kind
of,
like
example,
there's
also
an
instance
of
the
mainnet
die
contract.
That's
there
as
well,
if
you're
going
to
do
anything
with
stable
coins,
we're
gonna
go
from
there.
Okay!
So
now
now
that
I've
showed
you
kind
of
like
a
basic
walkthrough
of
scaffoldeeth.
A
Let
me
make
sure
this
deployed.
We
reset
it.
Okay,
so
I'm
actually
going
to
stop
this
one.
Let's
go
here
and
we're
gonna.
Stop
this
one
as
well
and
I've
just
got
another
tab,
basically
open
where
I've
kind
of
already
done
the
same
thing.
It
was
like
really
hard
to
read.
A
So
I'm
now
I'm
in
the
the
challenge,
zero
directory.
So
basically
what
this
is
is
I
told
you
earlier
that
there's
different
builds
of
scaffold
teeth.
If
you
go
to
the
GitHub
and
you
go
back
to
like
the
root
of
scaffold,
Heath
you'll
see,
there's
two
other
kind
of
repositories.
It
can
get
a
little
confusing.
There's,
there's
cavalithe,
which
has
like
a
lot
of
like
examples
for
like
like
I,
said
nfts.
You
know
different
implementations
of
that
stuff.
A
The
scaffold
youth
examples
folder
has
some
additional
ones
that
might
not
be
there
and
then
you
have
this
challenges.
So
the
challenges
is
basically
everything
that
you
do
with
speedrun
ethereum
is
available
there.
So
the
first
step
that
you
do
for
a
challenge.
Is
you
actually
check
out
that
repository?
So
the
very
first
one
you
come
to
is
the
challenge,
the
simple
nft
example.
A
So
we
have
access
to
it
here
and
I've
already
checked
it
out,
and
this
is
all
available
in
computer
and
ethereum
as
well,
but
it's
also
in
the
readme
I
think
it
just
pulls
from
there
actually.
So
it's
the
same
kind
of
a
setup.
If
you're
going
to
do
challenge
zero,
which
I
would
highly
recommend
everyone
here
as
soon
as
you
get
to
a
stable
internet
or
if
you
can
like
wait
through
the
yarn
install
and
get
checkout
after
you
do,
that
everything
is
pretty
much
functional.
A
So
I've
already
done
the
checkout
here,
I've
already
done
the
yarn
install,
let's
just
make
sure
done.
Oh
and
the
other
step
is.
You
do
need
to
check
out
the
the
right
Branch,
because
this
root
Branch
it's
a
little
confusing
at
first
is
the
master
branch
is
just
a
basic
readme
and
you
have
to
actually
check
out
this
Branch.
So
you'll
clone
the
repository
and
the
extra
step
is
that
you'll
check
out
this
simple
nft
example,
which
again
it
tells
you
that
here
so
you
just
have
to
make
sure
you
follow
along.
A
You
can
pretty
much
do
this
like
in
probably
like
10
minutes,
it's
pretty
easy
and
then
we're
going
to
kind
of
walk
through
a
little
bit
right
now,
so
I've
already
done
that
did
the
install.
So
let's
do
the
same
thing:
let's
do
yarn
you're
in
chain.
B
A
Close
while
we
keep
that
one
open,
actually,
okay,
all
right,
so
while
that
loads,
let
me
just
come
over
here
and
do
a
yarn
deploy
so
now
we're
going
to
deploy
this
new
instance
and
let's
grab
the
the
config
file
as
well.
So
let's
do
atom
Dot.
A
Let's
take
a
look
at
what's
different
with
this.
Basically,
so,
let's
see,
if
it
deployed
successfully,
it
did
and
react
started.
So,
let's
first,
let's
look
at
the
UI.
So
what
do
we
got?
Localhost,
2000
and
you'll
see
that
we
get
like
a
whole
new
kind
of
experience
right.
We
have
the
the
your
Collectibles
and
we
have
this
like
transfer
function,
so
we
can
call
a
transfer.
A
We
can
also
upload
to
ipfs
like
metadata
and
also
download,
and
then
we
also
have
our
debug
contracts
folder,
so
you'll
notice,
the
debug
contracts
is
a
lot
more
involved
and
that's
because
we
are
inheriting
the
open,
Zeppelin
smart
contract
for
ERC
721.
So
let's
take
a
look
at
that
real
quick.
So
we
go
to
contracts
your
contracts
and
we
see
that
we
have
just
a
different
version
of
solidity,
essentially
we're
in
in
importing
all
of
the
erc721
standard
stuff.
A
We
inherit
that
stuff
and
then
we
have
like
these
overrides
we're
doing
on
minting
and
it
gets
a
little
more
complicated.
But
really
all
we're
doing
is
just
setting
the
URL
for
the
nfts
and
then
we're
minting
nfts
here
and
keeping
track
of
the
counter
for
the
index
of
those
there's
a
bunch
of
stuff
here.
There's
like
we're
just
setting
the
token
URI
and
we
also
have
the
ability
to
like
burn
nfts
as
well.
So
this
is
already
written
for
you.
A
So
you
have
this
starting
point
and
then
you
can
change
the
name
of
your
nft
to
whatever
you
want
so,
especially
for
hackathons,
it's
great,
because
you
can
just
if
you're
doing
an
nft
project.
You
just
use
this
as
your
starting
point
right
and
then
we
can
come
over
here
and
just
with
the
button,
we
can
see
how
easy
it
is
to
make
an
nft.
Oh,
we
need
to
grab
some
funds
and,
let's
just
start
mining,
some
nfts.
A
It's
probably
my
internet
connection,
because
it's
trying
to
like
use
ipfs
yeah,
let's
try
new
ipfs,
so
this
might
not
actually
work
sorry
guys,
but
normally
what
you
would
do
is
you'd
be
able
to
Min
an
nft,
because
what
happens
is
there's
this,
like
kind
of
like
Json
file,
that's
already
created
for
you,
I,
don't
know
exactly
where
it
is.
Let's
see
it's
in
Act
source.
A
It
might
actually
be
in
one
of
the
let's
see.
B
A
Oh
yeah
sex,
so
yeah
there
we
go
so
there's
this
there's
this
Json
structure,
kind
of
already
created
for
the
nfts.
So
what
you
can
do
is
you
can
come
in
here
and
edit,
the
URLs.
So
all
these
nfts
are
actually
created
by
Austin
Griffith
they're
like
little
paintings
that
he
did
on
Nifty
ink.
So
if
you
guys
aren't
familiar
with
Nifty,
you
should
check
that
out.
You
can
like
draw
on
there
and
like
basically
create
an
nft
on
there,
so
he
has
all
those
on
his
website.
A
So
these
are
just
like
nfts,
and
you
can
see
here
how
we
just
like.
Have
this
Json
file?
You
can
customize
it
with
the
name
description,
the
URL.
Maybe
if
you
want
to
add,
treats
to
those
nfcs,
you
can
do
that
and
then,
with
this
mint
button
here
is
doing.
A
If
the
internet
connection
would
work
is
just
basically
grabbing
that
file
and
then
creating
an
nft
right
and
then,
if
we
look
at
the
actual
code
again
for
the
actual
smart
contract,
you
can
kind
of
get
in
and
kind
of
like
learn
exactly
how
ERC
721,
Works
and
kind
of
explore.
A
So
if
you're
yeah,
if
you're
just
getting
started
again,
I
think
what
I
would
recommend
is,
you
know,
obviously
check
out
the
repository
Toy
around
just
with
like
kind
of
copy
and
pasting
stuff
from
solidity
by
example,
into
your
smart
contract.
If
you
get
more,
you
know,
as
you
get
more
kind
of
knowledgeable
on
understanding,
solidity
and
understanding.
You
know
how
stuff
works
then
start
going
through
the
speed
run
challenges
the
simple
nft
one
is
really
really
easy.
Again.
A
It
takes
like
10
minutes,
but
as
you
get
further
down
here,
like
they
get
a
little
more
complicated
and
you
kind
of
have
to
start
like,
like
even
like
the
dice
game,
you
have
to
figure
out
a
way
to
like
game
game,
the
randomness
of
the
smart
contract
and
kind
of
like
hack
it
a
little
bit
and
then,
as
you
get
here
like
when
you
get
to
build
a
decks,
I
mean
you're
literally
like
building
index
on
your
own,
like
it's
really
really
difficult.
A
So,
as
you
get
down,
you'll
you'll
find
that
pretty
much
after
you
get
through
all
the
speedrun
ethereum
you'll
be
pretty
much
ready
and
set
to
go
and
get
hired
as
a
solidity
upper
right,
that's
the
goal
and
you
can
be
part
of
the
build
Guild
so
yeah.
So
that's
my
demo
I'd
like
to
just
see
if
you
guys
had
any
questions
or
if
anyone
wanted
to
yep.
A
Yeah
so
there's
a
typescript
build
of
scaffoldeth
that
you
can
get
you
just
can
come
here
to
scaffold,
Youth
and
I.
Believe
it's
let's
see
here
so
scaffold
youth
and
then
you
can
do
a
search
for
typescript
there.
It
is
so
it's
a
next
JS
typescript
implementation
and
it
is
a
lot
faster.
Actually,
it's
it's
really
fast
with
next
JS.
So
if
you're
good
at
typescript,
that's
definitely
what
I
would
recommend
yeah.
B
B
A
Good
question
yeah,
so
the
question
was:
what's
the
difference
between
storing
nfts
on
ipfs
versus
R,
weave
ipfs
is
is
good
if
you're
like
paying
for
like
pinning
service
of
like
your
assets
that
you
or,
if
you're,
running
like
your
own
ipfs
node,
and
you
can
kind
of
guarantee
uptime
that
you
know,
obviously
the
benefit
for
something
like
our
weave
and
there's
like
another
decentralized
protocol,
where
you
can
like
pay
up
front
for
your
storage.
They
use
just
a
different
kind
of
like
decentralized
algorithm.
A
Ipfs
is
all
hash
based
and
it's
all
based
on,
like
the
hash
being
like
distributed
across
the
ipfs
cluster,
but
there
always
has
to
be
one
node
that
has
the
original
kind
of
hashes.
Otherwise,
it's
not
going
to
get
properly,
it
won't
be
available,
and
so
that's
why
you
see
sometimes
with
like
some
nfg
projects,
where
you
just
don't
see
the
image
anymore.
It's
because
they've
launched
this
thing
with
ipfs
and
then
they
haven't
pinned
it
properly
and
it's
pretty
much
gone.
A
And
then
you
have
to
like
update
the
the
your
URI
in
the
in
the
nft,
and
that
usually
doesn't
happen
because
you
have
to
pay
for
gas
for
that.
So
yeah,
something
like
are
weave,
is
good
or
again,
if
you're,
using
something
like
pinata
or
some
other
like
ipfs,
pinning
that's
that's
advice,
yeah
yep,.
A
Oh
tmux
yeah,
so
the
question
was
what
do
I
use
for
my
my
my
terminal.
So
this
is
tmux
yeah,
it's
really
great
and
you
can
kind
of
just
like
you
can
create
sessions.
You
can
store
your
sessions.
It's
really
useful
tmux.
Another
question.
D
A
Yeah
I
would
have
totally
deployed
if
the
internet
connection
wasn't
so
great
at
my
next
plan
was
to
deploy
to
a
test
net
and
then
eventually
do
a
mainnet
there's
some
things
you
need
to
do
so.
The
question
was
basically
was
like
for
the
UI
I
think
it's
a
two-part
question
learning
the
UI
components
for
like
react
and
stuff
like
that.
There's
a
lot
of
like
traditional.
Like
react,
kind
of
stuff,
you
can
do
I,
don't
really
personally
have
a
feeling
because
I'm
not
a
react
expert.
A
Maybe
someone
else
here
does
but
I
would
just
kind
of
look
at
like
react
like
introductory
courses,
because
if
you
just
get
a
basic
understanding
like
I
said
most
of
the
react,
stuff's
already
written
and
you
can
kind
of
copy
paste
and
stuff
like
that.
But
as
far
as
for
the
the
second
question,
if
you're
gonna
push
your
app
to
production
or
even
even
to
a
test
net,
you
probably
want
to
get
your
own
instance
of
the
inferior
key.
A
So
we
use
an
inferior,
so
you'll
want
to
generate
your
own
inferior
key
and
put
that
in
before
you
launch
to
mainnet.
That's
one
of
the
things
we
ask
because
otherwise
our
API
key
gets
bombarded,
and
then
you
also
want
to
set
up
an
etherscan
API
key
as
well.
A
So
you
can
verify
your
smart
contract
and
then,
as
far
as
like
publishing
to
you
know
like
a
mainnet
I
would
just
consider
like
abstracting
away
as
much
of
the
scaffolding
stuff,
as
you
can
pulling
it
out,
because
you
know
you
want
your
app
to
look
right,
polished,
but
there's
a
lot
of
cool
apps
out
there
that
are
actually
still
using
all
the
little
components
and
stuff
like
that
too,
as
well.
I
didn't
really
get
into
it.
A
But
let
me
actually
real
quick
now
that
you
say
that
I
do
want
to
show
one
thing:
if
you're
going
to
deploy
to
sorry,
if
you're
going
to
deploy
to
a
test
net
you're
going
to
want
to
use
a
yarn
you're
going
to
use
a
deployer
account
you're
not
going
to
want
to
use
the
hard
hat
account,
because
everyone's
private
key
in
the
hard
hat
is
the
same
I.
Think
so
you'll
want
to
do
a
yarn
run
generate.
A
So
what
that's
going
to
do?
Is
it's
going
to
generate
a
mnemonic
and
it's
going
to
store
it
in
your
base
directory
for
scaffold
eth?
We
can
see
it
it's
right
here
somewhere
somewhere
here
there.
It
is
mnemonic.txt
I,
think
in
the
newest
version
of
scaffold
eth,
it's
actually
the
the
public
address
dot
text.
So
it's
whatever
the
public
address
is
but
I'm
not
going
to
click
on
it
because
it's
the
password
there.
A
But
basically
it's
going
to
use
that
special
mnemonic
as
the
deployer
account,
so
that
there's
no
chance
that
someone
can
gain
access
to
your
smart
contract
and
then
what
you
can
do
is
you
can
do
yarn
account
and,
if
you're
on
it,
if
you're
on
a
gonna,
deploy
to
a
test.
Now
what
yarn,
account's
gonna
do
is
going
to
give
you
the
QR
code
for
that
account
and
then
what
I
do
is
I
just
use
a
punk
wallet
on
my
phone
Punk
wallet.io.
A
It's
a
way
for
you
to
like
create
a
like
kind
of
a
little
like
toy
wallet
and
I.
Just
have
it
as
like
an
icon
on
my
on
my
desktop
here
on
my
phone
and
I'll.
A
Show
it
real,
quick
and
then
I
just
scanned
that
that
QR
code
and
send
my
funds
through
my
through
this
little
camera
reader,
so
Punk
wallet.io,
and
then
at
that
point,
if
you're
deploying
to
a
test
net
you'll
have
test
net
funds
that
you
can
transfer
easily
Rush
by
scan
in
that
and
obviously,
if
you
want
to
deploy
the
main
set,
you
need
to
do
the
same
thing.
You
got
to
put
some
deployer
funds
on
there.
It's
not
working
because
the
internet,
but
normally
what
it
would
be
doing
right
now.
A
Is
it
go
through
all
the
networks
and
tell
you
on
what
your
balance
is,
so
you
could
send
some
funds
and
then
run
it
again
right
and
then
see
that
your
balance
has
been
updated
and
then
you
can
do
a
yarn
sorry.
So
normally
you
do
a
yarn
deploy
it's
just
using
whatever
hard
hat
is
using
for
the
deployment
so
inside
the
Hard
Hat
config.
So
if
we
go
to
hard
hats.
A
Trying
to
see
where
the
hard
dock
config
is
oh
there,
it
is
so
inside
the
Hard
Hat
config.
You
can
see
it's
configured
as
localhost,
so
if
you
were
to
plan
to
like
go
early,
you
could
just
type
Gorly
right
there
or
you
can
just
do
I.
Think
it's
during
deploy,
dash
dash,
Network
squarely
I,
think
that
and
it
would
try
to
deploy
to
Gorly
okay.
So
it's
either
War.
You
can
just
update
it
in
the
hard
hat
config
or
you
can
just
do
a
manual
command
there.
A
A
Yeah
yeah
there
is,
there
are
there's
actually
a
website.
My
internet
worked.
I
would
I
would
tell
you
what
it
was:
there's
juice
box,
juice
box
I
think
it's
called
is
like
a
kind
of
like
a
grants.
A
Application
that
was
all
built
on
on
scaffoldeeth
Nifty
ink
was
built
on
scaffolding.
Punk
wallet
was
built
on
scaffold
Heath,
so
there's
a
lot
of
like
people
actually
using
scaffold
teeth
in
production.
You
got
a
question.
A
Yep,
that's
a
great
question.
Thank
you
and
I
didn't
get
to
that
either.
So
the
test,
the
test
folder.
The
question
was
there
was
a
test
folder
here
and
we
can
see.
We
have
this
my
test.
So
all
most
of
the
builds
come
with
a
Associated
test
file
so
that
when
you
deploy
it,
you
can
run
a
test.
This
test
is
actually
part
of
the
speedrun
ethereum
you
have
to
this
test
has
to
pass
before
you
can
get
your
thing
approved
and
you
can
rate
these.
A
It's
basically
hard
hat
chai
tests,
so
you
can
write
it
in
JavaScript
and
you
can
test
against
and
definitely
that's
advised
and
to
do
that.
You
just
run
yarn
test
like
this
and
it's
going
to
fail
because
the
internet
connection.
Well,
maybe
it
didn't?
Oh
it's
good.
Okay.
So
we
can
see
here
that
we
did
a
challenge:
zero,
simple
nft
and
it
worked
and
it
was
deployed
and
then
you
then,
if
you
start
building
your
smart
contract,
you
can
start
modifying
your
test.
A
All
right,
as
you
go
good
question,
yep
great
question,
so
the
question
was:
can
you
use
Foundry
instead
of
hard
hat?
There
is
a
Foundry
built,
so
I
think
I
earlier.
If
you
come
over
here
and
you
do
a
search,
there
should
be
a
Foundry
version,
yep
right
here.
So
when
I
first
got
in
here,
I
was
on
The
Foundry
version.
It's
I
think
it's
rather
new
I,
don't
know
how
100
functional
it
is,
but
I
I
think
it's
it's
been
tested
and
I.
Think
it's
working
good
question
yeah.
A
C
C
D
C
E
E
D
G
D
C
E
F
F
C
C
C
F
F
F
G
C
G
G
Before
we
jump
in
the
action
you
might
want
to
download
a
GitHub
repo
for
this
Workshop
either
use
the
QR
code
or
just
Google
GitHub.
While
we
Dash
IO
workshop
and
you'll
get
it.
We
also
will
need
a
Foundry
for
this
Workshop.
If
you
have
it
great,
if
you
don't
have
it
just
install
it
using
the
link
in
this
slide
and
then
run
two
commands
Foundry
up
and
Forge
build
I
know.
Internet
is
pretty
bad
here
and
so
for
some
reason
you
can't
download
it
and
install
it.
G
Don't
worry,
the
repository
will
stay
up
and
you
have
access
to
it
and
I'll
pause.
The
slides
tomorrow
and
I'll
be
doing
some
live
Demas,
so
you
can
just
watch
and
get
the
idea
what's
going
on,
let's
jump
right
into
it
all
right
who
has
ever
deployed
here
and
written
a
smart
contract.
Please
raise
your
hand.
G
Okay,
who
has
ever
run
into
the
issue
of
a
contract
size
limit
here,
please
raise
your
hands
wow,
it's
way
more
problem
than
effort,
so
yeah
this
picture.
It
illustrates
my
personal
pain
and
why
I
work
in
baby
on
finance.
We
pretty
quickly
ran
at
the
issue
of
a
contract
size
limit
and
it's
not
easy
issue
to
address
and
it
causes
us
a
lot
of
pain
and
one
file
developer.
I
know
in
a
solution.
Space
called
with
limitation.
G
I
quote
bane
of
my
existence,
so
this
is
how
big
this
problem
is,
and
we
are
going
to
talk
about
today.
So
there
is
a
few
solutions
for
this.
Well,
you
can
reduce
byte
code
size
using
various
techniques
and
essentially
it's
like
alternative
sport
to
guest
golfing
I,
called
it
byte
code.
Golfing
I
certainly
do
not
recommend
it,
because
it's
like
a
diminishing
return
Sport
with
each
optimization.
G
Other
Solutions
are
external
libraries,
static,
pre-compiled,
rotor
and
a
dynamic
rotor,
we'll
cover
them
in
this
workshop
and
hopefully
have
some
time
for
questions
and
discussions
all
right.
We're
going
to
use
a
simple
contract
as
a
baseline
contract
for
this
Workshop,
it's
called
a
counter.
It
has
a
few
functions,
a
set
function
which
sets
a
invariable
to
a
new
value,
a
get
functions
which
retrieves
this
variable
and
finally
accounts
functions
which
just
adjusts
a
constant.
G
G
All
right,
let's
jump
into
the
code
here,
we
have
our
counter
contract
again,
I'm
not
going
to
spend
any
time
on
this.
It's
a
pretty
basic.
What
is
important
about
it?
It's
rather
small!
So
if
we
look
at
it
byte
code
size,
you
can
see
it's
under
one
kilobyte,
which
is
great,
and
we
have
a
lot
of
space
left.
G
But
let's
say
a
product
team
says:
oh
actually,
we
need
to
implement
this
new
core
feature
quote
quote:
function
and
call
function
is
a
function
which
returns
just
like
big
string,
which
takes
all
the
space.
And
then,
if
you
look
at
this
big
modeler,
it
like
takes
almost
all
the
space
in
the
contract
with
a
few
left
and
if
we
try
to
implement
it
in
very
new
way,
using
solution
inheritance.
So
we
just
okay
for
our
counter.
G
G
External
libraries
is
a
is
a
feature
of
a
solidity,
so
how
it
works
is
that
in
your
contract,
in
your
methods,
you
just
call
a
library
instead
of
implementing
it
in
the
contract.
In
this
case,
we
have
a
two
libraries.
One
is
called
storage
leap
which
contains
our
original
counter
methods
such
as
set
get
const.
G
Stability
is
just
abstraction
layer
over
delegate
code
and
that's
basically
it
is
not
much
to
this,
and
if
we
go
back
to
our
presentation,
we
can
quickly
sum
up
all
the
ups
and
downs,
this
approach,
so
the
good
part
about
it.
It
comes
with
some
security
guarantees
by
solidity.
The
main
important
one
is
the
library
can't
call
self-destruct.
G
So
this
is
that
it's
not
truly
infinite,
because
if
we
Define
to
add
one
more
function,
you
need
like
external
wrapper
function,
which
stack
up
quite
quickly
and
eventually
you
run
out
of
space
in
your
surface
contract
and
it
doesn't
matter
how
many
ellipse
you
can
write
more,
which
is
normal
space
and
the
final
downside,
maybe
for
some
projects
external
libraries
can
be
used,
can
support
upgradable
contracts.
So
once
you
deploy
your
external
libraries,
it's
like
set
in
stone
and
you
can't
change
it.
G
Okay.
The
next
approach
is
a
static,
pre-compiled
rotor.
This
work
was
pioneered
by
Alejandro
Santander
from
synthetics.
He
also
previously
worked
at
open
Zeppelin
and
he
is
known
as
a
funeral
out
on
Twitter
and
if
you
look
at
like,
if
you
want
to
take
a
look
at
production,
ready
like
stable
code,
I
suggest
you
check
out
hard
hat
router
package
at
the
synthetic
zipper
and
what
they're
gonna
take
a
look
at
the
simplified
example.
G
So
so
the
idea
for
the
static
router
is
pretty
simple:
it's
a
smart
contract
which
has
no
fun
no
external
functions,
and
it
only
has
a
fallback
and
receive
functions
and
what
it
does
it
calls
a
forward
function
inside
both
of
them
and
the
forward
function
consists
of
two
parts:
the
lookup
part
for
the
implementation
address
and
the
assembly
part
for
delete.
G
Jade
call
I'm
not
going
to
spend
time
on
this
I'm
just
going
to
say
this
is
like
a
canonic
implementation
of
a
proxy
Jade
call
in
assembly
which
is
used
by
all
the
proxies
and
what
it
does.
It
basically
sends
your
function
code
to
whatever
the
implementation
contract
is
and
then
returns
its
results,
and
the
interesting
part
is
here
so
in
solidity,
each
function
has
a
signature
and,
as
you
can
see
here,
we
have
a
switch
for
a
signature
method
and
based
on
the
signature
of
a
code
function.
G
We
pick
up
an
implementation
address
which
is
later
used
for
diligate
call
and,
as
you
can
see
here,
we
have
four
functions
registered
for
a
counter
modular,
which
is
a
get
set.
Const
and
one
function
registered
for
a
quote.
Modular
because
it's
like
so
big
and
based
on
a
function
signature,
we
do
pick
up
a
right
implementation
address
and
then
use
it
for
delegate
call
and
again,
if
you
go
to
our
contract
sizes,
why
it
works,
because
these
are
three
separate
contracts.
We
have
a
big
modular
which
is
within
the
limits.
G
Then
we
have
counter
modulator,
which
is
also
in
limits
and
finally
static.
Router
itself
is
pretty
small
because
it
just
with
one
function,
though
the
more
functions
you
have,
the
more
its
bite
size
grows,
because
you
have
to
add
each
function
here
as
a
new
line,
though
it
grows
way
less
than
external
libraries
example.
G
And
if
we
go
back
to
slides,
we
can
see
what
are
the
benefits
of
using
it.
It's
extremely
gas
efficient.
Why?
Because
it's
all
pre-compiled
in
byte
code,
so
you
don't
need
to
waste
any
expensive
operations
as
HS
load
on
the
rotors.
So
you
don't
your
different
models.
Do
not
so
you
don't.
Your
different
model
is:
do
not
write
to
the
same
storage
and
then
finally
develop
and
maintenance.
G
Overhead
can
be
tricky
because
you
need
to
pre-compute
always
signatures
and
addresses
up
front,
and
you
don't
want
to
do
it
by
hand
which
is
I
recommend
check
out
again
heart
router.
They
built
a
plugin
which
does
that
for
you
well
this,
like
a
second
approach,
how
you
can
achieve
infinite
size
and
compare
to
libraries,
it's
like
better
in
the
way
which
gives
you
like
more
control,
using
like
assembly
and
low
level
language
features.
G
The
next
idea
is
a
duration
on
the
static
router.
It's
not
necessarily
better,
not
necessarily
better.
It
is
a
different
approach.
It
depends
on
your
project,
I
call
it
Dynamic
router
if
you're
interested
in
a
product
level,
better
tested
implementation
of
this
idea,
I
highly
recommend
you
to
check
out
Eep
2535
by
Nick
March.
G
The
vcp
is
covers
far
more
things
than
just
unlimited
contract
size,
but
one
thing
it
certainly
does
achieve
is
unlimited
contract
size
through
a
dynamic,
router
I've
written
a
simplified
example
of
this
Dynamic
router.
So,
let's
get
to
it,
so
we
can
see
how
it
works.
It's
quite
similar
to
a
static
router.
In
the
same
way,
it
has
a
fallback
currency
functions
which
just
forward
every
function
Call
to
to
our
forward
function,
but
the
difference
comes
in
this
line.
G
If
in
a
static,
router
function,
we
have
a
switch
case
which
just
goes
or
have
this
for
easy,
which
I
have
this
address
in
a
dynamic
router,
we
are
using
a
smart
contract
storage
mapping
which
is
called
modulus
and
using
his
as
you
can
see
here,
we
pick
up
an
implementation
address
using
a
message,
signature
and
then
the
rest
of
the
limitation
is
function
is
the
same.
We
just
provide
with
implementation
to
diligent
call,
and
essentially
it
works
in
the
same
way,
the
essential
difference
between
static
routine
Dynamic
is
the
static.
G
Router
has
all
the
signatures
and
all
the
implementations
and
races
hardcoded
in
its
byte
code,
where
Dynamic
router
use
mapping
on
the
storage
of
a
smart
contract
to
track
them,
and
that
adds
pluses
and
minus
to
this
approach.
So
the
pluses
is
once
you
deploy
your
Dynamic
router,
you
can
add
more
modulus,
even
it's
already
deployed,
or
you
can
like
fix
bugs
by
updating
it
here.
I
have
this
function,
update,
modulus
and
it's
also
pretty
straightforward.
G
G
You
can
use
open,
Zeppelin
access
roles
or
some
like
other
techniques,
but
that's
like
out
of
the
scope
of
this
Workshop,
but
you
just
have
to
keep
this
in
mind
and
if
we
go
back
to
presentation,
Dynamic
router
is
the
first
router
which
is
truly
infinite
because
all
the
mappings
between
function,
signatures
and
implementations
are
inside
the
storage,
which
is,
as
we
all
know,
very
big
in
solidity.
Then
you
can
literally
add
infinite
amount
of
functions
to
this
router.
G
G
If
you
want
to
build
a
truly
Unstoppable
contract,
maybe
you
don't
want
to
have
any
upgrades
and
them
can
be
many
solutions
like
governments
and
multi-seek,
but
you
eventually
have
to
figure
it
out
for
yourself,
and
these
are
the
three
main
approaches
which
you
can
use
to
tackle
infinite
size
contracts
and
then,
what's
like
important:
what's
the
difference
between
infinite
size
contracts
and
normal
contact
business
approach,
it
comes
down
to
a
gas
overheads.
G
Essentially
here
in
this
table,
we
are
campaigning
our
base
contract
with
with
three
approaches
in
terms
of
gas
and
why
gas
is
important
like
a
short
story.
When
was
like
a
bull
run
and
guess,
prices
were
high,
we
were
seeing
the
the
function,
calls
for
the
users
in
the
price
ranges
of
one
hundred
dollars.
G
Twenty
two
hundred
dollars
and
even
three
hundred
dollars
for
some
projects
and
a
lot
of
these
gas
costs
were
coming
from
using
proxies
because
proxies
has
a
gas
overhead,
a
dish
function
call
and
if
you
really
have
a
complex,
defy
system
where
protocols
call
each
other
and
they
all
have,
there
are
all
proxies
with
amount
of
overhead
Stacks
pretty
heavily
even
within
your
own
protocol,
and
it's
like
important
to
keep
an
eye
on
this
gas
overhead
course.
So,
let's
dig
down
a
bit
in
these
numbers.
G
The
first
base
contract
are
the
numbers
for
our
base
course.
So
it's
like
no
delete
code
involved
and
then,
if
you
look
at
the
base,
call
for
a
constant
call,
you
just
returns
a
number.
It's
a
very
small
and
the
first
number
in
red
is
just
what's
the
overhead
and
guess,
and
the
second
number
in
red
is
in
percentage
and
you
can
see
for
like
a
simple
return
call
of
a
constant
value.
The
overhead
is
actually
around
two
thousand
percent,
which
is
like
insane,
and
you
may
say:
oh,
it's
not
practical.
G
You
know
to
return
a
constant
value,
but
you'll
be
far
from
the
truth,
because
the
famous
ec20
token
has
a
member
a
function
called
decimals,
which
returns
how
many
they
came.
Also
talking
has-
and
you
have
to
call
this
function
if
you
define
developer
because
in
order
to
handle
ec20
token,
you
have
to
know
how
many
decimals
this
token
have
and
one
of
the
most
common
uc20
tokens
like
usdc
their
approxy
contracts.
So
every
time
you
call
decimals
you
overpain,
roughly
two
thousand
percent
or
probably
more
but
anyway,
let's
take
a
high
level.
G
Look
at
this
approaches
so,
as
you
can
see
indeed,
static.
Router
is
the
most
gas
efficient
approach.
So
if
you
have
to
build
a
gas
efficient,
infinite
contract-
and
you
are-
and
you
know
what
kind
of
functions
you're
going
to
have
and
don't
plan
to
upgrade-
then
it's
like
a
great
solution
and
then
Dynamic
router
is
make
more
expensive
even
more
expensive
than
external
Library.
G
The
reason
I
wouldn't
recommend
external
Library.
As
you
can
see,
it
has
unusually
high
overhead,
for
quote
more
than
double
than
it
should
and
I
think
it
has
something
to
do
with
how
solidity
pass
with
such
big
amounts
of
data.
But
I
haven't
dipped
the
byte
code
yet,
but
just
be
wary.
If
using
external
libraries
and
you
pass
or
return
big
amounts
of
data,
then
your
gas
expenses
may
surprise
you
and
to
take
a
look
at
this.
What
would
be
the
high
level
conclusions
of
this
overview?
G
Is
that
your
gas
overhead
obviously
is
more
significant
for
low
for
fractions
which
are
low
in
gas.
Essentially,
if
your
function
has
only
a
single
s
load,
then
you
would
pay
a
lot
of
gas.
G
So
what
it
means
in
Practical
terms,
which
I
also
encountered
is
that
if
you
need
to
build
a
function
which
returns
some
like
data
around
your
protocol,
smart
contract,
you
may
want
to
bulk
them
all
this
data
in
one
function
call
so
you
don't
need
to
call
five
functions
in
a
row
because
you
would
pay
a
gas
overheard
on
each
call.
Essentially
batching
view
functions
might
be
a
good
idea.
G
G
I
never
found
anyone
using
it
somewhere
on
the
Internet
or
on
GitHub,
which
is
why
I
had
to
coin
the
term
for
this
approach,
so
I'm
going
I'm
calling
it's
like
loaded
router,
and
so
the
approach
is
pretty
simple
because
like
if
you
go
back
to
a
static
router,
so
the
static
router.
In
our
case
it
doesn't
take
much
space
and
even
it
grows.
There's
still
a
lot
of
space
left
and
what
you
can
do
essentially
is
again
using
solution
inheritance.
G
So,
in
other
ways,
if
there
is
some
space
in
terms
of
byte
code
size
left
in
your
static
router,
you
can
put
the
functions
there,
which
either
people
use
the
most
in
your
system
or
the
functions
which
has
the
highest
gas
overhead
like
calling
decimals,
and
this
allows
you
to
save
quite
a
bit
of
gas
because
just
to
give
a
bad
explanation
of
this,
if
you
combine
static
router
with
a
counter
modular,
we
don't
get
to
this
forward
function
because
static
router
now
is
counter
modular
and
that
results
in
a
quite
significant.
G
Gas
savings
and
the
same
approach
can
be
applied
to
Dynamic
router
I'm,
just
gonna
show
you
the
call,
but
it's
a
pretty
straightforward.
You
again
can
hit
counter
model,
but
here
this
is
the
cage
with
a
dynamic
router,
because
in
Dynamic
router
we
can
update
implementations
of
a
function.
If
you
place
a
function
like
get
a
set
on
the
router
itself,
you
will
never
be
able
to
update
it.
G
It
results
either
to
95
Improvement
or
97
Improvement
for
a
constant
function.
It
results
around
54
or
68
Improvement
for
a
get
function,
which
is
a
single
s,
load
and
singular.
Slow
function
is
not
dead
and
common,
as
you
might
think,
because,
for
example,
ec20
balance
of
function
is
just
a
single
s
load
and
again
this
function
is
called
a
lot
and
I.
Don't
really
expect
it
to
be
changed
and
then,
finally,
for
a
single
s
store
operations,
the
savings
amount
is
about
11
or
18.
G
So
it's
like
not
that
much,
but
like
still
sizeable
and
what
you
could
you
like
looking
at
these
numbers,
my
suggestion
would
be
is
to
move
logous
function
on
the
router
if
they
use
a
lot.
So
this
is
the
most
best
saving
or
just
the
functions
you
expect
user
Fade
to
be
user
facing
so
the
in
the
functions.
People
will
use
the
most
again
as
a
transfer
function,
a
deposit
of
withdrawal
or
claim
reward,
and
then
finally,
the
pure
functions
is
just
just
a
constant,
have
the
biggest
impact
on
this
foreign.
G
G
We
can
see.
Surprisingly
many
functions
of
pc20
function,
20
token
such
as
name
and
symbol
in
decimals.
In
most
implementations
they
really
return.
A
constant
you
know,
just
like
name
is
like
migrate.
Token
symbol
is
like
three
letters
and
decimal
is
like
18
number
right
and
in
most
projects
really
with
functions
will
never
change.
G
And
literally,
if
you
write
in
you'll,
see
20
token,
which
has
decimal
functions
which
will
return
different
values,
I
might
have
a
problem
with
you,
please
let
me
know,
and
even
going
back
even
on
later
so
total
Supply
many
FC
20
tokens
has
a
fixed,
total
Supply
right.
So
with
again,
no
reason
for
this
function
to
be
upgradable
or
to
be
sitting
behind
the
daily
Jade
call,
and
then
things
get
tricky,
so
I
can
see
how
transfer
allowance
or
proof
can
be
changed
in
the
future.
G
Maybe
standards
change,
but
it's
like
up
to
every
developer.
You
have
to
make
call
on
yourself
whenever
your
project
View
encounter
these
issues
in
the
future
or
not
and
the
same
logic
more
or
less
applies
to
ec721.
G
But
these
are
just
two
common
contracts:
I
really
wanted
to
show
on
them,
kind
of
logic:
I
would
fall
if
I
would
build
a
complex
system
where
I
would
just
sit
down
and
look
at
my
contracts
and
look
at
which
methods
are
not
going
to
change
for
sure
in
visual
X
save
to
put
on
the
router
itself
to
save
the
gas
and
which
makes
the
most
sense
because,
for
example,
at
Babylon
Finance,
we
had
this
like
admin
model
which
had
like
a
lot
of
admin
functions,
but
it's
pretty
much
only
us
or
governance
we're
calling
them.
G
So
we
really
didn't
care
about
the
gas
cost
of
this,
so
I
was
a
confident
just
like
putting
them
behind
the
diligent
call
and
being
upgradable,
and
let's,
let's
jump
back
to
the
code.
So
here
you
would
see
once
we
put
these
functions
on
our
routers,
they
do
grow
in
size.
So
a
loaded,
static,
router
is
slightly
bigger
than
just
a
static
router.
G
That's
because
we
merged
all
these
functions
on
this
contract,
and
eventually
you
hit
the
size
of
how
many
functions
you
can
put
on
your
router,
which
we
did,
and
that
is
why
you
also
should
be
like
mindful
that
you
have
to
put
the
functions
on
the
router
which,
like
your
absolute
top
priority
in
terms
of
gas.
So
if
it's
like
questionable,
don't
do
it
and
the
same
applies
to
Dynamic
router,
so
it's
higher,
but
to
repeat
secure
my
security.
You
can
see
on
concern
once
again.
G
Dynamic
router
is
a
different
from
static
router.
In
that
sense
that,
if
you
put
a
function
on
router
itself,
then
it
can
be
upgraded
later,
and
you
should
be
like
super
careful
doing
this.
G
The
code,
the
repo
is
already
public,
and
it
has
all
these
examples,
as
well
as
the
test
which
I
just
made,
which
actually
makes
sure
that
all
we
discussed
is
worked.
So
here
you
can
see
that
creating
static.
Routers
is
simple
because
it
has
everything
encoded
in
it
while
to
create
a
dynamic
router.
We
need
to
build
all
these
modules,
so
we
need
to
dynamically
fetch
all
the
selectors
for
the
methods,
and
then
we
create
a
model
definition,
which
is
an
array
of
selectors,
bind
it
to
a
certain
implementation.
G
And
here
we
have
tests
to
make
sure
that
all
these
functions
work
and
if
you
will
be
checking
out
with
report
later,
you
can
run
the
following
command
test
guest
report
to
see
all
the
guest
numbers
we
just
looked
and
speaking
of
these
guess
numbers,
these
numbers
are
produced
on
0.8
solidity,
compiler
with
optimization
set
on
and
about
200
optimizations
run
on.
G
Let's
get
back
to
our
presentation,
and
that
will
be
it.
Thank
you
for
your
time.
I
hope
you
find
it
useful
I
hope
you
build
unlimited
contracts
successfully
and
never
experience
the
pain.
I
did
please
follow
my
Twitter
I
do
Post
development
stuff
there
and
I
would
be
honor
it.
If
there's
any
questions
or
discussions.
F
E
So
the
dynamic
router,
whether
it's
sorry,
the
loaded
router,
whether
it's
dynamic
or
static
it
inherits
from
the
counter
module
and
then
from
either
Dynamic
router
or
static
Road,
because
the
counter
has
the
all
the
functions,
except
for
quote
those
function.
Selectors
will
match
to
the
functions
on
counter
module
and
will
never
hit
the
switch
statement
on
the
static
or
the
the
rest.
E
If
you
were
really
doing
this,
though,
would
you
not
you
would
have
you
wouldn't
have
the
dynamic
module
with
the
same
functions
defined
as
modules
that
would
be
hit
and
they
would
just
be
superseded
by
other
function?
Selectors,
because
that's
you
would
leave
those
off
yeah.
G
I
can
tell
you
before
in
Workshop,
great
yeah,
I
didn't
do
it
in
my
repo,
because
I
didn't
want
to
just
produce
like
more
quality
and
to
get
in
this
optimization
game,
because
yes,
but
yes,
it's
like
exactly
correct.
So,
if
you're
making
your
order
loaded,
then
the
functions
you
put
in
the
rotor
yourself,
you
remove
them
either
from
the
static
part
of
the
router
or
you
never
put
them
on
the
storage
of
a
dynamic
router,
because
why
do
we
need
the
same
function
twice?
C
G
The
space
yeah
I
mean
both
hard
hat
and
the
forge
allow
you
to
run
different
commands,
so
the
forge
you
can
run
Forge
build
sizes,
and
it
just
shows
you.
G
G
Oh
yeah,
it's
a
good
question
yeah.
So
what
I
did
in
in
our
times
is
that
maybe
it's
like
wrong,
but
it's
a
security
hack
I
would
just
like
delete
everything
inside
the
function
and
I
see
what
how
much
it
drops,
but
it's
fast
and
it
works
I,
don't
know
maybe
with
some
automation
right
now,
but
that's
the
truth.
G
G
So
for
the
users
as
I
say,
unfortunately,
if
you
don't
use
like
the
loaded
technique,
it
gets
its
more
gas
expensive
and
then
you
should
be.
You
should
like
estimate.
How
big
is
your
main
functions
like
let's
say
if
your
deposit
function
is
really
big
like
200k,
then
maybe
you
don't
care
about
5k
overhead.
It's
like
nothing
but
I've
seen
some
protocols
which
have
like
really
small
functions.
You
know
like
just
like
claim
my
rewards
right,
a
small
function,
but
because
it
has
overhead
it
made
it
more
expensive
for
users.
G
But
what
is
more
important
that
you
should
like
Define
build
your
system
from
Day
Zero
understanding.
Do
you
need
infinite
size
or
not,
because
there's
nothing
more
ugly
than
like
building
that
not
infinite,
and
then
you
have
to
deploy
extra
extra
contract
and
they
call
each
other
and
in
the
end,
is
the
users
who
pay
for
that
right.
So
essentially,
if
you
need
really
big
protocol,
you
should
go
infinite
size
from
Day
Zero.
In
the
end,
it
will
be
cheaper
for
the
users,
but
if
you
don't
need
it,
yeah
just
don't
use
it
more.
Questions.
G
Yeah,
it's
it's
a
pretty
Advanced
topic,
the
reason
I
decided
to
skip
in
this
format.
You
can
get
some
ideas
from
synthetic
hard
hat
package.
It
has
come
good
explanations,
but
a
quick
answer
is
that
it
depends
on
what
you
do,
but
the
most
gas
efficient
is
there.
You
have
this
sorts
of
mixing
functions
which
are
shared
between
modulus,
because
essentially
each
module
can
access
any
part
of
the
storage
and
what
you,
what
you,
what
you
don't
want
to
do.
G
You
don't
want
to
call
from
one
modular
function
of
another
module
through
the
whole
like
routine
process,
because
it's
a
highly
gets
an
efficient.
What
you
want
is
you
want
to
break
your
fishes
in
that
way,
that
is
kinda
each
model.
Just
like
does
its
own
thing.
It
doesn't
really
need
to
call
other
modulus,
but
even
if
it
does
it's
better
to
use
mixings
where,
with
some
shared
code,
which
allows
like
gas,
cheap
access.
Well,
at
least
it's
my
position
on
this.
G
I
see
someone.
Yes,
please.
G
G
G
D
C
E
E
D
D
D
C
C
C
C
C
C
C
C
C
C
H
H
H
Okay,
buenos
Tardes
good
afternoon,
hello,
everybody
welcome
to
building
blockchain
products
for
unicep
how
to
get
involved.
H
My
name
is
Shane
O'connor
and
I
am
an
innovation
manager
with
unicef's
office
of
innovation,
which
is
based
in
Stockholm
in
Sweden,
but
I'm
very
happy
to
be
here
at
devcom
with
you
guys.
Probably
a
lot
of
you
know
UNICEF
as
an
organization.
You
know
you've
heard
of
us.
You
know
what
we
do.
H
and
UNICEF.
Is
one
of
the
larger
un
organizations,
so
big
bureaucratic
sometimes
slow
to
move,
so
it
takes
us
a
long
time
to
try
and
get
UNICEF
to
move
in
this
type
of
space
and
to
get
us
up
to
speed
on
how
to
properly
use
the
technology.
That's
out
there
in
the
real
world
to
support
unicef's
programming.
H
In
my
own
team
that
I
work
with
the
Venture
fund,
we
have
been
providing
kind
of
seed
funding
to
support
what
we
call
Frontier
Technology
Solutions,
that
benefit
children
and
the
world,
and
we
have
some
people
from
a
few
of
the
companies
that
have
benefited
from
that
here
in
the
room
today,
but
really
from
the
slide.
There
you'll
see
we're
looking
at
the
intersection
of
the
needs
of
one
billion
people
and
100
billion
dollar
Industries.
So
we
look
at
AI,
drones,
3D,
printing
machine
learning
and
also
blockchain
and
cryptocurrency.
H
We've
actually
gone
through
three
rounds
of
blockchain
funding
cohorts.
We
did
our
first
cohort
in
about
2018,
which
was
more
of
a
kind
of
a
thematic
call
for
submissions
and
you'll,
see
that
we
had
submissions
from
Supply,
Chain,
Solutions,
digital
certificates
and
badges
impact
investing.
H
We
did
a
second
cohort
back
in
2020,
which
was
more
focused
on
financial
inclusion
and,
and
that
kind
of
particular
not
not
so
thematic
but
more
focused
and
some
of
the
kind
of
products,
platforms
and
companies
that
came
into
that
cohort
were
focused
on
humanitarian
cash,
transfers,
remittances
and
decentralized
decision-making
tools.
H
We
have
a
cohort
that
is
about
to
be
announced
in
the
next
one
month
or
so,
and
this
is
some
of
the
our
third
cohort
around
blockchain
and
you
can
see
some
of
the
kind
of
solutions
and
companies
that
have
been
involved
there
and
yeah
I
think
we'll.
Hopefully,
people
can
see
those
coming
out
pretty
soon
excellent.
H
This
is
really
exciting
and
Santa
is
going
to
be
giving
a
talk
later
on
at
about
5
40
on
the
the
crypto
phones.
I
won't
take
too
much
of
a
thunder
here,
but
in
2019
UNICEF
launched
crypto
fund
and
we
were
in
fact
the
first
UN
agency
to
be
able
to
receive
hold
and
disperse
cryptocurrencies.
H
So
this
is
a
a
big
big
thing
for
the
un
and
certainly
a
big
big
thing
for
Unicef,
and
this
has
really
been
able
to
help
us
to
build
digital
Solutions
and
particularly
digital
public
goods,
to
help
us
ensure
kind
of
Equitable
access
to
these
Technologies
and
these
tools
to
really
try
and
support
human
development.
H
Obviously,
through
the
lens
of
unicef's
focus,
unicef's
mandate
on
supporting
children,
one
of
the
new
applications
again
new
for
Unicef
new
for
un
and
using
blockchain,
is
cache
based
transfers,
both
kind
of
in
a
development
context,
supporting
social
protection
schemes,
but
also
possibly
more
interesting
in
humanitarian
situations.
So
responding
to
disasters
trying
to
get
funding
funds
out
to
communities,
who've
been
affected
and
we're
actually
at
the
moment,
looking
at
blockchain
for
cash
transfer,
where
in
fact,
I
don't
know
if
they're
here
in
the
room
yet.
H
But
we
do
have
another
cohort
graduate
that
is
supporting
us,
Room
San
from
Nepal,
but
using
blockchain
for
cash
transfer
to
really
increase
transparency
of
these
processes.
So
everyone
can
see
the
movement
of
the
funds
all
the
way
to
the
beneficiary,
and
this
is
interesting
for
us
as
a
UN
agency,
but
also
particularly
interesting,
I,
think
to
donors
too
and
of
course,
saving
costs
compared
to
the
traditional
aspects.
For
this
this
particular
space
UNICEF
is
also
looking
currently
we're
using
blockchain
to
support
the
the
cash
transfer
programming.
H
It's
not
cryptocurrency
at
the
moment
it
does
get
converted
to
Fiat,
but
we
are
hopefully
looking
at
using
pure
crypto
cash
transfers
early
in
2023
I.
Think
it's
what
we're
looking
at
yeah
next
slide.
So
now
we're
on
to
project
giga,
so
I'll
introduce
my
colleague
here.
I
So
my
name
is
Herman.
J
I
Lead
the
blockchain
work
for
Giga
at
UNICEF,
gigas
kind
of
like
operates
as
a
little
startup
within
the
office
of
innovation.
At
UNICEF
we
were
started.
We
started
in
2019
and
we're
sort
of
a
joint
venture
between
UNICEF
and
the
itu.
The
international
telecommunications
Union
and
our
goal
is
to
connect
all
the
world
schools
to
the
Internet
by
the
year
2030..
I
So
we
have
quite
a
lot
of
work
to
do
and
we
operate
along
sort
of
three
pillars
of
work.
The
first
pillar
is
mapping
believe
it
or
not.
We
actually
don't
know
where
all
the
schools
in
the
world
are
so
we're
using
machine
learning,
algorithms
to
analyze,
satellite
data
and
identify
schools
and
actually
help
governments
find
all
the
schools
in
their
country.
So
that's
always
an
interesting
conversation
with
the
Ministry
of
Education.
I
The
second
pillar
is
about
financing,
so
we
estimate
that
it's
going
to
cost
approximately
428
billion
dollars
to
connect
all
the
world
schools
to
the
internet,
which
is
quite
a
lot
of
money,
so
we're
really
investigating,
like
Innovative
financing
models,
to
find
sustainable
ways
to
to
make
this
happen.
So
there's
two
types
of
expenses
that
we
have
to
we
have
to
solve
for
the
first
one
is
obviously
sort
of
capital
expenses.
You
know
putting
fiber
in
the
ground,
putting
putting
Towers
up
that
sort
of
thing.
I
But
the
second
is
you
know
once
you
connect
to
school,
you
have
to
pay
for
ongoing
internet
connectivity.
You
all
sort
of
have
subscriptions
to
that.
That's
kind
of
like
how
it
works.
You
have
to
pay
your
bills,
otherwise
you
get
disconnected
so
we've
got
a
team
sort
of
focusing
on
on
making
that
happen,
and
the
third
pillar
is
about
actually
connecting
so
we
operate
a
team
called
the
accelerate
team
where
we
work
with
governments
to
investigate
different
kinds
of
business
models
for
different
kinds
of
scenarios.
I
You
know,
schools
in
urban
areas
need
a
different
solutions
than
schools
in
super
rural
areas.
So
we
work
with
governments
to
try
to
figure
that
out
and
advise
them
on
sort
of
the
best
way
to
go
so
that
they
at
some
point
can
take
over
the
financing
and
the
rollouts
of
these
programs
and
do
sustainably
so,
like
I
said
we
launched
in
2019.
Our
goal
is
to
connect
all
the
world
schools
by
2030..
So
far
we
were
joined
by
90
countries.
I
We
have
connected
5
300
schools,
we've
mapped
about
1.1
million
out
of
an
estimated
6.5.
So
there's
still
like
quite
a
lot
of
work
to
do,
and
we
were
super
happy
to
be
joined
by
14
partners
that
support
us,
including
Ericsson,
Dubai,
Keras,
musk,
Foundation
dell,
recently
joined,
which
is
a
really
big
deal,
and
we've
raised
about
210
million
dollars
towards
his
goal.
So,
as
you
can
see,
we're
still
quite
far
off
from
the
428
billion
required.
I
I
So
the
first
one
is
what
we
call
gig
accounts,
which
is
like
a
accounting
platform
and
a
sort
of
monitoring
platform
for
the
people
who
are
actually
controlling
the
money
to
pay
for
school
internet
connectivity.
So
the
way
it
usually
happens
is
that
a
country,
government
or
a
UNICEF
country
office
will
write
out
a
contract
for
like
100
Schools
or
a
thousand
schools
in
a
country
and
have
very
little
tools
to
be
able
to
actually
monitor
whether
this
internet
service
is
delivered.
I
So
what
we're
developing
is
a
way
for
them
to
make
it
super
easy
to
monitor
that.
So
we
we
have
our
own
sort
of
real-time
data
application
that
schools
can
install
on
their
on
their
networks
and
Report
data
back
to
us,
so
that
if
data
is
subpar
or
connections,
get
disconnected,
we
can
actually
hold
internet
service
providers
accountable.
So
that's
that's
our
thing
and
what
we're
hoping
to
go
with
this
is
right.
Now
the
tools
really
sort
of
to
support
support
these
people
in
their
in
their
their
work.
I
But
what
will
be
really
cool
is
to
actually
connect
this
with
smart
contracts
and
monitor
whether
internet
quality
is
delivered
and
if
it
is
automatically
pay
in
10
service
providers.
So
that
comes
super
easy
for
people
to
to
connect
schools
and
to
to
get
paid
for
that.
I
The
second
product
we're
working
on
is
called
connectivity
credits,
it's
kind
of
kind
of
similar
to
the
carbon
credit
market,
so
we're
building
a
Global
Marketplace
for
connectivity
to
make
the
connection
of
schools
sort
of
more
Equitable.
So
what's
currently
the
case
in
the
free
market
is
that
schools
in
rural
areas
get
connected
and
the
ones
in
urban,
in
urban
areas
don't
or
if
you're
a
school
in
the
rainforest.
I
An
internet
service
provider
isn't
gonna
like
lay
a
fiber
optics
cable
there.
So
what
we're
doing
is
we're
providing
a
marketplace
where
we
put
tokens
on
these
difficult
to
connect
schools
and
allow
internet
service
providers
to
redeem
these
tokens
for
benefits
from
the
government
like,
for
example,
tax
breaks
or
special
deals
when
bidding
for
Spectrum
bandwidth
and
that
sort
of
thing.
I
So
that's
currently
in
progress
in
in
Botswana
and
we're
looking
for
other
countries
to
to
implement
this
another
area
that
we're
investigating
is
nfts,
so
we've
launched
in
the
beginning
of
this
year.
The
first
first,
the
largest
I,
could
say
the
largest
sort
of
collection
within
the
UN
for
this
called
Patchwork
kingdoms.
It's
based
on
all
the
school
data
that
we
have
so
for
these
1.1
million
map
schools
that
we
have.
I
We
worked
with
a
data
artist
data
analytics
artist
to
create
these
1000
unique
art
pieces
and
raise
funds
for
Giga.
So
we
sold
all
of
them
raised
about
700
thousand
US
dollars
for
that
which
is
really
cool
and
looking
to
sort
of
build
upon
that
with
our
follow-up
collection.
Currently
title
in
progress
called
nft2,
where
we're
basically
looking
to
build
the
world's
most
comprehensive
decentralized
database
of
school
data.
I
So
the
idea
will
be
to
create
an
entity
for
every
single
School
in
the
world,
give
this
nft
for
to
the
schools
themselves
to
own
and
give
them
the
ability,
together
with
their
communities,
to
edit
the
data
for
their
school,
keep
it
up
to
date
and
and
own
this
data
themselves.
So
right
now,
it's
sort
of
on
our
Cloud
Server
in
Frankfurt,
sort
of
locked
up
and
for
for
us
to
use,
but
it'd
be
really
cool
if
schools
own
their
own
data.
I
So
that's
where
we're
hoping
to
go
with
that,
so
we're
looking
to
use
nfts
as
a
sort
of
a
portal
into
into
making
that
happen
and
the
last
projects
that
were
actually
really
Keen
to
talk
about.
I
At
this
event,
it's
like
we're
finally
allowed
to
talk
about
this
in
public,
which
is
really
cool,
is
a
staking
experiment
that
we've
been
running
in
Rwanda,
so
we've
been
working
with
the
ethereum
foundation
and
the
the
government
of
Rwanda
to
create
an
impact
investing
product
using
ethereum
staking
to
pay
for
school
connectivity.
So
that's
currently
live
and
we'll
also
be
talking
about
that
more
in
the
panel
discussion
on
Thursday.
I
If
people
are
interested
I
think
that's
it
and
then
I'll
hand
over
there's,
one
more
so
I
mean
Rome
wasn't
built
in
a
day
and
these
products
aren't
either
we're
still.
I
You
know
iterating
on
these,
so
we're
asking
you
guys:
do
you
want
to
help
us
build
so
Antonio
Gutierrez
yeah
mentioned
us
at
the
previous
sort
of
General
Assembly,
so
there's
really
sort
of
been
a
global
call
now
for
governments
to
step
up
and
and
and
help
with
this
help
with
this
course
now
I'll
introduce
you
to
my
colleague.
J
To
finish
with
the
with
the
talk
before
we
go
into
breaking
sessions,
is
that
we
we
cannot
do
this
alone.
We
are
relatively
a
fairly
small
team
compared
to
all
the
things
that
we
do
and
all
the
products
that
we
are
building.
So
we
work
with
companies
with
people
on
different
ways.
One
one
is
that
we
have
a
tech
team,
an
internal
Tech
Team
of
program,
product
managers,
data
scientists,
software
developers,
and
we
are
continuously
searching
for
that.
J
So,
if
you
are
interested
in
joining
our
team
keep
an
eye
in
our
website,
because
you
have
different
jobs
that
go
out
there
at
the
moment
we
have
one
for
a
blockchain
developer,
that's
open,
I!
Think
it's
going
to
be
open
for
another
week
or
so
so,
if
yeah,
if
either
you're
interested,
you
know
anyone
that
might
be
interested,
please
spread
the
word.
There
will
be
another
one
for
a
blockchain
product
manager,
Road
as
well,
that
will
be
coming
out
soon
and
others
will
keep
coming
out.
J
So
definitely
keep
an
eye
on
that
and
and
apply.
We
also
especially
for
blockchain
work,
because
many
of
the
things
that
Urban
was
presenting
are
shown
you
and
they
are
experiments
and
prototypes
that
we
are
building.
We
work
with
external
companies
and
with
vendors
to
to
build
them,
and
then
we
take
them
and
we
scale
them
internally,
but
we
first
work
with
companies
to
to
build
them.
J
So
again,
if
you
are
a
company,
that's
working
in
the
blockchain
space,
either
on
the
nft
space
staking
tokens
and
and
others,
and
you
are
interested
in
working
with
us.
There
will
be
again
few
calls
for
companies
to
apply
to
help
us
build
the
things
that
Urban
was
presenting.
So
there
will
be
a
one
call
to
help
us
build
this
nft2
that
doesn't
have
a
name
yet
so
we'll
be
working
with
a
company
too,
to
build
that
the
same
for
the
accounting
platform
that
he
presented,
kik
account.
J
We
have
a
working
prototype
at
the
moment,
we'll
again
be
looking
for
a
company
to
help
us
build
the
next
version
of
that
and
test
it
pilot
it
in
couple
of
countries
is
so
again
if
you
are
in
that
space
of
smart
contracts,
Etc
feel
free
to
apply,
and
then
the
last
one
that
will
also
shortly
be
coming
out.
It's
on
the
connectivity
credits.
We
are
building
that
at
the
moment
in
Botswana
about
looking
to
Pilot
it
in
couple
of
other
countries.
J
So
there
will
be
another
call
looking
for
companies
to
build
that
a
token
Marketplace
for
for
connectivity
and
then
yeah
I
think
those
are
the
main
course
that
will
be
coming
out.
Of
course,
then
we
also
work
with
companies
as
partners,
so
not
so
much
Contracting
them,
but
we
work
with
companies
like
that
they
must
plan.
Well,
that's
not
a
company,
but
the
mass
Foundation
Erikson
IHS
towers
as
partners
where
these
these
companies
give
in-kind
contributions,
either
funding
monetary,
but
also
sometimes
they
give
us
tech
support
either
through
their
developers
through
their
team.
J
So
again,
if
you
are
interested
in
helping
out
every
child
to
us
and
they'll
find
Ali
at
the
last
one,
it's
the
Venture
fund.
So
if
you
are
a
startup
in
the
blockchain
space,
there
are
continuous
course
that
are
coming
out
for
that
there
will
be
one
that
will
go
out
soon
around
climate
Tech
Solutions.
So
if
again,
you
are
building
something
on
that
20th
of
October
it's
coming
up
so
so
again
that
will
be
out
and
it's
an
investment
of
one
hundred
thousand
hundred
thousand
dollars
more
or
less
with
that.
J
J
D
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
D
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
C
J
C
C
K
K
Of
polygon,
but
before
that
we
were
working
on
the
roll
up.
That
was
a
basically
a
Decay
roll
up
that
you
can
only
transfer
tokens
and
ether.
So
basically,
what
we
will
do
is
like
we'll
introduce
you
the
this
project,
this
general
knowledge
project
that
was
done
in
tircom,
and
then
we
we
make
a
little
project
interacting
with
Hermes.
Basically
well,
you
will
see.
K
K
Specific
language
for
building
zero
knowledge
proof
right.
So
basically,
what
you
want
is
like
you.
You
have
some
kind
of
models,
kind
of
problem
that
you
want
to
solve.
Yeah.
You
want
to
express
this
in
arithmetic
constraints.
That
is
what
will
be
the
job
of
the
turcom
for
sure.
Then,
using
some
tools
and
in
our
cases
there's
an
RCS
who
you
you
will
convert
these
arithmetic
constraints
in
polynomial
identities
that
at
the
end,
you
will
have
a
cryptographic,
Brewing
System.
That
is
what
you
want
at
the
end.
K
You
want
to
have
some
input
and
some
witness
create
some
proof
and
then
have
some
kind
of
verifier
in
ethereum
right
and
with
approve
and
an
input
see
that
the
verifier
is
able
to
accept
or
resect
the
proof
so
I
as
I
say
before,
as
you
see
here,
like
circum,
will
be
at
my
specific
language
and
basically
will
be
when
you
have
some
kind
of
model.
You
write
this
model
of
this
problem
in
Silicon
language,
with
a
DSL
description
and
then
with
the
Silicon
compiler.
You
will
get
the
arithmetic
constraints
later
on.
K
You
can
do
it
the
verifying
system,
and
we
see
before
so-
for
a
quick
example.
I
don't
know
if
you
see
any
zero
knowledge
stuff,
but
it's
always
the
Fibonacci
example.
So
once
again
we
have
the
multiplicative
one.
So
it's
like
the
same
as
Fibonacci,
but
the
numbers
instead
of
summing,
you
multiply
them.
Basically
one
is
the
series
of
Fibonacci.
So,
as
we
see
here,
we
see
a
little
example.
K
Basically,
I
will
explain
a
little
bit
What's
Happening
Here
the
here.
We
have
a
template
that
that's
how
to
use
the
finest
circuit
and
silicon
template,
and
then
you
have
a
inputs
as
a
signals
and
by
default
the
signals
are
private.
If
you
don't,
if
you
don't
Define
it
afterwards,
you
will
see
this
weather
in
the
example
that
we
did
and
we
have
an
output
that
way
the
fold
is
public.
Basically,
what
it
does
is
circuit
is
like
Computing,
the
femininity
multiplicative
and
put
it
all
the
values
in
the
EM.
K
That
is
intermediate
signal.
As
you
see
in
the
line,
seven,
and
at
the
end
we
like
assert.
We
put
a
constraint
that
the
one
of
the
one
of
the
values
of
this
multiplicative
Fibonacci
series
is
put
it
on
the
output
signal
and
and
bottom
up.
We
see
that
we
Define
a
component
Main
and
basically
how
it
works
field
commas.
You
can
create
like
multiple
templates.
We
see
this
afterwards,
but
you
calculate
like
multiple
templates.
K
Let's
say
it's
like
there
are
little
circuits
that
you
can
connect
them
all
together
in
order
to
make
it
more
modular
and
at
the
end
you
have
to
have
a
main
component.
That
starts
the.
That
is
where
the
input
will
start
right.
That
will
connect
with
the
circuits
that
you
defined
before
so
as
a
simple
how
to
use
steelcom.
K
Well,
this
is
I
will
I
will
get
this
pretty
quickly
is
I
say
before
silicon
is
a
very
modular
language.
You
can
create
like
templates
as
we
see
before,
and
you
can
in
the
correct
template.
So
it
is
very
useful.
For
example,
we
have
template
for
verify
an
American
proof
and
you
can
just
use
it
like
connect
them
connecting
with
the
miracle
proof
and
use
it.
The
output
for
very
fine
things
right.
So
it's
easy
to
audit
and
easy
to
write
a
larger
circuit,
and
this
is
like
a
full
schema
of
everything.
K
Let's
see
how
it
starts.
So
what
I
see
I
say
before
you
have
a
silicon
program
and
you
compile
it
and
you
have
the
the
constraint
system,
then
what
you
will
need,
let's
go
to
the
here.
You
will
need
a
verification,
key
and
approving
key.
K
In
order
to
do
this,
you
need
like
to
do
I,
don't
know
if
you
know,
but
you
need
to
do
some
kind
of
a
trusted
ceremony
and
depending
on,
if
you
are
using
a
one
proven
system
or
another
16
or
plunk,
you
need
to
do
a
trusted
ceremony
for
every
circuit,
in
Clash
of
group
16
or
in
case
of
loan.
You
have
one
universal
trusted,
one
universal
ceremony
that
is
multiple
computation.
K
The
point
is
you
have
some
kind
of
computations
to
create
a
trust
you
have
like
some
distributed
compute
distributed
computation
to
create
a
proving
key
and
a
verification
key,
and
this
is
what
we'll
have
basically
the
verifier
and
approver
and
down
here
we
can
see
that
we
have
an
input
and
with
the
silicon
and
a
circuit
compiler,
and
with
this
we
can
create
the
weakness
that
basically
is
already
intermediate
signals,
and
basically,
with
this
we
can
end
up
creating
a
proof.
K
Surely
because
this
is
a
lot
of
doing
things,
but
I
think
with
an
example,
will
will
be
more
clear
Maybe,
and
this
is
the
state
of
the
art
and
how
the
like
DSL
language
like
circum,
is,
are
going
around,
as
you
see,
but
still
come
is
one
of
the
most
used
right
now
and
now.
Carlos
will
explain
a
little
bit,
however,
mesh
works
and
how
is
and
how,
when
how
it
works.
Yes,
foreign.
L
There
is
a
tool
that
you
can
use
is
a
web
app
that
you
can
use
in
order
to
play
around
a
little
bit
with
a
circum,
so
you
don't
need
to
start
anything
to
just
go
enter
and
then,
according
to
the
computer,
it
compiles,
so
you
can
play
around
with
it
a
little
bit
okay.
So
what
we're
going
to
do
is
a
circuit
in
order
to
prove
that
a
certain
account
has
a
not
has
made
more
than
10
transactions
in
their
Metro
Lab.
L
Okay,
for
that
purpose,
at
the
very
beginning,
I
want
to
explain
a
little
bit.
What
is
the
Hermetic
circuit?
L
Probably
you
will
already
know
that,
but
basically
are
a
lot
was
like
you
make
a
transaction
in
Layer
Two,
okay,
so
there
is
a
coordinator
that
gets
all
these
transactions,
it
Aggregates
the
all
these
transactions
in
a
batch
and
from
this
batch
you,
the
coordinator,
is
that
the
entity
that
gets
all
the
transactions
it
accumulated
transactions
and
basically
it
makes
approves
that
verifies
the
correctness
of
these
transactions
in
one
single
layer,
one
transaction,
okay.
This
is
why
it
is
called
roll
up.
L
Basically,
now
I
will
focus
a
little
bit
on
the
Miracle
tree
that
we
use
and
the
parameters
that
are
inside
in
the
state
ring.
So
it
will
be
very
useful
for
later
on
in
order
to
go
to
Circuit
that
we're
going
to
code
okay,
first
of
all,
I
just
this
is
just
an
schema
of
all
the
secrets
that
are
involved
in
the
air
method
lab,
as
you
can
see
that
a
lot
of
them.
L
You
can
check
the
repository
in
order
to
see
all
the
fieldcom
language
that
all
the
work
that
has
been
done
over
there.
We
will
focus
here
in
the
last
one,
which
is
the
hash
state,
and
this
is
how
the
Stray
state
tree
looks
like,
but
you
can
see
when
we
the
account
that
we
are,
we
add
into
the
state
tree.
It
has
different
parameters.
One
of
them
is
of
course,
ethereum
address.
Second,
one
is
the
baby
top
tab.
You
have
a
balance,
you
have
a
token
ID
and
you
have
a
nouns
okay.
L
This
is
very
important
and
how
you
compute
the
hash
of
the
state.
Okay.
So,
basically,
when
you
add
a
leaf
into
the
miracle
tree,
you
need
a
key
value,
so
the
key
is
an
index
which
will
be
enforced
by
your
smart
contract
and
it
will
be
incrementally
okay
in
order
to
not
have
a
lot
of
levels
in
the
medical
tree,
and
we
need
also
the
state
the
value.
So
so
we
need
to
Hash
the
state
in
order
to
hesitate.
So
basically,
we
just
hash
with
position
for
field
elements.
L
The
first
film,
the
first
filterment
contains
the
token
ID,
the
nouns
and
the
sign
you
can
notice
here
that
the
dominatry
has
three
little
bits.
The
nodes
has
40
bits
and
the
same
has
one
bit.
The
second
element
is
the
balance.
The
third
element
is
a
coordinate
of
the
baby
top
Tab,
and
the
fourth
element
is
the
theorem
address.
I.
Think
it's
worth
to
mention
that
I
showed
previously.
The
baby
tap
tap
here
is
divided
into
the
sign
and
the
y
coordinate
okay
Okay.
L
L
L
L
Could
you
hear
me
well
nice
Okay?
So,
let's
start
so,
basically
I
will
create
a
file.
Okay,
that
I
will
name
it
depcom
Workshop
dot
film.
So
the
first
thing
to
do
is
to
specify
which
version
of
philcom
are
we
going
to
use?
L
Yeah,
okay,
nice,
so
what
we're
going
to
do
now?
So
in
that
case
we
are
just
taking
the
token
ID
the
nodes
and
the
sign.
We
are
building
the
element
zero
and
then
we
are
putting
the
balance
into
the
element.
One
we'll
put
in
the
y
coordinate
into
the
element:
two,
we
are
putting
the
acetylene
address
into
the
elementary.
We
are
performing
a
position
hash
and,
at
the
very
end,
in
return,
what
we
will
have.
We
will
have
the
value
okay
and
this
value
will
be
inserted
in
the
smt
verifier.
L
L
I
will
name
in
Minot,
for
example,
we'll
do
the
greater
than
we
will
comparing
all
possible
bits
between
them,
and
this
component.
You
can
check
the
component
by,
as
I
did
right
now,
just
by
opening
the
hash
State
component
and
see
what
is
going
on
inside,
you
can
do
the
same.
Entering
in
the
circum
leak
in
circuiting
operators
and
seeing
which
are
the
inputs
and
the
outputs
of
the
regulator.
So
but
those
are
quite
simple,
I
would
say,
because
there
is
just
two
input.
L
Okay,
so
basically
we
are
comparing
the
nouns
and
the
Min
nodes,
okay
and
the
output.
Basically
you
can
reference
it
as-
and
here
we
are
just
setting
a
constraint.
So
these
are
like
a
a
very
important
constraint
for
this
circuit
because
it
basically
assures
that
the
nodes
that
you
will
be
used
in
the
smt
verifier
indeed
needs
to
be
more
than
okay.
L
L
Perfect
so
I'm
this
component,
you
may
see
that
the
inputs
are
definitely
non-signed,
balance,
ethereum
address
and
the
Y
coordinator.
L
D
L
So
what
we're
going
to
do
now
is
to
prove
I
mean
with
the
smt
verifier,
as
I
mentioned
before,
we
are
just
providing
the
route
providing
the
siblings,
providing
the
index
providing
the
value
and
this
component
they
basically
will
verify
that
the
siblings
provided
and
the
value
corresponds
to
that
truth.
Okay,
as
I
mentioned
previously,
I,
have
done
this
circuit
before
I.
Don't
remember
all
the
smt
verifier
inputs
and
outputs,
so
I
will
just
copy
paste
and
the
other
ones
are
a
little
bit
easier
than
this
one.
L
But
this
one
datable
tricky,
but
well.
Basically,
here
I'm
declaring
the
smt
verify
component
with
with
and
leveled
plus
one.
There
is
a
signal
which
is
enabled,
which
is
basically
the
constraint
will
be
I
mean
it's
equal
or
zero.
The
the
sorry
there
is
an
input
signal
which
is
the
enabled
in
order
to
use
the
smt
amplifier
the
functionality
the
simplifier
has
different
functionalities,
which
is
could
be
adding
a
leaf,
the
letting
a
leaf
updating
a
leaf.
L
So
in
that
case,
if
we
put
a
zero
here,
it
will
be
basically
no.
This
is
the
smt
professor,
so,
regarding
the
center
verifier,
the
zero
is
just
verifying
that,
as
I
said
previously,
the
road
will
match
all
the
siblings.
So
here
is
the
root,
which
is
the
public
into
the
I
declared
at
the
very
beginning
of
the
circuit.
L
We
are
setting
up
here
all
the
siblings
okay,
this
to
sign
notes.
No
sorry.
These
three
signals
are
not
used
for
this
circuit,
so
we
are
just
setting
to
zero,
and
this
is
very
important,
the
key
and
the
value
of
the
medical
tree.
So
basically
the
key
will
be
the
index
and
the
value
will
be
the
hash
of
the
state.
Okay,
that
I
calculate
over
here.
Okay,
now
I
notice
that
I
just
renaming
this
component.
L
L
Okay,
simple,
as
that
I
mean
it's
that
it's
a
super
small
circuit,
okay
and
it's
very
easy
to
call
to
code.
It
I
mean,
of
course
you
you
need
to.
You,
need
to
check
the
components
that
you
are
using
the
comparators.
The
smt
verifier
probably
is
the
most
complex
one,
but
it's
it's
not
that
hard
at
the
art.
It's
super
easy
and
everyone
can
read
it.
That's
also
the
the
beauty
of
VidCon
okay.
L
So
what
we
are
going
to
explain
now,
basically,
is
what
to
do
now.
You
know
with
this
circuit,
basically,
what
we're
going
to
explain,
because
we're
going
to
explain
it.
Basically,
what
we're
going
to
do
is
to
generate
all
the
trusted
setup
and
we
are
going
to
generate
the
verifier
we're
going
to
see
the
smart
contracts
are.
We
are
going
to
perform
some
tests
in
order
to
see
that
everything
works.
Fine.
K
I
will
get
get
away
from
these
okay,
so
well,
basically,
what
we
will
doing
now
like
now
now
that
do
we
already
have
a
circuit.
The
the
first
thing
that
we
have
to
do
is
like
combine
the
circuit,
and
maybe
I
should
run
the
script.
Well,
it
will
take
a
while,
but
maybe
I
I
could
run
it
until
we
explain
it.
K
So
basically,
what
we
are
doing
here
is
like
executing
all
of
these
commands
with
basically
with
the
XX
Inc.
If
you
are
more
interested
into
details,
you
can
check
in
the
silicon.20
documentation.
Basically
we're
following
this,
but
we
are
in
here
is
basically
first
compiling
the
circuit
and
then
when
we
have
the
constraints,
what
we
need
now
is
I,
don't
know
if
you
remember
before
in
the
schema,
but
we
need
you
need
a
verification
key
right.
We
need
a
approving
key
verification
key
in
order
to
to
make
the
proven
system.
K
So
in
order
to
do
that,
basically,
what
we
are
doing
here
is
like
a
multi,
a
multi-party
computation
that
we
Market
ourselves,
because
this
is
not
a
serious
project.
This
is
just
a
like
a
workshop
project,
but
this
will
be
like
the
central
decentralizer.
This
will
be
done
in
a
multi-party
computation,
but
in
this
case
we
just
donate
that
all
sets
right.
So
basically,
what
it's
coming
here
is
like.
We
create
a
new
powers
of
Tau.
We
continue.
We
have
some
entropy.
That
is
tools.
K
Then
we
prepare
the
phase
two
and
then
we
make
another
contribution
and
basically,
at
the
end
we
end
up
with
a
with
a
key
that
it
basically
is
a
the
verification
key
that
we
need.
With
this
key.
We
can
generate
the
verifier
of
the
solidity
and
also
we
can.
Basically,
we
can
generate
the
the
groups
to
to
send
to
the
smart
contract
right.
K
So
basically,
all
of
this
is
just
for
getting
the
the
compiler
circuit
and
the
key,
so
I
don't
know
how
much
it
will
take
like
it
will
take
that
long,
but
I
don't
think
it's
like
a
it's
able
to
just
wait.
I
will
continue
to
explain
it
at
the
end.
You
end
up
with
this
key
with
this
key
and
with
one
one
file,
there's
a
key
and
one
file,
there's
a
the
compiler
circuit,
and
with
this
you
can
like
do
whatever
you
want
right
like
create
a
export,
the
verifier.
K
That
is,
this
contract
that
is
created
automatically
and
then
basically,
you
can
like
start
interacting
with
this.
So
once
we
have,
when
we
run
the
script,
that
it
will
take
so
much
so
so
long
and
we
get
the
verifier
and
what
we
can
do
now
so
remember
that
in
our
in
our
circuit.
K
Let's
find
this
a
little
bit
this
one
right.
We
have
three
public
inputs,
so
we
have
the
root
right,
the
index
and
the
other
address.
So
somehow
we
must
to
take
this
with
the
remote
contract.
Now
we
will
see
the
smart
contract
and
see
how
how
we
interact
with
this.
But
basically,
as
you
see,
we
have
three
inputs
right,
so
the
verifier
as
we
can
see.
Basically
these
are
some
internal
functions
and
basically
what
the
the
all
the
function
that
we
want
is
like
the
verify
proof
right.
K
This
is
basically
verified
with
a
function
that
we
take
from
input,
the
like
the
proofs
and
then
public
input
and
we'll
and
we'll
return
either
true,
if
the
proof
goes
well
or
fast,
if
the
proof
wasn't
right.
So
as
we
see
the
array
of
input
S3,
because
we
have
three
public
inputs,
the
root
the
index
and
the
three
mattress.
So,
let's
build
a
smart
contract
to
get
along
with
this,
so
I,
don't
know
if
you
are
like
you,
you
know
a
lot
of
Solitaire
law.
K
K
M
L
Maybe
in
sitcom
2.0,
when
you
define
the
main
component
there
you
are
the
family.
D
K
You
no
so,
okay,
so
basically
we
will
be
an
FD
I
use,
a
nft
library,
and
while
it's
important
here
is
like
we
said
before,
we
need
a
snapshot
of
the
Hermes.
So
an
air
mass
Miracle
root
an
address
of
the
verifier
in
order
to
call
the
verify
function
and
an
only
fire
in
order
to
not
let
people
to
take
like
100
nfts
with
the
same
proof.
K
Right
so
basically
is
what
I'm
saying
here:
the
the
Constructor
basically
said
the
FC
721
with
a
parameter
that
token
name,
token
symbol
and
we
set
the
root
and
the
second
verifier.
And
then
we
have
like
the
all
the
function.
That
is
important.
That
is
a
climber
Ms
nft!
That's,
basically
what
it
says
is
you
you
pass
as
an
input,
an
index
and
and
the
proof
that
you
want
to
and
the
proof
of
the
zero
knowledge.
K
Basically,
it
says
if
you
already
claim
it
and
then
it
calls
the
verifier,
which
is
the
contact
verifier,
that
we
see
for
with
the
proof,
and
this
is
the
public
input.
As
we
see
we
have
the
the
merger
root,
the
index
that
you
want.
There
will
be
one
and
the
message
sender.
This
is
done
because,
like
to
note
that
you
cannot
claim
like
another
nft
that
you
don't
not
own
right,
it
is
how
you
you
secure
that
only
the
message
sender
can
claim
his
own
entities
and
basically
this
will
call
the
the
verifier.
K
If
all
goes
good,
the
proof
will
be
will
be,
will
be
receiving
correct
and
the
Notifier
will
be
set
to
true
and
you
will
get
your
nft.
So
you
do
have
questions
about
this
or
someone.
K
B
K
So,
in
order
to
do
a
flow,
we
do
a
test
and
I
think
I
will
get
a
pretty.
That
is
not
this
one.
Is
this
one
that
I
will
do
a
very
quick
overview?
Basically,
what
we
are
doing
is
like
using
or
Irma
as
a
library.
So
maybe
it
gets
a
little
bit
confusing,
but
anyway,
I
will
explain.
I
I
will
do
a
quick
review
and
I
think
yeah.
You
will
understand
so.
K
First,
we
create
three
accounts,
basically
and
then
there's
a
function
that
creates
a
new
state
that
basically,
what
we
are
doing
is
like
creating
the
Merkel
root
right.
We
created
this
state
that
we
want
to
check
against.
So
what
we
are
doing
here
is
like
creating
two
accounts
and
then
doing
Trend
transactions
from
account
1
to
account
two.
Basically
we
do
this.
We
could
remember
that
we
need
that
the
nodes
of
any
account
needs
10
or
more
in
order
to
be
able
to
generate
a
bulletproof
and
claim
the
nft.
K
So
somehow
we
we
managed
to
somehow
we
managed
to
create
the
the
state
with
the
10,
with
the
with
this
account,
and
one
of
them
will
have
like
a
non-stand,
so
we
can
claim
the
nft
so
afterwards,
basically
what
we
are
doing,
but
this
is
I,
don't
know
if
you're
familiar
with,
but
basically
we
are
deploying
the
verifier
and
then
the
player,
the
cki
drop.
That
is
a
the
contract
that
we
made
and
then
basically
this
is
the
and
then
we
start
a
test,
and
basically
this
is
the
input
right.
K
As
we
see
here,
we
have,
we
have
a
lot
of
inputs,
some
of
them
will
be
private
and
some
of
them
will
be
public
and
we
will
check
against
a
smart
contract
right.
So
we
create
an
input
and
we
create
the
snaps.js
library.
That,
basically,
is
the
the
library
that
allows
us
to
create
the
proofs
and
basically,
we
pass
an
input
and
the
directory
of
the
circuit
go
pilot.
That
is
this
one
and
the
directory
of
the
verification
key.
K
K
K
So,
as
I
say
before,
I
wanna,
at
the
end
of
the
talk
like,
depending
on
the
Brewing
System
that
you're
using
if
you
use
plonk,
you
can
reuse
the
the
ceremony.
If
you
use
a
growth
16,
you
have
to
like
one
of
the
part
of
the
ceremony.
It
is
like
you
have
to
do
it
for
every
circuit
you
have
to
so
in
this
case,
because
we
use
secret
16.
We
have
to
like
make
a
multiple
computation
for
every
circuit.
D
H
C
C
C
C
C
C
C
C
C
C
C
C
C
C
N
N
Hope
everyone
hears
me
so
hola
and
Welcome
to
our
Workshop
about
running
the
beacon
chain.
Explorer
on
your
own.
N
N
We
will
go
first
to
how
we
came
to
the
beginning
expert
and
what
what
the
architecture
of
the
project
look
looks
like.
And
finally,
we
will
show
you
how
you
run
the
Explorer,
but
before
we
go
to
anything,
we
need
your
anyone
who
wants
to
participate.
We
need
you
to
to
download
a
few
things.
So
are
there
any
anyone
who
wants
to
participate
on
this
laptop?
M
Then
I'll
quickly,
we'll
jump
back
to
that
and
I'll
quickly,
introduce
kind
of
who
we
are
a
bit
more
in
detail.
So
the
company
bitfly
was
founded,
2017
and
we've
done
a
range
of
products.
The
we've
been
basically
active
since
the
beginning
of
ethereum.
In
the
space
we
actually
created
one
of
the
first
log
explorers,
but
kind
of
let
it
slack
a
bit.
M
So
that
was
etherchain.org,
it's
one
of
the
older
ones
and
then
later
on,
we
kind
of
regretted
not
putting
more
effort
into
that
Explorer
and
then
we
kind
of
decided
now
that
there's
gonna
be
ethereum,
2.0
or
basically
the
merge.
We
decided
to
create
another
Explorer
specifically
for
phase
zero
and
that
Explorer
kind
of
ended
up
being
the
beacon
chain
Explorer
and
it
started
out
where
everyone
could
basically
see
all
the
information
about
the
beacon
chain.
M
M
M
What's
actually
going
on
with
the
validator
to
see
the
different
states
of
the
validator
to
kind
of
make
sure
you
don't
get
slashed
and
we
also
operated
one
of
the
bigger
mining
pools
called
ethermine.org
that
was
now
retired
since
the
merge
and
we
kind
of
shifted
away
from
mining
a
bit
and
focusing
we're
focusing
a
bit
more
on
staking
so
kind
of
to
shill
a
bit
our
other
products.
M
We
have
staking.ethermine.org
now
where
you
can
stake
with
less
than
32
each
and
we
have
eat,
pool
if
you're
too
lazy
to
run
your
own
validator.
You
can
just
upload
your
validator
key
and
we'll
kind
of
take
care
of
that
for
you
and
then
a
brief
history.
I
kind
of
already
touched
on
that.
So
it
started
out
in
2019
end
of
2019
with
the
first
test
networks.
So
even
before
the
Genesis
of
the
beacon
chain.
M
M
The
red
one
is
when
it's
missed
and
the
yellow
is
if
it's
orphaned
and
that's
kind
of
a
nice
overview
of
the
first
few
epochs
when
the
Genesis
happened,
and
we
also
have
like
a
checklist
below
how
much
finalization
we
have
no,
our
participation
we
have
and
if
the
EPO
has
Justified
and
finalized
and
a
nice
rocket
for
like
the
countdown
when
Genesis
started,
which
is
also
pretty
pretty
nice.
M
So
that's
kind
of
how
how
this
whole
project
began
and
it
kind
of
exploded
a
bit
more
and
more
and
with
the
merge
we
tried
to
add
more
information,
not
just
the
phase,
zero
information
and
it
kind
of
grew
and
grew,
and
this
presentation
will
also
be
kind
of
about
how
we
kind
of
handled
the
scale
and
also
give
a
kind
of
a
workshop.
Where
you
can
help
us
with
with
kind
of
finding
ways
to
scale
better
yeah,
so
let's
go
a
bit
to
the
architecture.
M
So
in
the
beginning
this
is
kind
of
a
very
simple
view.
What
the
beacon
chain
Explorer
looked
like
I,
also
presented
this
a
similar
slide.
I
think
it
was
etcc
a
year
ago
where
we
had
just
the
prism
node
we
had
infuro
node
and
the
funeral
node
was
mainly
to
get
the
deposit
data
from
East
one,
and
then
we
had
an
exporter
that
just
basically
wrote
everything
into
postgres
database
and
that
worked
really
well
in
the
beginning.
M
It
was
really
easy
to
work
on,
and
then
we
just
had
a
golang
front
end
with
some
templates
that
kind
of
served
everything
to
the
end
user
and
even
when
I
presented
it
back,
then
we
kind
of
can
see
that
prism
already
needed,
like
a
576,
67
gigabytes
of
data,
Erica
node,
already
1.4
terabytes
and
cause
postgres
already
two
terabytes
of
data,
and
then
I
looked
at
these
numbers
again,
how
it's
running
today
and
kind
of
the
reason
why
we
had
to
scale
little
bit
more.
M
So
the
numbers
now
are
that
we
switched
to
Lighthouse
and
we
have
a
32
slot
sync.
So
there's
different
kind
of
sync
versions
that
you
can
choose
and,
depending
on
what
amount
of
starts
you
choose,
the
more
information
is
stored,
but
the
quicker
you
can
retrieve
information
and
we
basically
want
to
store
everything
and
that's
already
a
five
terabyte
disk
that
you
need
for
that
Lighthouse
then
Aragon
is
2.1
and
our
postgres
database
is
huge,
so
kind
of
the
tables
and
the
indexes
that
we
have
in
the
postgres
database.
M
They
just
don't
scale
that
well,
so
it's
already
10
terabytes
big
and
we
don't
only
run
the
mainnet.
We
also
run
the
test
net
and
the
test
net
is
just
that
amount
and
even
a
bit
more
for
different
test
Nets.
So
it's
a
huge
amount
of
data
and
it's
getting
a
bit
expensive
running
that
in
the
cloud.
So
we're
going
to
talk
about
how
we
kind
of
started
migrating
away
from
that
and
basically
the
the
scaling
challenges
during
the
merge.
M
So
this
is
kind
of
a
analytics
view
that
we
had
so
we
had
concurrent
sessions
of
2267
people
that
were
looking
during
the
merge
because
we
had
like
this
nice
slot
view
that
you
saw
before
where
people
could
see.
Okay
during
the
transition.
What
was
happening.
It
was
a
nice
visual
way
of
kind
of
tracking
it,
and
we
had
a
lot
of
people
we
kind
of
were
kind
of
prepared.
M
So
you
have
this
Super
Mario
mushroom
that
should
power
you
up,
but
that
mushroom
was
kind
of
overpowered
by
the
people
looking
at
it,
because
the
way
the
architecture
was
designed,
it
just
didn't
scale.
Well,
we
have
front-end
instances
that
kind
of
have
to
query
the
same
stuff
like.
If
we
have
five
front-end
instances,
they
do
five
times
the
same
queries,
because
we
don't
just
have
like
one
layer
that
updates
our
cache.
We
just
have
every
front
and
instance
that
has
its
own
cache.
M
So
these
are
things
we
kind
of
try
to
try
to
improve,
and
then
again
we
have
very
expensive
indexing
as
well.
In
bigtable
and
big
I
know
a
big
table.
That's
going
to
get
to
later.
In
past
Chris
and
pascals
also
has
to
get
a
lot
of
the
table
into
memory
to
be
able
to
query
stuff,
which
is
a
lot
of
the
times,
not
very
efficient,
especially
with
huge
amount
of
data.
M
And
so
what
we
try
to
do
is
we
have.
We
started
out
with
one
big
binary
where
everything
runs
and
we
try
to
strip
away
things
from
that
big
binary
and
kind
of
isolate
that
in
microservices
that
not
every
binary
does
everything.
And
if
we
duplicate
one
binder,
we
don't
do
unnecessary.
Work
and
kind
of
the
migration
is
kind
of
a
bit
challenging
for
us.
M
Because
then
we
have
to
kind
of
make
sure
that
we
manage
a
lot
of
the
technical
depth
that
we
kind
of
have
and
are
maybe
adding
through
changing
Technologies.
N
You
have
to
enters
the
docker
file
in
the
docker
compose
file
in
it
and
if
you
just
run
Docker
com
Toko
compose
tool,
it
will
pull
all
the
images
and
when
we
later
get
to
an
interactive
part,
everything
will
be
done.
So
we
have
all
these
things
ready.
A
M
Okay,
great
I,
hope
the
internet
is
good.
Let's
pray
a
bit
because
when
we
tried
it
or
tested
it
before
it
took
a
while.
So
here
you
can
see
I
kind
of
touched
on
that
the
scaling
and
large
table
so
in
postgres
in
the
beginning,
we
didn't
have
any
partitioning
at
all
so
later
on
when
oh
yeah,
two
people.
E
E
C
C
E
C
C
M
C
C
O
M
Perfect
yeah,
it's
gonna
be
fine.
Okay,
should
we
present
General,
you
can
just
maybe
hold
I
can
hold
it
up
and
you
can
baby.
O
O
Let's
go
so
Cloud
first
I
think
still
makes
sense,
especially
for
like
the
Dos
or
whatever
you
guys
might
need
that
for
in
terms
of
front
end,
I
don't
know
if
this
is
a
bottleneck,
but
we
mentioned
a
thought
about
clustering
or
some
Auto
skill
for
this
or
even,
if
we're
going
to
the
web
3
ethos
of
let's
put
this
on
ipfs
or
like
distribute
it
somehow
and
merely
make
it
un
undeniable
Service
scaling
that
way,
or
it
could
be
just
some.
O
Some
Auto
Skilling
surf
Some,
Cloud,
run
or
gcp
or
whatever
I
use
for
that.
So
I.
Don't
think
this
would
be
the
bottleneck,
anyways
the
front
end
itself,
I
think
that
and
if,
depending
on
what
you
have
here,
this
could
be
heavily
statically
generated.
So
it
might
be
something
that
you
wouldn't
be
a
problem.
Then
second
layer,
we're
talking
about
cash,
so
I
imagine
most
people
are
our
team
imagines
that
most
people
are
looking
at
past
data,
so
you
probably
don't
have
to
have
direct
access
to
the
database.
O
You
don't
have
to
do
like
real
queries
against
it.
You,
like
cash,
heavily
previous
data
that
was
already
from
previous
blocks.
That
will
never
change
so
things
that
could
be
like
pretty
much
Frozen
there,
because
it's
not
it's
really
static
and
and
and
and
stale
deal.
It's
called
like
that.
So
this,
depending
I,
guess
there's
probably
lots
of
ways
of
getting
this
catch
layer.
This
could
be
like
a
DB
level.
O
This
could
be
some
like
redis
cash
flow
or
something
like
that,
but
yeah
really
really
something
before
the
database
itself,
then
on
database,
our
friend
I
forgot
his
name,
but
our
friend
there
gave
idea
of
maybe
we
could
start
sharding
this,
maybe
some
sharding
based
on
transaction
hash
or
something
like
that
which
same
thing
since
this
is
mostly
data
that
will
live
forever
and
not
touch
it
again.
We
probably
have
a
part.
O
That's
only
read
only
so
it's
there
very
high
output
for
reads
not
that
much
in
terms
of
Rights
and
a
part
which
will
be
the
right
part,
which
this
part
here
would
have
more
direct
access
to
the
actual
nodes,
and
then
the
nodes
probably
make
sense
to
have
multiple
archive
nodes.
If,
if
the
RPC
calls
might
be
a
problem,
I
don't
know
if
it
makes
sense
to
have
lots
of
different
machines
running
those
instead
of
infuria
inferior
for
us
in
our
company
is
always
a
problem
and.
O
Yeah,
maybe
just
run
your
own
archive
notes,
for
these
not
sure.
Also
if
the
actual
RPC
calls
are
a
a.
O
Okay,
so
at
least
yeah,
maybe
to
like
archive
knows
you
guys
are
going
to
run
for
that,
and
then
this
part
here
would
just
be
like
the
heavy
right
part
which
everything
that
you
you
check
as
a
new.
You
will
just
update
database
based.
N
So
this
is
the
solution
we
came
up
with.
B
N
This
is
the
solution
we
have
right
now
with
which
we
part
of
the
of
the
of
the
of
the
data
set.
We
now
store
and
pick
table
instead
of
impulse
quests,
so
we
thought,
like
it's
not
really
necessary,
to
have
a
relational
database
for
this
kind
of
data
set
and
bigtable
scales
really
well.
So
I
think
that
we
we
were
able
to
to
indexed
all
of
the
current
each
one
transactions
in
five
hours.
So
it's
like
really.
N
It
scales
really
well
depictable,
so
we
now
store
the
blocks,
the
balances
of
the
validators,
every
transaction,
all
of
the
attestations
in
bigtable,
and
this
resulted
in
a
really
much
more
stable
in
index
time.
So
now
you
can
see
it
takes
us
like
really
Stables
30
seconds
to
export
all
the
data
of
one
epoch.
N
Yeah,
this
is
where
we
come
to
the
interactive
part
of
this
of
this
Workshop
for
everyone
who
wants
to
participate.
M
N
We
turn
on
postgres,
where
it
is
in
Peak
table
and
initialize
the
the
post
press
tables
and
picked
the
big
table.
What
is
called
tables
database.
N
N
The
next
thing
we
want
to
do
is
to
start
it
one
indexer.
We
called
it
that,
because
we're
not
really
creative
but
it
indexes
like
I,
think
it.
It
first
gets
the
blocks
from
the
execution,
glands
and
encoded
in
protopath
and
stories
into
big
table
encoded
in
protobuf,
and
then
we
index
as
after
that
we
indexed
the
blocks
with
all
the
the
fields
and
values
and
then
transaction
as
well.
So.
N
N
It
just
emulates
the
the
peak
table,
API
and
stores
it
in
sqlite
database
and
I
think
like
for
for
just
storing
and
then
analyzing
the
data
it
works.
Well,
it's
not
like
it
will
not
scale
for
for
a
thousand
requests
per
second,
but
for
analyzing
the
data.
It's
a
like
a
really
good
solution
solution.
In
our
opinion,.
N
So
the
the
thing
here
is,
we
are
not
able
to
to
reach
the
nodes.
We
we
think
before
the
the
workshop
in
the
cloud.
Somehow
we
don't
get
access.
We
have
this
python,
so
we
are
now
running
the
nodes
on
our
laptops,
and
that
is
where
you
see
some
errors,
because
the
nodes
are
not
synced
and
it
it's
not
like,
doesn't
work
well,
but
tonight.
N
N
The
next
thing
is
like
the
the
statistics,
module
module-
and
this
is
also
a
really
important
and
integral
part
of
the
whole
project,
because
the
indexer
will
aggregate
the
data
of
one
day
and
store
the
aggregated
data
of
the
one
of
of
one
Beacon
chain
there
in
the
database,
and
so
it
all
the
queries
become
much
faster.
N
And
we'll
get
started
with
the
with
the
cache
updater
and
then
the
front-end
itself,
which
is
a
calling
web
server
which
just
queries
all
the
databases.
So
all
the
things
are
running
now
and
we
can
browse
the
content
Explorer
on
localhost
8080.
The
thing
is,
since
the
nodes
are
not
synced,
it
will
take
some
time
until
any
data
will
show
up
one.
N
We
wrote
in
into
the
into
the
into
the
main
script.
The
thing
is
like
we,
we
understand
like
this
repository,
not
as
we
want
to
to
to
make
it
the
big
change
for
available
for
everyone
who
wants
to
to
explore
the
big
engine,
not.
N
N
We
will
try
to
make
it
more
easy,
but
the
thing
is
we
really
what
I'm
saying
We
Stand
by
the
decision
to
make
the
secure
open
source?
So
it's
not,
we
will.
We
will
try
to
to
make
it
available
for
everyone.
It's
not
like.
We
made
the
decision
to
go
into
bigtable
from
from
Google
and
to
run
it
in
gcp
just
to
to
make
the
scaling
issue
like
gone,
but
that
doesn't
mean
it's.
It's
not
available
for
everyone.
N
N
N
Yeah,
okay,
okay,
okay,
yeah,
so
so
the
thing
is
like
a
repository.
We
show
really
how
you
can
set
up
the
text
wrong
and
we
we
know
it's
not
like
there's
a
lot
of
technical
technical
tip
that
is
like
we
need
to
solve
it,
but
it
it's
working
for
everyone,
not
just
for
those
who
have
really
gcp
account
and
everything
I
think
we
can
go
to
the
next
slide.
N
M
Okay,
so
for
anyone
using
our
mobile
app
or
the
website,
we've
got
a
discount
code,
Bogota
50.
If
you
want
to
use
it,
you
can
get
our
Premium
app
Services.
M
If
you
have
a
lot
of
validators,
it's
nice
among
other
things
or
if
you
want
to
use
our
API
Services,
you
can
use
the
code
over
the
website
not
directly
over
the
mobile
and
yeah.
If
you're
running
a
validator,
the
mobile-
and
you
don't
know
about
the
mobile
app,
it's
pretty
nice,
it
lets
you
look
at
your
validators
on
the
go.
It
lets
you
get
notifications
when
you
propose
a
Blog
and
kind
of
see
if
you've
gotten
those
30,
East
block
Rewards
or
something
like
that.
M
Yeah.
Okay,
then.
M
If
you
want
to
contribute
here's
kind
of
the
overview
of
kind
of
the
resources,
so
we
have
a
Bitcoin
Grant,
that's
linked
below
you
can
tweet
at
Peak
and
chain.
If
you
see
any
issues
or
something
create
issues
on
the
GitHub
repository,
that's
also
linked
there
and
oh
did
anyone
still
want
to
take
a
picture
or
no
thanks,
yeah.
That's
basically
it
from
us
thanks.
So
much
for
participating
and
listening.
M
Yours
right
now
that
you
purchase
sepolya,
it's
called
so
it's
one
of
the
test,
Nets,
it's
a
bit
smaller,
so
it
should
be
able
to
think
in
a
reasonable
amount
of
amount
of
time.
The
Wi-Fi
isn't
the
best
here
so
here
it
could
take
a
while,
but
it's
a
lot
smaller
than
prata
or
which
is
girly
or
mainnet,
which
are
pretty
huge
right
now.
M
I'm
not
sure,
if
I,
if
I,
should
answer
that,
but
it's
it's
quite
a
lot.
It's
quite
a
lot.
So
it's!
What
is
it
five
figures.
N
Especially,
but
we
looked
also
at
other
DPS,
but
in
the
end
we
took
something
that
also
fits
in
our
team,
like
we
don't
have
so
much
resources.
I
was
like
so
much
take
so
much
man
hours
to
get
into
a
new
technology,
and
for
us
this
looked
at
the
best
fit
and
right
now
we
are
really
happy
with
it.
So.
M
Yeah,
we
basically
went
from
an
export
time
of
30
plus
seconds
for
attestation
assignments
to
like
five
seconds,
which
is
a
lot
better
and
there
was
less
contention
between
different
queries
on
bigtable
now
that
we
moved,
but
that
can
change
if
we
have
everything
on
bigtable
we're
just
starting
to
migrate.
So
I
hope
it
stays
good
yeah.