►
From YouTube: PEEPanEIP #21: EIP-1822: Universal Upgradeable Proxy Standard with Gabriel B. & Patrick G.
Description
Topics covered
0:54 - Introduction
3:44 - Overview Proxy
7:21 - Delegate call
11:25 - Remix example
18:06 - Address storage pattern
23:43 - Proxiable
27:45 - Library Lock
31:40 - Storage pattern
33:49 - Examples
35:10 - Resources & Tools
39:10 - What is the difference between using a Proxy system & using a Diamond system?
43:15 - When and why EIP-1822 be moved to the next state?
EIP-1822: https://eips.ethereum.org/EIPS/eip-1822
Presentation - https://docs.google.com/presentation/d/1QA9U3QN9oFSuoAaHYAtmjD8-kbp36B31iU3_B4m0EmE/edit?usp=sharing
Discussion - https://ethereum-magicians.org/t/eip-1822-universal-upgradeable-proxy-standard-uups/2842
### Real-world Examples
- rDAI - https://github.com/rtoken-project/rtoken-monorepo/blob/master/packages/contracts/contracts/Proxy.sol
- SuperFluid Finance - https://github.com/superfluid-finance/protocol-monorepo/blob/dev/packages/ethereum-contracts/contracts/upgradability/UUPSProxiable.sol
- Github - https://github.com/search?q=EIP+1822&type=commits
### Tools and Resources
- Solidity Proxy Creator (sol-proxy) - https://www.npmjs.com/sol-proxy
- 1822 Truffle plugin https://github.com/mdcoon/truffle-proxy
- Play with the contracts on Remix: https://remix.ethereum.org/#gist=6da9368618132420d958dfbba5db54eb
- bash: "truffle unbox https://github.com/pi0neerpat/proxy_101"
### Get help
Patrick: https://twitter.com/pi0neerpat
Gabriel: https://github.com/gbarros
Check out other exciting EIPs in Peep an EIP series at https://github.com/ethereum-cat-herders/PM/projects/2
Contact Ethereum Cat Herders
Discord: https://discord.gg/tzYmDmF
Twitter: https://twitter.com/EthCatHerders
Medium: https://medium.com/ethereum-cat-herders
GitHub: https://github.com/ethereum-cat-herders/PM
Email: support@ethereumcatherders.com
Website: https://www.ethereumcatherders.com/
A
Hi
there,
thanks
for
joining
the
ethereum
cathedrals,
are
back
with
another
episode
of
penny,
the
one
and
only
eip,
dedicated
series
where
we
are
discussing
an
improvement
proposal
for
ethereum
and
understand
how
it
is
going
to
make
ethereum
even
better.
I'm
your
host
pooja
ranjan
and
today
we
are
joined
by
gabriel
barris
and
patrick
gallaher.
Today
we
are
going
to
get
an
overview
of
eip
universal
upgradable
proxy
standards.
A
C
C
I
fell
in
love
with
blockchain
and
all
the
community
has
been
bringing
up
on
in
the
ethereum
environment
and
currently
I'm
working
at
cartesi
layer,
two
solution
and
working
with
contracts.
I
felt
that
there
was
this
emerging
pattern
of
using
proxies
and
that's
where
the
eip
came
from,
bring
it
up
project.
B
Hey
guys,
I'm
patrick
gallagher,
I
got
into
ethereum
in
2018,
I
was
working
in
in
government
and
the
ability
to
do
hackathons
and
win
prizes
was
so
enticing
that
I
jumped
careers
into
software
development
specifically
to
work
on
ethereum,
and
it's
been
a
pretty
good
ride.
Ever
since
so
now,
I'm
a
full
stack
developer
in
in
web
and
and
mostly
ethereum,
and
my
calling
has
really
been
to
developer
experience
and
user
experience,
and
so
like
the
the
first
project
I
created
was
one
click.
B
A
B
B
So
we'll
start
with
telling
the
story
of
some
ocean
ocean
going
ships.
So
we
have
two
ships
and
the
first
one
is
our
first
set
of
contracts,
we'll
call
that
ship
a
dot
sol,
and
so
this
this
is
our
contracts.
We've
deployed
them
to
mainnet,
they're,
really
awesome.
You
know
they're
they're
being
used,
but
there's
some
caveats.
B
You
know
we
have
limited
fuel
to
our
our
new
ships
and
we
have
some
crew
and
equipment
on
those
ships
that
are
very
important,
and
so
you
know
a
couple
months
down
the
road
we
say:
oh,
you
know
we
ran
out
of
fuel.
So
what?
If
we
deployed
a
new
set
of
contracts?
Let's
deploy
shipb.sol
and
with
this
new
contract
we
added
a
feature
that
allows
us
to
upgrade
or
that
allows
us
to
create
fuel
using
renewable
energy.
So
we
can
power
our
ship
and
continue
sailing
the
the
seas.
B
So
that's
the
kind
of
the
back
story
that
we're
setting
the
stage
for,
and
the
first
concept
that
we
have
to
understand
when
we're
using
proxies
is
the
concept
of
a
delegate.
So
you
might
have
be
aware
of
this
term
as
a
person
in
government
who
represents
you
or
a
group
of
people
in
a
conference
or
beating
or
in
a
voting
situation,
and
then
the
verb
is
to
give
or
commit
powers
to
another
agent
representative.
B
So
if
we
take
and
combine
this
idea
and
sort
of
push
it
into
the
software
development
world,
what
we
have
is
we
have
two
sets
of
contracts.
We
have
a
proxy
contract
and
a
logic
contract
and
one
is
doing
delegating
to
the
other.
So,
instead
of
instead
of
the
first
contract,
you
know
being
responsible
for
all
of
its
own
logic
and
all
of
its
own
storage.
B
B
D
B
B
So,
like
you
know,
back
to
the
definition
of
a
delegate,
we're
kind
of
giving
the
powers
to
somebody
else.
So
the
the
the
the
target
address
is
the
the
person
we're
saying
you
know
hey
like
what
code
should
I
run.
You
know
give
me
give
me
the
code
that
we
need
to
run
and
because
the
message.value
and
message.sender
aren't
changing,
we
can
do
some
that
enables
us
to
call
it
in
the
context
of
the
original
proxy
contract
and
so
well
it.
B
It
enables
you
to
basically
pretend
like
it's
the
other
contract
I'll
show
you
in
the
next
example.
Okay.
So
the
first
step
is
that
we
are
going
to
deploy
our
logic
contract.
That's
the
one
with
the
big
chunk
of
code
that
we're
we're
using
the
second
one
is
that
we
deploy
our
proxy
contract
and
we're
going
to
use
that
using
the
construct
data
from
the
logic
contract,
which
is
basically
just
like.
B
It
needs
a
setup
command
and
needs
construct
data
to
set
it
up,
and
then
the
we'll
play
a
little
game
of
who's
that
pokemon
here.
If
you
can
guess
who
it
is
in
the
middle
yeah,
that's
ditto.
So
the
proxy
contract
is
basically
pretending
to
be
the
logic
contract.
So
all
of
the
code
in
the
logic
contract
you
can.
You
can
run
on
the
proxy
contracts,
because
it's
using
that
delegate
call
again
to
go
out
and
reach
it
and
bring
it
in
and
execute
it
in
the
context
of
the
proxy.
D
So,
just
just
to
be
clear:
I'm
just
a
regular
ethereum
user.
I've
got
my
externally
owned
account
in
order
to
interact
with
this
like
whole
setup
I'll,
be
sending
my
transaction
to
the
proxy
contract,
at
which
point
the
proxy
contract
makes
a
delicate
call
to
the
logic
contract
and
will
take
basically
code
from
the
logic
contract.
It'll,
look
like
it's
being
executed
in
the
proxy
contract
and
that's,
and
that
is
basically
the
whole
proxy
system
correct
that
that's.
B
E
B
That's
a
good
point,
so
we
we
kind
of
don't
want
to
to
mess
with
storage
on
the
logic
contract
and
we'll
talk
about
some
caveats
and
some
issues
that
you
can
run
into
later.
If
something
happens,
the
logic
contract
right,
the
proxy
contract,
is
simply
just
getting
the
code
that
it
should
run.
It's
not
doesn't
really
care
about
what
storage
is
at
the
logic
contract
because
remember
we're
running
it
in
context
of
the
storage
for
the
proxy,
not
of
the
logic.
B
E
F
B
Okay,
so
now
we'll
go
back
to
our
story,
our
ship,
a
on
our
ship
b
and
we'll
jump
out
to
remix,
but
before
we
do
that,
just
to
give
a
kind
of
visual
of
what's
going
to
happen
at
the
top.
Here
we
have,
you
know
our
ship
a
and
we
are
going
to
abandon
ship
from
ship
a
to
ship
b
right,
the
one
that
has
this
renewable
energy
upgrade
and
that's
going
to
be
a
new
logic
contract
that
we're
that's.
B
B
Yeah,
so
that's
so
we're
going
to
abandon
ship
and
switch
out
our
logic
contract
to
a
new
one,
and
we
call
this
an
upgrade.
So
let
me
switch
over
to
remix,
so
the
link
to
this
remix
example
is
in
the
description
for
the
video
and
it's
using
the
magical,
gist
feature
of
remix,
which
is
super
cool.
So
you
just
click
that
and
you
get
you
get
all
the
contracts.
D
B
B
D
B
B
And
if
we
look
at
the
ship
there
it
is
the
titanic,
we
have
a
fuel
supply
of
three
units
and
we
have
some
other
functions
here.
We
have
the
captain
and
we
can
call
travel,
and
so
when
we
call
travel
once
the
transaction
processes
and
then
our
fuel
is
reduced.
So
now
we
have
two
and
we
call
it
two
more
times
our
fuel
is
now
zero
and
if
we
call
it
again,
oh
no
fuel
left.
So
all
right.
We
need
it's
time
to
abandon
ship
right
like
this.
B
B
E
B
B
B
Apparently
we
yeah
and
our
fuel
supply
is
still
zero.
So
if
we
try
to
travel,
we
still
can't
do
that
right.
But
we
have
this
ability
to
add
more
fuel,
so
we
can
call
the
refuel
function
which
captures
energy
from
the
sun
and
and
puts
it
in
the
batteries
and
spins
our
our
our
engine,
so
we're
going
to
refuel.
B
B
B
B
Just
like
a
normal
mapping
where
you
have
you
know
a
location
and
then
a
value,
and
by
choosing
the
specific
slot,
we
can
kind
of
guarantee
a
low
probability
of
collision,
because
it's
such
a
random
location
and
when
I
say
low
probability,
I
mean
like
very,
very
low
and
what
that
does
is
it
allows
us
to
keep
track
of
where
the
logic
contract
is
over
time
without
without
while
keeping
the
same
storage.
Basically
because
it's
going
to
always
occur
at
this
storage
slot,
and
you
can
see
that
right
here.
I
wish.
D
D
What
makes
this
such
a?
What?
What
makes
a
low
probability
of
collision
if
this
is
too
low
level
a
question
to
get
into
here?
I
totally
understand,
but
is
there
something
that
makes
this
harder
than
say?
I
know?
Are
there
storage
slots
that
are
more
commonly
used?
Does
salinity
start
storage
slots
from
the
beginning
and
increment
them
up,
and
this
is
just
so
far
down
that
anyone's
okay
got
it.
C
B
So
part
of
of
the
standard
also
is
the
the
naming
for
how
to
get
the
storage
slot,
and
so
what
we're
doing
is
we're
just
hashing
the
string,
uppercase
proxiable
and
there's
a
couple
other
ways
to
do
this.
There's
also,
you
can
provide
like
a
specific
naming
syntax
here
that
you
can
keep
track
of.
So
you
could
say
eip1820.
D
B
The
implementer
okay
got
it
and
in
fact
the
the
two
examples
right
now
of
this
deployed
on
mainnet.
I
think
they
both
use
something
different,
so
we,
I
think,
I
think
originally
gabriel.
You
had
hoped
that
we
could
standardize
that
slot,
but
it
ended
up
not
being
adopted
as
much
as
we
we
thought
was
going
to.
We
thought.
C
B
Here
is
the
second
contract
that
is
part
of
the
standard,
which
is
the
proxiable
contract,
and
these
don't
necessarily
need
to
be
separate
deployed
contracts.
They
can
all
be
part
of
the
proxy,
and
I
I'm
sorry
I
apologize
this.
This
goes
in
the
logic
contract
that
you
would
deploy.
The
the
proxy
contract
is
in
your
proxy
and
that's
like
what
I
said:
that's
that
thin
layer.
B
You
could
adapt
this
to
your
needs,
but
if
you
can
also
just
use
it
out
of
the
box
in
the
standard
for
proxiable,
and
so
what
proximal
is,
is
it
helps
you
to
perform
an
upgrade
without
getting
into
trouble?
And
so,
when
I
say
getting
into
trouble,
I
mean
something
like
I
want
to.
I
have
ship
a
and
I
want
to
upgrade
to
ship
c,
but
ship
c
actually
doesn't
have
the
ability
to
upgrade
so
I
could
get
stuck.
D
So
I
think,
there's
something
that
I
must
have
misunderstood
before
this:
the
storage
space,
the
xerox,
c5,
etc.
What
is
that
something?
Actually,
let
me
ask
it
like
this:
what's
being
stored
there
in
the
proxy
contract
and
what's
being
stored
there
in
the
logic
contract,
so
that
is
not
being
stored.
C
D
B
Thanks,
I
think
I
think
also
it
could
help
that
I
showed
the
full
contract
in
the
slide,
but
it
was
limited
in
room.
The
the
proxy
evil
contract
is
part
of
your
logic
contract,
and
it
has
this
function.
That's
not
actually
returning
from
storage,
it's
just
from
this
function,
it's
actually
returning
the
same
value.
D
B
B
Essentially,
what
a
library
lock
is
is
it
does
two
things:
it
prevents
the
logic
contract
from
being
called
directly
and
it
also
prevents
things
like
initializing
it
multiple
times,
and
so,
if
you
are
familiar
with
the
parity
wallet
hack,
that
was
a
situation
where
many
many
wallets,
which
were
proxy
wallets,
relied
on
a
single
library
or
logic
contract.
Those
are
the
same,
I'm
using
them
in
the
same
way.
B
And
so
what
the
library
lock
here
addresses
is
to
prevent
something
like
that
from
being
happening
and
preventing
you
from
calling
that
logic
contract
out
there
and
modifying
its
storage,
or
you
know
calling
another
initializer
or
just
you
know,
any
kind
of
funny
business.
Basically,
and
so
hopefully
we
can
keep
the
logic
contract.
Just
this
static.
D
E
D
So
how
does
this
stop?
I'm
taking
a
look
at
this,
it
looks
like
you
have
basically,
a
global
variable
inside
the
contract
called
initialized,
and
it's
set
to
true.
Once
you
call
the
initialize
function
shouldn't
there
still
be
a
little
gap
of
time
between
the
contract
being
deployed
and
someone
calling
the
initialize
function
for
the
contract
to
be
protected
from
direct
calls.
C
F
C
B
You
don't
want
to
get
in
a
situation
where
the
new
logic
contract
thinks
that
things
are
in
different
places,
because
then
you
can
get
into
some
really
bad
situations,
so
the
the
tldr
is
never
reorder
your
storage
when
you're
using
a
proxy
contract,
all
the
always
append
new
items
to
storage,
and
that
might
feel
a
little
weird
right
because
maybe
you're
doing
some
gas,
optimization
and
you're
like
well.
If
I
you
know
put
this
up
here
next
to
the
these
types
of
variables,
then
I
can
save
on
gas.
B
Don't
do
that!
You
want
to
avoid
that,
because
if
your
new
logic
contract
thinks
that
things
are
in
different
places
right
because
that's
possible,
if
you
tell
your
logic,
contract,
hey,
you
know,
here's
the
new
order
of
variables.
It's
going
to
go,
look
at
them
and
it's
going
to
be
in
the
wrong
storage
slots.
B
B
B
Okay,
so
there
are
two
production
examples
of
the
proxy
one
is
the
the
rdi
project,
which
is
a
d5
tool
that
essentially
wraps
compound
and
redirects
the
interest
to
another
party,
and
so
this
was
this
was
my
implementation
of
1822
and
I
ended
up
building
some
tooling
for
that
it's
deployed
now
we
had
it.
We
had
it
audited.
B
So
if
you're
curious
to
see
like
real
world
examples
with
value
in
them,
that's
where
you
should
go
first
and
then
super
fluid
finance
is
in
testnet,
but
it
will
be
coming
out
on
mainnet
soon,
and
so
that
is
the
latest
version
of
production
usage
for
the
groups
proxy
and
again,
this
is
where
I
said.
I
think
both
of
these
examples
actually
use
different
storage
slots.
So
you
know
it's
up
to
the
implementer,
how
you
want
to
name
your
storage
slot
and
then,
of
course,
around
github.
B
There
is
a
a
command
line
package
that
helps
you
convert
your
existing
contracts
to
a
proxy.
Essentially
this
grabs
all
of
your
storage
and
puts
it
into
one
contract
so
that
you
can
apply
the
light,
the
the
same
patterns
and
prevent
you
know,
reordering
storage
and
all
that
sort
of
thing,
and
I
think
it
also
adds
a
library
lock,
so
that
was
kind
of
fun.
I
created
that
back
when
we
were
working
on
rdi.
B
B
D
D
Let's
say
that
someone
knows
that
there's
certain
core
functionality,
they
don't
mind
coding
directly
in
the
proxy
contract
and
there's
only
a
few
little
functions
that
they
want
to
make
upgradeable.
Would
that
be?
Is
that
undesirable
as
in
do
we
specifically
want
the
proxy
contracts
to
be
as
lean
as
possible.
C
B
B
D
You
mentioned
the
diamond
standard
that
actually
was
the
next
thing
I
was
going
to
ask
about
with
the
like,
just
from
a
high
level,
what
the
difference
between
a
proxy
and
a
diamond
does.
Since
I
think
that,
like
my
first
question
was
gonna,
be,
if
you
do
about
the
standard,
I
see
that
you
do
so
from
a
high
level.
What
is
the
difference
between
using
a
proxy
system
and
using
a
diamond
system.
B
B
Yeah,
so
I
think
you
can,
you
can
upgrade
certain
functions
and
you
know
using
any
kind
of
upgradeable
or
proxy.
It
opens
a
can
of
worms
for
governance,
for
decision
making
for
administration
and
so
really
like
it's
up
to
the
group,
the
developers
to
decide.
You
know
what
makes
the
most
sense
for
our
situation.
B
Are
we
a
project
where
you
know
we
only
want
to
say:
hey,
you
know,
community.
We
will
only
ever
touch
these
functions.
We're
never
going
to
touch
these
horns
or
are
we
a
project?
That's
saying
you
know:
hey
we're
in
rapid
development,
we're
not
really
sure
which
functions
we
might
want
to
upgrade.
So
those
are
situations
where
you
want
to
decide.
You
know.
Do
I
want
do.
B
I
want
a
fully
upgradable
contract
like
the
1822
or
do
I
want
to
piecemeal
upgrading
and
do
only
specific
functions,
so
that's
really
kind
of
like
a
more
business
and
community
decision
and
governance
than
it
is
a
technical
one.
Although
there
are
definitely
a
lot
of
technical,
you
know
differences
as
well.
C
D
D
C
D
A
Yeah,
well,
I
mean
already
been
implemented
in
some
of
the
projects,
as
you
discussed
earlier,
so
I
think
review
would
be
the
most
appropriate
state
at
this
point
of
time
to
maybe
you
know
getting
feedbacks
from
the
editor
and
leave
comments
on
how
we
keep
on
processing
this
proposal
to
be
a
standard.
Well,
I
mean
I'm
happy
that
it
is
already.
A
C
Eip
has
been
out
for
quite
some
time
what
patrick
said.
It's
really
our
experience.
There
are
several
developers
reaching
out
trying
to
understand
it.
Some
discussions
on
interior
magicians
after
a
lot
of
conversation,
it
feels
like
there
is
no
nothing
much
to
it
anymore,
to
be
discussed
so
leaving
it
for
a
little
bit
of
time.
C
Just
since
now
we
have
this
video
coming
out
soon
as
well,
more
people
are
going
to
be
aware
of
it
and
might
engage
so
maybe
leaving
a
month
or
two
to
these
newcomers
to
understand
and
see
if
they
still
have
something
to
say
and
then
moving
to
last
call
would
be
actually
something
like
see
as
appropriate.
For
for
the
ipa
right
now,.
A
A
B
B
Morning
and
our
die
is
now
over
one
year
old,
so
one
year
in
production,
with
now
over
a
hundred
thousand
locked
and
die,
which
is
kind
of
a
lot
to
me
at
least
so.
No
no
hacks
yet,
and
hopefully
none
ever
and
also
superfluid
is
about
to
finish
audits,
hopefully
soon,
and
that
will
be
yet
another
audit
that
is,
for
this
specific
eip
or
at
least
an
implementation
of
it.
So
that
would
be,
I
think,
for
me,
like
another
solidifying
factor
at
least.
A
A
I
have
thoroughly
enjoyed
the
conversation
and
hope
that
it
will
be
helpful
for
decentralized
application
developers
considering
to
implement
this
in
their
project.
We
already
have
a
few
live
examples
for
our
youtube
viewers,
the
presentation
and
the
resources
shared
are
available
in
the
description
box.
A
If
you
have
any
questions
that
couldn't
be
answered
today,
you
may
leave
a
comment
or
you
can
ask
the
author,
their
twitter
and
the
handles
are
provided
in
the
description
section
to.
Let
us
know
how
you
like
this
episode
and
which
eip
would
you
like
to
see
in
the
future
episodes
your
feedback
is
important
to
us
and
we'll
be
able
to
bring
more
informative
episodes
for
you.
If
you
have
missed
a
proposal
discussion
earlier,
the
recording
is
available
on
p
penny
playlist
at
ethereum
categories
youtube.