►
Description
Topics covered
-----------------------------
0:49 - EIP introduction
1:35 - Guest’s introduction
3:28 - EIP-4626
4:34 - Definitions
5:28 - Methods in the specifications
6:51 - Example of Rari vault
9:05 - Use of convert to share, asset
12:45 - Max- min function, preview mint
14:20 - Max Withdraw
16:24 - Preview withdraw
17:52 - Events
19:15 - 4626 Implementations
19:35 - Sol implementation
22:20 - Questions
22:50 - In FuseV2, will all fTokens adhere to the 4626 standard? If so, how has the conversion process gone so far?
25:26 - Is there a need and/or want for a 4626/2612 implementation of the standard in solmate? Would be glad to work on it.
26:13 - It seems the EIP has considered simulations. What is the expected usage for 4626?
28:14 - Do you know other implementations or the project for the Vyper implementation?
29:46 - What is the basic motivation to document it as Ethereum standard?
33:22 - Thoughts on the present EIP process. What do you think will help it reach Final status?
38:12 - Is there any important security consideration for implementing in dapps.
Resources:
-----------------
EIP- https://eips.ethereum.org/EIPS/eip-4626
Discussions-To - https://ethereum-magicians.org/t/eip-4626-yield-bearing-vault-standard/7900
ERC playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxqXee9EMQDIEz2CslTnsW0K
PEEPanEIP playlist - https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F
Check out upcoming EIPs in Peep an EIP series at https://github.com/ethereum-cat-herders/PM/projects/2
Follow at Twitter
-----------------------------------------------
Jet Jadeja @JetJadeja | Pooja Ranjan @poojaranjan19 | William Schwab @wschwab_
Contact Ethereum Cat Herders
---------------------------------------------------
Discord: https://discord.io/EthCatHerders
Twitter: https://twitter.com/EthCatHerders
Medium: https://medium.com/ethereum-cat-herders
GitHub: https://github.com/ethereum-cat-herders
Website: https://www.ethereumcatherders.com/
A
A
This
is
merged
as
a
standard
to
ethereum
repository
in
march
2022
to
have
an
overview
of
the
proposal
we
are
joined
by
a
very
special
guest
and
co-author
of
this
proposal.
Jet
jar
jar
checked
jadeja
is
a
solidity
dev
at
rari
capital,
a
d5
project
that
offers
lending
borrowing
and
earning
yield
on
every
asset.
Thank
you
for
joining
us
jet.
B
Yes,
sir,
so
my
name
is
judeja,
I'm
a
16
year
old
solidity
developer
at
rari.
As
puja
just
said,
I've
been
working
in
the
ethereum
space
for
about
a
year
and
a
half.
Now
around
two
years
I
originally
started
working
on
blockchain
technology
with
transmissions
11
back
in
around
2018
school
just
gone
online,
and
we
wanted
to
make
some
cool
projects.
So
we
decided
to
build
a
blockchain
and
that's
really
how
it
all
started.
B
So
we
ended
up
joining
rory
capital
and
we
started
you
know
working
on
some
incredible
projects.
One
of
those
projects
are
were
these
things
called
vaults,
which
are,
you
know,
allow
you
to
earn
interest
on
a
variety
of
different
assets,
and
what
we
realized
is
that
integrating
different
projects
into
these
vaults
was
really
difficult.
You'd
have
to
write
a
new
integration
which
took
time
you
also
had
to
get
it
audited,
which
took
a
lot
more
time
and
was
also
very
expensive.
B
A
B
B
B
So
the
4626
standards
implements
the
erc20
standard
so
that
the
balance
representations
are
completely
fungible,
so
you're
able
to
transfer
yield
bearing
token
balances
around
so
just
going
through
some
of
the
definitions.
The
asset
is
the
underlying
token
managed
by
the
vault.
It's
supposed
it's
supposed
to
be
an
erc20
contract.
The
share
is
the
token
of
the
vault,
so
the
vault
erc
20
asset.
B
It
has
a
ratio
of
underlying
assets
which
is
exchanged
on
mid
deposit,
withdraw
and
redeem,
and
the
yield
bearing
assets
are
supposed
to
or
sorry
the
yield
bearing
shares
are
supposed
to
increase
in
value.
So
the
the
ratio
from
underlying
to
shares
should
increase
over
time.
The
fee
is
basically
an
amount
of
assets
or
shares
charged
by
the
user
by
the
vault.
B
B
The
next
function
we
have
is
convert
to
shares,
and
it
basically
gives
us
the
amount
of
shares
that
the
vault
would
exchange
for
the
amount
of
asset.
Provided
so
say
you
want
to
say,
you
have
a
protocol
that
wants
to
deposit
into
a
vault
and
that
protocol
wants
to
know
how
many
shares
they
will
receive
after
that
deposit.
They
can
simply
use
the
convert
to
share
function
to
see
how
their
yield,
bearing
balance,
is
going
to
increase.
C
Well,
I
mean
there's
a
lot
of
just
of
the
terminology
going
around
and,
of
course
you
use
this.
I
mean
you're,
probably
developing
this
with
ruri.
Do
you
think
it
might
be
easier
if
you
like
gave
an
example
of
the
fuse
pool
or
something
like
that
that
was
using
in
terms
of
like,
what's
getting
deposited,
what
you're,
holding
and
kind
of
what
you?
What
you
expect
to
see
yeah.
B
For
sure
yeah,
so
I'll
use
the
ferrari
vault
as
an
example
with
rory
vaults,
you're,
going
to
be
able
to
create
a
vault
for
basically
any
asset,
that's
supported
by
fuse
and
it's
it's
essentially
a
yield
aggregator.
So
it
will
deposit
into
the
fuse
pools
that
have
the
highest
integers.
So
for
a
quick
example,
let's
use
like
a
usdc
vault
so
for
the
usdc
vault,
you
have
the
underlying
asset
set
to
the
address
of
usdc
and
then
you'll
have
rv
usdc,
which
is
the
the
share
token.
B
C
B
Token,
exactly
I
mean
technically,
the
value
would
start
going
down,
because
the
ratio
between
underlying
and
shares
is
going
to
decrease.
However,
the
value
of
the
share
is
going
to
increase,
so
the
convert
to
shares
is
going
to
decrease,
but
we
have
another
function
called
convert
to
assets
which
allows
you
to
put
in
a
an
amount
of
shares
and
get
out
in
the
amount
of
underlying,
and
then
that
value
is
going
to
increase
as
the
value
of
the
shares
increases
as
well
and
basically,
as
the
vault
accumulates
more
and
more
underlying
so
yeah.
B
The
next
function
is
the
max
deposit,
and
that
tells
you
the
maximum
amount
of
underlying
asset
that
can
be
deposited
into
the
vault
for
the
receiver
through
a
deposit
call
so
yeah.
I
mean
this
this.
Essentially
it's
pretty
it's
pretty
simple
it.
It
just
returns
the
amount
of
underlying
assets
that
can
be
deposited
and
if
there's
no
limit
it
just
returns,
the
maximum
integer
size,
which
is
2
to
the
power
of
256
minus
1..
B
However,
this
is
essentially
a
stimulation,
so
you're
able
to
you're
you're,
basically
able
to
simulate
the
so
so
in
most
cases
for
most
vaults
preview,
deposit
and
our
other
function
convert
to
shares
are
going
to
have
the
same
output.
However,
there's
some
cases
where
there's
say
like
slippage,
where
they
might
have
different
different
outputs,
then,
finally,
we
get
to
deposit,
which
is
the
actual
interaction
where
you
mint
shares
to
the
user,
who's
depositing
to
the
receiver
by
depositing
exactly
the
amount
of
underlying
tokens.
B
So
it
requires
you
to
make
a
call
before
depositing
to
check
your
balance
and
then
make
a
call,
after
depositing
to
check
your
balance
after
the
deposit
and
then
you're
able
to
just
subtract
the
newer
one
from
the
original
one
to
get
the
amount
of
shares
minted.
However,
that's
a
really
inefficient
way
of
doing
things.
It
requires
two
extra
calls,
whereas
here
we're
simply
making
a
bit
of
extra
return
data
to
return
the
amount
of
shares
emitted,
which
is
definitely
going
to
help
a
lot
of
integrators.
B
So
a
lot
of
these
these
functions,
a
lot
of
these
methods
are
going
to
be
focusing
on
trying
to
make
the
experience
for
integrators
better
than
it
currently
is
by
the
way.
I
do.
You
guys
think
that
that
going
through
each
function
is
the
best
way
to
go
through
things,
or
would
you
prefer
that
we
go
into
the
the
code?
How
do
you
guys
think
we
should
go
about
this.
C
B
Perfect
perfect,
so
yeah
just
going
through
the
next
function
max
mint.
It
basically
allows
you
to
put
in
the
name
of
the
receiver
and
gives
you
the
maximum
amount
of
shares
that
can
be
minted
from
the
vault
to
the
receiver
and
what's
useful
about
this,
is
it
enables
developers
to
say
have
like
a
like,
for
example,
like
boost
shares
to
a
specific
user.
There's
a
lot
of
use
cases
enabled
by
this,
rather
than
just
having
a
maximum
deposit
value.
B
The
next
one
is
a
preview
mint
so
going
through
the
through
the
actual
interactions.
We
have
multiple
ways
to.
We
have
two
ways
to
deposit
and
two
ways
to
withdraw.
We
have
a
deposit
function
which
takes
in
the
amount
of
underlying
tokens,
you're
depositing
and
returns
the
amount
of
shares
that
are
being
minted.
You
have
a
mint
function
which
takes
in
the
amount
of
shares
that
you're
minting
and
returns
the
amount
of
underlying
tokens
that
you
want
to
deposit
and
there's
also
two
ways
of
withdrawing.
B
So
this
is
basically
the
same
as
preview
deposit
except
it
takes
in
the
number
of
shares,
rather
than
the
number
of
underlying
tokens
and
then
yeah
the
mid
function.
So
it
means
exactly
the
exact
amount
of
shares
to
the
receiver
by
depositing
the
amount
so
it
takes
in
shares
and
then
returns
the
amount
of
assets
max
withdraw.
Is
it
basically
enables
the
user
to
see
how
much
all
right
sorry
to
see
how
the
owner
to
see
how
much
they
can
withdraw?
B
B
Oh
good,
no!
No!
No!
So
I
I'm
pretty
familiar
with
the
compound
code
base.
So
yeah,
it's
gonna
revert
it's
gonna!
It's
compound
will
basically
check
how
much
they
have
on
hand
and
if
too
much
is
being
borrowed,
it'll,
basically
just
just
revert
but
you're
able
to
check
in
the
math
you're
able
to
to
check
how
much
compound
does
have
on
hand.
So
in
the
max
withdraw
function
here
you
can
just
return
that
value.
B
Moving
on
to
preview,
withdraw
basically
does
the
exact
same
thing
as
preview
deposit
improve
your
mint,
except
for
withdrawals
you
put
in
a
number
of
assets
and
it
will
return
a
number
of
shares
that
are
being
burned.
This
is
the
actual
withdrawal
function
takes
in.
It
takes
in
three
different
parameters.
First,
it
takes
in
the
number
of
assets
that
you're
trying
to
withdraw.
B
Now
is
the
actual
redeem
so
yeah
it
burns
the
exact
amount
of
shares
from
the
owner
and
then
sends
those
assets
to
the
receiver
so
going
through
the
events.
We
wanted
to
add
quite
a
few
events
to
make
it
easier
for
integrators
because,
as
I
said
earlier,
we
want
to
try
and
really
make
the
experience
for
integrators
as
as
beneficial
as
possible.
I
mean
as
easy
and
smooth
as
possible,
so
the
deposit
event
takes
the
name
of
the
caller
and
the
reason.
B
Why
is
because
our
deposit
functions
as
we
went
through
earlier,
taken
a
recipient
address.
So
even
though
I
could
call
the
deposit,
the
shares
could
be
sent
to
another
address
the
withdrawal
function.
Oh
sorry,
let
me
let
me
go
through
the
the
rest
of
the
deposit
event.
Okay,
so
it
takes
in
the
caller,
the
owner,
the
amount
of
underlying
assets
being
deposited,
and
the
number
of
shares
being
minted
withdraws
very
similar.
It
has
one
more
one,
more
variable
or
sorry,
one
more
parameter,
so
it
takes
in
the
caller.
B
B
So
there
is
a
viper
4626
and
soulmate
4626
implementation
and
then
open
zeppelin
is
actually
coming
out
with
the
46
and
4626
implementation
really
soon
so
yeah
I
mean
I'm
I'm
much
more
familiar
with
the
soulmate
4626
contract
and
basically
it's
implemented
almost
all
of
this
logic
in
a
really
efficient
manner.
However,
there
is
some
functions
that
you're
going
to
need
to
implement
yourself,
one
of
them
being
the
total
assets
function
and
that.
B
B
Then
a
before
withdraw
and
then
after
deposit
and
that
that's
really
all
there
is
to
it
I
mean
you
can
add
as
much
extra
functionality
as
you
want
to,
but
the
base
4626
contract
is
just
all
of
this,
and
then
it
has
all
of
that
logic
for
depositing,
like
preview
deposit.
All
of
that
stuff
is
in
this
contract,
but
all
the
developer
has
to
do
is
just
implement
these
few
functions.
B
C
C
D
C
C
A
A
I
mean
eap.
4626
made
it
in
a
very
short
period
of
time.
Now
I
understand
why,
because
of
so
many
people
working
together,
I
suppose
and
yeah
I'm
sure
this
will
help
new
projects.
Looking
for
some
standard
api
for
tokenized
walls,
I
have
a
few
question:
if
anyone
else
has
any
technical
question,
please
write
it
on
the
chat.
I
think
william
sharp.
You
may
have
some
question.
You
want
to
go
ahead.
First,.
C
B
B
B
C
B
C
All
right
and
vex's
second
question:
is
there
a
need
and
or
a
want
for
a
4626
slash,
26
12
12
implementation
of
the
standard
soulmate
would
be
to
work
on
it.
Also,
do
you
mind
repeating
that
you
cut
out
a
bit?
Oh
sure,
let
me
just
check
that
basically
vex
is
asking:
if
there's
any
work
being
done
to
integrate
2612
permits
into
4626
in
soulmate.
B
C
B
C
A
The
first
one
is
related
to
implementation.
The
proposal
refers
an
implementation
in
solidity
and
viper
and
rari
capital
has
implementation.
You
did
mention
that
there
is
an
implementation
in
open
zaplin
coming
up.
I
was
wondering
like
if,
if
you
are
by
any
chance
aware
of
any
other
project
they
are
planning
to
implement,
there
is
demo
of
viper.
Do
you
by
any
chance
know
the
name
of
the
project.
A
B
A
A
A
B
It's
very
difficult
to
write
integrations
for
a
lot
of
different
projects,
especially
when
you
have
to
get
all
of
them
audited,
which
takes
a
lot
of
time,
and
it's
also
quite
dangerous
in
july.
I
believe,
if
last
year,
ferrari
capital
got
hacked
our
our
east
pool
due
to
an
integration
with
alfa
hamora
and
what
was
very
interesting.
Is
we
had
gotten
that
integration
audited?
We
had
sent
it
to
their
team
and
they
had
approved
of
it.
B
Yet
it
still
got
hacked,
which
shows
how
having
custom
integrations
can
can
be
quite
dangerous,
especially
because
auditors
don't
look
into
the
code
base
of
other
projects.
Right
they're
only
really
hard
to
look
into
your
own
code
base
and
then
we
also
got
it
reviewed
by
them
and
they
didn't
raise
any
problems,
and
you
know
that
definitely
shows
the
dangers
of
having
to
write
integrations,
whereas
with
a
single
standard,
it's
a
lot
harder
to
have
problems
like
that,
for
example
with
erc20.
B
If
I
want
to
get
say
usd
like
a
usdc
integration,
I
don't
have
to
go
to
to
like
the
usc
usdc
developers
and
get
my
integration
audited
by
them.
I
can
simply
integrate
it
and
have
independent
auditors
do
that
with
4626.
We
wanted
to
speed
up
the
development
process
and
also
make
the
contracts
safer.
So
one
example
that
I
like
to
bring
up
a
lot
is
uniswap
say
there
was
no
erc20
standard.
B
Imagine
if
every
time
you
wanted
to
create
a
new
uniswap
pool,
the
uniswap
developers
would
have
to
go
through
write
a
whole
new
uniswap
pair
contract
based
on
these
new
tokens
and
then
get
that
audited.
The
space
would
be
behind
by
so
much
because
you
wouldn't
be
able,
because,
like
you
know,
being
able
to
to
create
these
unit,
swap
pairs
would
take
months
and
months
and
that's
currently
the
state
of
yield
bearing
tokens
and
integrations.
A
That
is
quite
inspirational
here.
I
know
the
d5
project.
They
are
generally
relying
on
the
audits
and
when
even
after
or
something
goes
wrong,
people
try
to
come
up
with
a
standard
that
is
really
incredible.
Of
you.
Guys
of
documenting
is
as
a
standard
for
many
other
developers
who
would
be
coming
in
future
trying
to
have
something
implemented
in
there.
A
My
next
question
is
related
to
eip
process
and
directly,
as
I
have
been
repeating
it
constantly
like
this,
is
one
of
the
fastest
moving
proposal.
According
to
a
start
from
2021,
only
20
erc
proposals
made
it
to
final.
This
may
be
an
old
number,
but
ratio
of
proposed
versus
final
eip
is
generally
low.
There
could
be
many
reasons
for
that.
Some
people
think
that
the
process
may
be
one
of
those
I'm
curious
to
understand.
As
an
author.
What
was
your
experience
documenting?
B
B
You
know.
I
think
that
that
the
experience
is
good
and
I
didn't
realize
how
low
the
the
finalization
rate
was
like
that.
That
is
crazy,
five
to
one
or
four
to
one
sorry
but
yeah,
I
I
think
that
it
was.
It
was,
you
know,
a
really
great
experience.
I
wasn't
the
one
making
the
like
prs,
but
you
know
based
on
what
some
of
the
other
co-authors
did.
You
know
it
was.
It
was
pretty
smooth
yeah.
A
B
A
B
B
So
I
think
that
we
got
a
lot
of
attention,
and
that
was
something
that
really
helped
was
there's
a
lot
of
ercs
and
a
lot
of
eips
that
you
know
don't
have
that
much
attention
and
you
know,
are
less
likely
to
get
past.
So
I
think
the
key
is
really
getting
a
lot
of
people
to
notice
and-
and
you
know
through
that,
you're
more
likely
to
get
approved.
B
Yeah-
and
I
mean
you
can
kind
of
see
how
general
we
made
4626
through
some
of
those
functions
like
the
preview
functions
like
the
the
max
functions.
All
of
that
we
wanted
to
add
those,
because
you
know
there's
so
many
things
that
you
could
do
with
tokenized
faults
and
yield
bearing
assets.
We
wanted
to
try
and
have
4626
cover
a
wide
variety
of
of
different
places
and
a
different
projects.
A
Thank
you
for
sharing.
I
hope
these
tips
help
new
authors,
push
their
proposals
towards
final
all
right.
My
last
question
is
related
to
security
consideration.
The
proposal
carefully
documents
many
security
considerations
for
using
this
standard.
Of
course
it
requires
some
careful
implementation
in
different
project.
People
may
have
different
projects,
and
implementation
may
vary.
I'd
be
curious
to
hear
from
you
if
there
is
any
specific
security
consideration
that
a
project
developer
shouldn't
miss
under
any
circumstances,
would
you
like
to
talk
a
bit
about
so
project
dev?
B
Yeah,
so
so
for
people
who
are
implementing
it
within
their
project,
I
think
that,
like
99
of
protocols
and
projects
that
are
using
4626
are
going
to
use
either
the
open,
zeppelin,
soulmate
or
viper
implementation,
which
really
covers
the
majority
of
the
logic
that
you
need
to
implement.
However,
there's
you
know
there's
for
projects
that
are
not
using
those
which
may
have
you
know
some
some
more
modifications
that
they
might
want
to
make
it's.
It's
definitely
a
bit
more
dangerous
to
do
that
and
implement
that
logic
by
yourself.
B
So
yeah
I
mean
in
terms
of
actually
actual,
like
you
know
anything
to
look
out
for
as
an
implementer.
I'm
not
entirely
sure.
I
think
that
you
know
there's
a
lot
that
can
go
wrong.
So
sticking
to
the
4626
implementations
that
have
already
been
written
and
are
widely
used
is
probably
the
best
way
to
go
now
for
integrators.
A
B
Yeah,
so
one
last
thing:
I
think
that
if
you're,
you
know
not
feeling
like
fully
comfortable
if
you're
unsure
about
implementing
4626
within
your
project,
I
think
it's
it's
really
important
and
really
essential
that
you
do
so,
because
4626
will
definitely
enable
a
lot
of
other
projects
to
be
able
to
use
and
integrate
within
your
product
or
integrate
your
project
into
their
own
code
bases.
I
mean
it,
makes
the
lives
of
you
know,
developers
so
much
easier
to
to
have
standardized
faults,
so
it
you
know
it.
B
A
A
On
this
note,
thanks
to
all
our
youtube
viewers
for
watching
and
sharing
your
feedback
with
comments,
check
out
description
for
related
links
and
guest
twitter
to
follow.
If
this
helped
you
help
others
hit
like
and
share
to
increase
reach.
Should
you
have
any
question
on
this
proposal
or
any
other
talk?
Let
us
know
in
the
comment
or
reach
us
on
eat
cat
herders
discord
subscribe
to
the
ethereum
categories,
youtube
channel.
If
you
haven't
done
it
already
see
you
next
time
with
another
interesting
proposal
till
then
keep
watching
keep
sharing
your
love
with
the
team.