►
From YouTube: Peep an EIP #5: EIP-2666 in five slides with Alex Vlasov
Description
EIP-2666 (PR): https://github.com/ethereum/EIPs/pull/2666
Slides: https://docs.google.com/presentation/d/1GuGoD2mVrXFwHXbAsE6c9YC8F4zKYEv7_3forMPg5KU/edit
Discussion at the fellowship of Ethereum Magician: https://ethereum-magicians.org/t/eip2666-global-precompiles-repricing-and-many-more-discussion-thread/4332
Follow Alex Vlasov at Github/Twitter (@shamatar), James Hancock (@JHancock),
EIP-2537 in five slides with Alex Vlasov on Peep an EIP - https://youtu.be/al4YpfDVmS4
Peep an EIP schedule at GitHub: https://github.com/ethereum-cat-herders/PM/projects/2
Contact Ethereum Cat Herders at
Discord: https://discord.gg/sgdnxZe
Twitter: https://twitter.com/EthCatHerders
Medium: https://medium.com/ethereum-cat-herders
Follow Pooja Ranjan (@poojaranjan19), William (@William94029369)
A
A
B
Okay,
thank
you.
So
we
will
jump
directly
to
a
small
overview.
How
brigham
wells
work.
It's
essential
to
understand
the
essence
of
this
keep
itself.
So
pre-compiles
were
introduced
at
the
beginning
when
it
was
necessary
to
offload
computation
of
some
specific
functions
which
were
just
too
expensive
if
one
would
express
them
in
terms
of
evm
and
like
solidity
contract,
for
example.
Oh
that's
why
there
are
a
few
precompiles
right
now
they
are
from
address
one
to
address
8,
which
executes
some
cpu
intensive
tasks.
B
One
interesting
thing
about
them
is:
there
is
no
code
under
these
addresses,
but
whatever
used
sent
as
input
when
you
perform
a
call
or
a
static
call
in
evm
is
just
directly
fed
into
the
native
function
and
this
function
is
pure.
So
it
means
that
there
is
no
access
to
disk
and
there
are
no.
I
o
operations
which
are
quite
expensive
in
this
room
right
now.
B
Everything
which
is
done
is
just
some
piece
of
memory
is
sent
to
the
function
as
the
input,
and
then
this
function
performs
some
computations
elsa
for
each
precompile.
One
has
to
come
up
with
a
formula
how
to
measure
the
gas
band
biases
precompile,
because
it's
no
longer
in
evm
environment,
so
you
cannot
pay
a
single
and
well
determined
gas
per
each
kind
of
operation.
B
So
it's
kind
of
initial
point
from
where
we
start,
and
first
it
comes
as
if
eve
2046
is
accepted,
which
reduces
the
price
of
performing
as
pc
calls
to
precompiles,
because
those
goals
as
as
was
mentioned,
are
quite
cheap.
They
don't
need
to
read
anything
from
this,
so
eve
2046
proposes
to
reduce
a
cost.
B
For
this
specific
case,
if,
let's
say
we
limit
address
range
for
all
pre-compiles
from
1
to
1023,
so
it's
like
lowest
10
bits
of
the
address
space,
then
one
would
be
paying
much
less
to
perform
such
static
call
and
as
an
example,
we
will
get
to
concrete
numbers
later
right
now.
Performing
a
shot.
256
function
would
cost
roughly
70
gas
for
kim
actually
performing
the
computations
of
the
pre-compile
itself,
but
it
would
cost
700
gas
to
actually
perform
the
call
to
this
precompile.
B
B
When
new
costs
were
proposed,
like
an
excessive
cost
of
call,
was
taken
into
the
int
account,
so
let's
kind
of
make
it
in
concrete
numbers.
If
one
would
actually
benchmark
be
an
edition
precompile
in
a
set
of
major
ethereum
clients,
he
would
get
the
numbers
that
in
the
worst
case,
this
function
just
take
something,
as
the
input
do
all
necessary,
computations
and
return.
The
output
would
cost
around
350
gas
in
the
worst
case
in
the
slowest
clan,
but
it's
still
fine.
B
B
Well,
I'm
not
the
person
who
proposed
eleven
or
seven
and
eleven
or
eight,
and
maybe
by
the
time
when
benchmarks
were
done,
and
maybe
they
were
done
not
on
a
full
set
of
clients,
so
some
clients
actually
fit
into
this
150
and
6000.
They
do,
but
not
all
of
them,
and
so
for
a
slowest
client.
The
safe
value
will
be
350,
which
is
larger,
but
still
this
discrepancy
is
kind
of
covered
by
700..
So
those
fixes
are
just
kind
of
safe
values.
B
But
before
this
it
was
in
general,
a
sentiment
that
called
to
precompile.
It
never
takes
this
much
time
to
execute
in
israeli
node,
so
there
was
a
sentiment
that
this
value
is
kind
of
wasted.
So
let's
kind
of
compensate
for
this
waste,
so
this
part
of
the
precompile
is
actually
just
get
everything
homogeneous.
So
it's
40
gas,
which
is
I
mean
for
ep
2046.
B
If
it's
actually
40
gas,
which
ethereum
client
spends
to
do
a
static
call
to
the
pre-compile,
it
still
needs
some
manipulations,
like
you
still
have
to
copy
some
memory,
then
let's
say
it's
40
gas,
but
we
measured
it
properly.
This
time
it's
never
700,
as
for
calls
to
pre-compile
two
contracts
which
requires
reading
from
disk,
for
example,
then
we
just
measure
everything
correctly.
This
is
the
first
part
of
this
eep,
so
we
just
set
correct
values
and
set
save
values.
B
So
this
freaking
file
will
be
repriced.
Another
pre-compile
on
address
equal
to
one
is
just
a
memory
copy
which
is
well
priced.
So
actually,
after
this
ip
is
accepted,
like
almost
every
precompile
is
repriced
to
properly
reflect
like
how
expensive
it
is,
and
by
properly
reflect,
I
mean
like
how
much
cpu
time
execution
takes
and
then
so
we
transform
cpu
execution
time
to
the
gas
and
said
this
price
for
every
pre-compile
so
for
hash
functions.
B
It's
well
in
theory.
One
would
be
able
to
measure
cpu
cycles
directly,
but
in
practice
it's
usually
done
that
we
take
easy
recover
as
the
ground
truth.
So
we
assume
that
easy
recovery
pre-compile
is
priced
properly
for
7000
gas,
then
on
a
local
machine,
one
runs
a
benchmark
for
easy
recovery
and
then
one
can
derive
actually
from
execution
time
of
ec
recover.
B
How
much
gas
can
kind
of
this
specific
machine
produce
per
second,
and
this
constant
is
enough
to
transform
any
other
measured
execution
time
or
any
other
function
into
its
gas
price,
and
it
is
specific
machine
dependent.
It
will
depend
on
cpu
frequency
largely,
but
if
we
assume
that
everything
just
depends
linearly
on
cpu
frequency,
then
this
constant
will
be
machine
specific,
but
in
general,
gas
value
will
be
proper
on
every
machine.
B
I
see
so
for
this
hash
functions.
Those
are
smaller
standard
hash
functions,
how
they
do
work
as
when
you
feed
the
input
of
some
lengths
into
this
hash
function
internally,
depending
on
specific
one.
They
do
some
work,
which
involves
putting
the
input
volume
with
few
extra
bytes
and
then
hash
function
starts
to
take
a
block
length
from
this
padded
input
and
starts
to
kind
of
mutate
internal
state
to
produce
the
output
at
the
end
of
the
day.
B
So
those
functions
they
depend
not
on
the
length
of
the
input,
but
first
of
all
on
the
pilot
length
of
the
input
and
then
like
how
many
chunks
of
specific
lengths
this
padded
input
will
take
as
an
example.
Here
I
will,
I
didn't
post
specific
formulas,
they
can
be
found
in
eep
itself,
but
as
just
as
an
example
at
the
moment
for
all
those
hash
functions
and
a
few
of
those
are
pre-compiles
like
shatter.
B
B
B
If
one
would
look
at
the
internal
structure
of
the
hash
functions
or
just
perform
a
benchmarking
of
this
hash
functions
on
different
lengths
of
the
input
starting
from
zero
bytes
and
doing
steps
like
one
byte
each
after
this
benchmark,
one
would
observe
that
execution
time
of
these
functions
behaves
like
a
stop
function
and
with
steps
at
some
specific
values.
So,
for
example,
kch256
hash
function
will
take
the
same
time
to
execute.
B
If
input
is
empty,
so
like
zero
bytes
or
if
input
is
128
bytes,
the
execution
time
will
be
sustained
and
it
just
reflects
the
internal
structure
of
the
hash
function
for
shutter
5
6.
This
is
the
same
behavior.
Just
constants
will
change
here.
For
example,
zero,
bytes
and
48
bytes
still
will
be.
The
same.
Internal
execution
still
will
be
the
same
execution
time.
Even
while,
if
we
use
existing
formula
for
pricing,
one
would
have
to
pay
different
prices
for
these
two
cases.
C
B
C
B
B
We
should
try
to
reflect
this
logic
in
pricing
formulas
and
again,
there's
a
funny
fact
that
in
this
case,
some
some
use
cases
will
actually
benefit
from
this
repricing,
because
if
one
would
use
a
binary
miracle
tree
where
you
would
do
a
lot
of
operations
of
hashing
64
bytes,
then
you
would
actually
pay
less
than
you
would
currently
pay
for
keycheck
256
function.
Does
that
automatically
mean
that
it's
a
dos
vector?
B
No
it's?
It
doesn't
mean
that
it's
those
vector
those
numbers
which
are
proposed.
I
mean,
if
you
represent
the
internal
structure
of
the
function
in
your
gas
pricing
formula.
It's
not
a
dose
factor
as
it
is.
You
just
need
to
place
proper
coefficients
in
a
formula
and
those
coefficients
are
also
determined
from
the
benchmarks,
so
benchmarks
were
supplied
by
major
clients.
B
I
ran
open,
ethereum
and
gas
benchmarks
myself
and
guys
from
nezerman
and
beso
provided
benchmarks
which
saved
it
by
themselves.
It
allowed
to
determine
the
constants
which
have
to
be
used
in
this
form
in
this
formulas
for
pricing.
So
that's
why
it's
not
a
dos
factor
we
still
take
in
this
account
a
concrete
and
real
performance
of
all
major
clients,
well,
with
maybe
exception
for
basu,
which
one
which
have
a
work
planned
to
optimize
these
functions.
B
B
If
one
would
actually
do
it
based
on
a
pair
of
the
fastest
one,
then
this
discount
will
be
even
larger,
much
closer
to
two.
So,
at
the
end
of
the
day,
like
anyone
who
would
want
to
have
hash
functions
in
his
application
or
smart
smart
contract
will
allow
his
users
to
pay
less
for
it.
I
don't
kind
of
directly
touch
here
that
keychaik256
is
extensively
used
in
many
other
applications
like
determining
the
storage
address.
B
B
B
Okay,
so
then
we
can
continue
to
as
a
current
state
as
we
discussed
during
the
previous
few
slides
already
all
major
clients.
They
have
provided
the
benchmarks
for
current
implementations,
which
allowed
to
derive
pricing
formulas,
so
we
it
was
possible
to
determine
all
the
necessary
constants
in
the
pricing
formulas.
B
So
now
it's
kind
of
waiting
for
decision
and
award
for
class
developers
how
fast
it
can
be
implemented,
but
in
general,
this
structure
of
this
is
much
less
complex
than
another,
which
you
have
discussed,
which
is
2567
so
here,
one
that
doesn't
take
any
complex,
cryptography
or
functions
which
can
be
implemented
different
ways
here.
One
just
have
to
follow
the
spec
to
implement
formula
how
to
derive
gas
cost
from
the
input
from
the
lengths
of
the
inputs.
B
A
D
I'm
curious
what
your
experience
was
like
going
into
this,
as
you
were
thinking
about
proposing
it
or,
as
you
kind
of
went
into
the
code
base
and
were
discovering
some
of
these
price
mismatch
mismatches
and
things
like
what
was
that
like?
Was
there
things
that
weren't
expected
were
there
things
that
were
unexpected.
B
B
So
I
just
decided
to
quickly
do
this
part.
It's
like
at
least
for
rust,
openly
steering
client
and
for
go
in
gas
client.
It
wasn't
very
quick
to
do
and
then
just
by
looking
at
the
plots
of
execution
time
versus
lengths
of
the
inputs,
it
was
clear
that
formulas
have
to
be
made
different
to
actually
reflect
the
behavior.
B
D
B
Yeah,
I
mean
we
discussed
it
as
the
course
of
discussion
of
this
first
slide,
which
is
now
on
the
screen,
in
the
sense
that
yeah.
I
understand
that
the
esprit
compile
is
just
a
pure
function,
so
everything
you
need
to
do
is
just
take
some
code.
Take
some
piece
of
memory
and
there's
an
execution
you
don't
have
to
pay
for
cost
of
performing
disk
lookup.
If
you
actually
do
the
call
to
any
of
the
real
contracts
which
takes
up
may
take
some
storage.
D
D
So
I
I
remember
when
we
were
first
starting
about
this
getting
excited
we've
had
times,
we've
had
a
lot
of
discussions
about
gas
costs
over
the
past
year
and
a
half,
and
this
is
just
some
history,
because
axic
originally
proposed
that
I
think
we
talked
it
before
he
proposed
about
it
as
well,
and
it's
and
it's
always
been
this
matter
of
yeah.
We
have.
We
have
an
inefficiently
priced
pre-compiles
or
op.
D
General
and
opcodes
are
the
stuff
that
your
your,
if
you're,
call,
if
you're
doing
something
on
ethereum
and
your
gas
is
whatever
amount.
It's,
because
off
codes
are
adding
up
to
that
gas.
So
any
reduction
or
more
accurate
gas
cost
for
an
opcode
means
really
means
a
reduction
mostly
at
this
point,
because
most
of
them
are
overpriced.
B
D
D
Where
there's
a
lot
of
other
work,
that's
still
that
is
going
on.
It
needs
to
be
done
so
that
we
have
haven't.
Had
anyone
do
it
so
seeing
you
do
this
for
just
the
for
the
precompiles
and
the
eips
you've
been
working
on,
it's
been
really
awesome
and
I'm
I'm
looking
forward
to
all
these
things
rolling
out.
B
B
B
It's
quite
easy
to
explain
like
most
use
cases
actual
execution
time
of
this
pre-compile
itself
will
be
in
a
range
of
let's
say,
10
gas,
but
then
you
would
immediately
pay
40
on
top
of
this
just
for
a
static
call,
and
you
would
need
to
do
much
more
than
one
call
to
this
pre-compile
to
actually
implement
blake
to
hash
function,
because
current
pre-compile
is
only
kind
of
what
internal
routine
of
this
hash
function.
Not
the
hash
function
itself.
D
B
It's
not
like,
like,
even
if
you
would
charge
one
gas
for
a
like
blake
to
compression
function
itself
in
a
pre-compile,
you
will
always
pay
40
on
top,
when
you
will
just
try
to
call
it.
So
it's
immediately
increases
the
final
cost
of
implementing
blake,
as,
for
example,
as
a
solidity
contract
tenfold
compared
to
implementing
it
as
a
like
as
a
full
pre-compile
for
a
specific
hash
function.
B
D
B
B
B
D
D
Yep
and
the
and
the
reason
why
there's
there's
there's
like
hesitation
to
do
this
immediately
is
the
dos
vector
or
denial
of
service
if
we
price
a
precompile
or
an
op
code
or
anything
too
low,
and
someone
can
call
it
enough
to
expand
the
network
and
and
do
something
bad
so
that's
in
between,
we
want
to
get
the
prices
right
and
we
need
and
the
amount
of
work
needed
to
verify
that
there
isn't
going
to
be
a
problem
with
the
clients.
It's
just
a
lot.
B
Yeah,
it's
taken
quite
some
time
to
measure
just
the
pre-compiles,
so
it
will
take
even
more
to
reprice
everything
but
like
internally.
I
have
an
impression
that
most
of
the
op
codes
and
all
and
us
operations
is
well
priced.
So
it
will
be
just
kind
of
cherry
picking
the
changes,
but
still
to
be
sure.
One
would
have
to
do
its
over
kind
of
every
possible
op
code
in
general
operation.
E
Yeah,
so
sorry,
I'm
just
going
to
jump
in
here
pretty
late.
So
I'm
sorry
it's
already
going
to
ask.
But
while
I've
been
researching
like
how
the
evm
works,
I
feel
like
so
are
like,
is
there
any
way
around
having
a
really
frankly
complex
system
to
monitor
the
the
work
done
by
the
pre-compiles,
or
have
we
considered
doing
something
along
the
lines
of
like
a
a
sub
evm
style
like
assembly
or
what
webassembly
setup
that
can
monitor
it?
B
B
It
would
just
introduce
inefficiencies,
as
this
is
a
having
a
low
gas
price
for
these
operations
was.
One
was
initially
reason
why
quickbiles
were
introduced,
and
the
ketchup
itself,
for
example,
was
even
made
into
the
opcode
so
because
those
functions
are
very
fast
on
the
on
the
processor
itself,
even
without
any
cpu
specific
assembly,
but
when
implemented
like,
but
when
the
same
code
is
compiled
in
wasm,
usually
it's
still
three
to
five
times
penalty
to
execute
the
same
code
like
as
an
example,
I
think.
B
He
compiled
it
to
wasm
and
tried
to
run
benchmarks
on
kind
of
some
common,
some
popular
set
of
operations
there
and
functions
and
in
general,
the
execution
time
was
three
to
five
times
larger
in
wasn't
compared
to
the
native
code.
Of
course,
one
can
try
to
optimize
wasm
and
a
virtual
machine,
but
it's
still
like,
but
if
one
would
optimize
vast
virtual
machine
all
the
way
down,
it
will
become
the
native
code,
so
one
would
have
to
compile
down
to
it.
D
D
These
these
little
bits
of
code
need
to
be
flipped
around
and
done
whatever
and
then
saved
how
how
I'm
requesting
and
and
the
people
who
run
that
code
at
the
end
those
get
put
around
in
transactions
and
in
the
end,
the
miners
or
block
producers
in
news
world
are
running
those
that
code
and
that
that
has
like
them
having
their
computer
run.
That
code
takes
a
certain
amount
of
time,
and
so
the
fur,
the
closer
you
get
to
purely
how
their
computer
is
running
the
code.
Then
the
closer
this
less
and
more
accurate.
E
So
I
I
can
understand
that
logic
in
terms
of
the
optimizations
of
it,
but
I
do
know-
or,
as
I
understand
it,
pre-compiles
in
general
are
a
pretty
contentious
topic
within
the
community
because
they
sort
of
because
I
it's
it's
just
sort
of
you
know
opaque
or
it's
not
really
clear
as
to
what
exactly
is
happening,
because
if
they're
just
running
you
know
a
random
code.
How
do
you
know
that
they're
running
that
one,
which
I
think
is
what
you
guys
were
talking
about,
but.
D
E
B
But
I
mean
hash
functions
in
inside
of
them
are
still
very
untrivial
functions.
The
same
goes
for
any
cryptography
and
we
use
it
every
day
when
one
signs
serum
transaction
and,
I
think,
all
of
the
clients.
Until
recently,
they
used
this
same
and
single
library
to
make
signatures,
which
is
a
c
library
for
segp
curve,
which
is
used
by
bitcoin
in
ethereum,
and
this
doesn't
probably
trouble
anyone,
so
only
travel
becomes
when
people
started
to
want
kind
of
independent
implementations
which
actually
becomes
a
technical
depth.
B
E
Complex
algorithms
that
will
need
to
change,
but
using
highly
optimized,
simple
programs,
if
that
makes
sense
like
using
the
outputs
which
is
more
or
less
what
it's
doing,
but
why
don't?
We
just
do
kakat
with
with
the
other
op
codes.
For
example,
I
mean
I,
I
saw
the
performance
overhead
problem,
but
doesn't
that
kind
of
limit
the
scope
of
the
ethereum
network.
B
B
A
B
B
There
is
elsa
kind
of
proposal
to
logically
split
it
to
five,
like
five
separate
gives
for
each
individual
repricing,
which
doesn't
change
the
nature,
just
change
the
form,
so
that's
also
possible
to
do
but
yeah
in
general.
It
wasn't,
I
think.
Oh
sorry,
it
wasn't
discussed
in
a
full
scope
on
the
call,
in
a
sense
that
now
benchmarks
are
complete
benchmarks
from
some
clients
were
only
obtained
around
two
weeks
ago.
A
D
It's
definitely
at
a
point
where
it
could
go
where
it
could
be
proposed.
If
I
I
don't
know
what
the
court
apps
would
say,
so
I
don't
want
to
speak
for
them.
I
could
I
can
our.
I
can
see
that
this
is
something
that
people
have.
We've
already
talked
about
quite
a
bit
as
well,
even
more
than
some
other,
yet
some
other
eips
that
are
in
efi
as
far
as
yolo
the
new
version
of
yolo,
I'm
hoping
that
this
makes
it
in.
So
that's
something
that's
on
the
horizon.
D
A
Talking
about
berlin
here,
just
for
a
minute,
I
want
to
come
back
to
the
relationship
that
this
proposal
includes
alex.
Is
it
okay
to
say
that
for
this
eap,
2046
to
be
getting
into
berlin,
eip2666
that
we
are
talking
today
is
going
to
support
a
few
operation
of
2046
and
for
2
666
the
to
measure
the
implicit
compensation
3246?
A
B
B
It's
it's
not
new
code,
which
has
to
introduce
it's
just
a
few
formulas
which
has
to
be
adjusted
and
new
efficient
and
repricing
of
pre-compiles
has
happened
in
the
in
the
past.
So
this
mechanism
is
already
supported
by
assuming
clients,
but
modex
is
completely
independent.
It
can
be
accepted
either
before
on
or
after
2046.
There
is
no
dependency
there.
A
Okay,
I
got
it
so
wow,
so
much
of
work.
So
much
of
work
that
comes
along
with
a
proposal.
I
think
it's
important
for
the
community
to
understand
running
the
ethereum
chain
is
locating
developers,
are
highly
committed
and
put
a
lot
of
work
into
every
proposal,
those
who
are
new
viewers
and
subscribers
and
have
not
watched
our
earlier
episode
on
eip2537
in
five
slides
with
alex
blassoff.
A
All
the
links
from
today's
episode,
including
the
eip
discussion
forum,
like
fellowship
of
a
theater
magician
where
active
discussion
happens
for
this
particular
proposal.
Eip266
and
the
presentation
with
the
guest
contacts
will
be
added
in
the
description
below
implementation,
related
links
for
reference
material
with
raw
data
input
and
benchmarking
and
pre-compiled
testing
are
available
in
the
proposal
itself.
A
That's
all
about
this
particular
proposal.
Well,
thank
you.
Alex
for
joining,
and
everyone
for
tuning
in
today
make
sure
to
subscribe.
The
ethereum
cat
holders
youtube
channel
and
if
you
have
any
questions
suggestion
on
which
proposal
you
would
like
to
hear
more,
please
leave
a
comment
below
and
we
will
reach
out
to
the
author
to
see
you
all
with
another
proposal.
It
be
penny
till
then
stay
safe.
Thank
you.
Everyone.