►
From YouTube: EVM-first EIPs Workshop | Devcon Bogotá
Description
Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on Swarm, IPFS and more.
https://archive.devcon.org/archive/watch/6/evm-first-eips-workshop/
This is a workshop discussion about the EVM. Anyone can come up and pitch their favourite EVM-first EIPs.
We want to be a bit more unconventional and would like to transform the room into a "live voting space" where attendees can fight for their favourite new EVM feature.
Different proposals will be listed and discussed for 3-5 minutes each, where invited panelists give a short opinion followed by loud interaction from the audience.
Speaker(s): Alex Beregszaszi, Paweł Bylica
Track: Developer Infrastructure
Keywords: evm
Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/
Devcon is the Ethereum conference for developers, researchers, thinkers, and makers.
Devcon 6 was held in Bogotá, Colombia on Oct 11 - 14, 2022.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/
A
A
It's
apparently
very
early
for
some
people,
but
we
kind
of
imagined
it
to
be
a
con
continuation
of
the
Ethereal
magician
session.
We
had
I
think
on
the
first
day,
but
the
focus
for
for
today
would
be
eaps
related
to
evm,
so
yeah
this.
This
possibility
to
take
a
mic
and
and
describe
or
pitch
for
AIP.
You
are
interested
in
and
we
can
discuss
and
maybe
ask
questions
from
the
audience.
A
So
if
anyone
wants
to
start,
if
not
I
can
take
like
five
minutes
10
minutes
to
to
to
talk
about
eof
the
like
three
five
EIP
proposals
we
have
drafted
so
far.
So
this
is
a.
This
is
a
slide
for
my
lightning
talk
about
eof,
but
mostly
what
I
wanted
to
to
have
on
the
screen
is
the
five
five
VIPs
we
have.
Two
first
are
the
first
potentially
scheduled
for
for
Shanghai,
which
means
the
next
execution
layer
upgrade
at
a
defined.
A
The
kind
of
the
basic
of
the
UF
structure
so
eof
stands
for
evm
object,
format
and
this
and
is
a
a
kind
of
on
our
idea
to
structure
the
the
evm
programs
in
the
way
that
the
kind
of
behave
more
predictable
way
so
that
we
know
where
the
data
is
in
the
program.
We
know
the
code
is,
and
we
conversion
programs,
so
that
also
gives
us
some
additional
backwards
compatibility
features,
and
on
top
of
that,
we
can
build
additional
features,
and
these
three
additional
features
are
the
the
next
three
IPS
on
the
list.
A
So,
firstly,
eof
allows
us
to
to
Define
instructions
and
in
a
bit
different
way,
so
we
can
have
some
immediate
values
means
the
op
code
can
be
followed
by
additional
numbers.
That
means
something
to
the
instruction
that
will
interpret
it.
That
will
interpret
the
the
values
following
that
wasn't
possible
before
because
of
the
backwards
compatibility
of
existing
evm.
So
you
can,
in
the
current
VM,
you
can
craft
a
program
that
that
will
break
if
you
interpret
into
values
following
up
codes
in
a
different
way.
A
A
So
this
there
are
some
tricks
you
can
do
in
current
VM.
That
would
not
be
possible
anymore,
but
I
think
most
of
the
compilers
that
Target
CVM
doesn't
really
exploit
this.
This
exploit
this
properties,
so
that
also
brings
some
additional
efficiencies,
because
you
can
kind
of
check
for
correctness
in
at
least
in
the
terms
of
Stack
Behavior
during
deploy
time-
and
you
don't
have
to
repeat
these
checks
right
later
during
execution.
A
B
B
A
Okay,
so
so
the
the
first
two
kind
of
the
basics
of
eof
will
be
introduced
with
version
one
and
and
reminding
like
three
additionals
will
require
the
the
version
bump,
and
this
is
kind
of
the
question.
How
many
features
we
want
to
pack
and
into
a
single
version
so
like
has
originally
we
we
kind
of
wanted
to
split
that
and
that's
what
also
reason
we
have
like
five
eaps,
not
like
single
one,
because
people
freak
out
if
the
EP
is
big
enough.
A
C
A
A
Do
you
yeah?
What
do
you
do,
what
you
define
as
a
version
I
mean
like
multiple
versions
bring
some
like
like
new
kind
of
complexity
to
the
system.
We
don't
have
so
far
right
so
currently
when
we
change
something
to
evm.
It's
mostly
time
based
like
to
like
to
some
point.
Evm
works
this
way
and
from
some
point
it
it
works
differently.
A
So
I
think
all
the
codes
still
like
have
all
of
the
versions,
historic
versions
and
because
people
care
about
executing
every
instruction
from
the
beginning.
But
you
can
imagine
you
can
design
a
client
that
only
kind
of
has
like
the
recent
two
or
something
like
that.
So
you
can
kind
of
scrap
the
code
that
is
and
like
do
the
the
full
sync
which
means
doesn't
execute
the
the
transactions
just
collects
the
state
and
goes
on
from
that.
A
I
think
nobody
did
so
far
this
way,
but
it's
possible
and
like
this
qof
itself,
will
like
introduce
kind
of
the
new
evm
that
will
run
next
to
the
the
Legacy
one
and
they
will
be
able
to
communicate
within
the
single
transaction
right.
So
you
can
have
like
Legacy
contract
that
calls
the
new
one
and
the
new
one
called
the
old
one
and
like
nothing
breaks
on
this
level.
But
it
will
have
kind
of
two
parallel
events
and.
B
Yeah
just
to
follow
up
so
like
of
the
say,
like
the
the
last
three:
are
there
any
say
we
were
to
split
that
in
like
two
in
one
or
like
three
hard
Forks
like?
Are
there
any
that
don't
require
a
version
bump
or
do
they
each
as
long
as
they're,
not
shipped
together?
All
the
time
required
version,
bumped.
A
I
think
that
the
static
relative
jump
doesn't
require
version
bump
at
all,
so
like
kind
of
the
forward
forward.
What
is
that
forward
backward?
No,
the
forward
compatibility
of
eof
is
that
you
can
always
drop
new
instruction
into
it
without
version
bomb.
So
whatever
you
add
to
the
instruction
can
be
like.
D
What
about
the
backwards
compatibility
of
packing
in
new
optional
eof
format,
sections
like
if
eof
functions
were
separate
from
the
code
section
and
provided
data
on
top
of
it
same
with
the
stack
validation
information
it
was,
it
had
a
separate
section
number
that
would
go
on
top
of
it.
I
mean:
could
those
be
done
in
a
forward
compatible
way
with
it
doesn't
break
things.
A
Yeah
yeah,
but
you
can
kind
of
so.
The
thing
is
you
can
like
when
you
have
something
commandatory,
you
can
make
it
optional
later
right,
so
because
kind
of
the
the
previous
deployed
contacts
will
all
will
have
this
thing
there.
But
if
it's
optional,
it's
still
fine.
So
maybe
there's
a
way
to
have
like
single
code
section
with
the
information
that
maybe
later
will
enable
like
more
call
sections
so
like
single
code.
Section
contracts
from
before
will
still
work,
we'll
just
have
single
function
there.
A
A
2.1
I'm,
not
sure
I
mean
it's
like
still
like
system,
like
all
the
all
the
contracts
have
to
like
do
exactly
like
the
same
things
and
like
this
not
really
like
optional,
think
you
can
perform
in
the
sense
that
all
the
clients
have
to
behave
the
same
way
so
I'm
not
sure
like
they're,
actually
that
having
like
minor
version
will
make
any
change,
make
any
difference,
so
either
it
behaves
differently
or
not.
So
if
it's
like
two
versions,
numbers
I,
don't
think
that
makes
any
difference.
Okay,.
A
E
A
No,
that's
actually
the
one.
The
last
one
actually
requires
the
version
bump
because
it
puts
additional
restriction
rules
on
the
code.
That
means
we
want
to
make
sure
that
when
you
load
the
the
evm
program
from
database-
and
you
see
the
version
number,
you
know
exactly
what
you
can
expect
from
the
code.
So
if
you
like,
if,
if
some
rules
are
not
there
at
the
deploy
time,
it
means
that
the
program
you
load
from
that
era
will
like
have
different,
will
have
different
structure
and
you
can't
rely
on
it
anymore.
Yeah.
F
F
F
G
A
A
I
think
this
is
what
this
kind
of
analogous
to
arm
and
all
of
that,
so
the
it's
just
to
like
make
sure
like
people,
don't
use
like
kind
of
exotic
way
of
like
M
size,
of
that
to
put
zero
on
the
stack.
So
we
just
will
delegate
one
instruction
to
do
exactly
this
with
the
same
gas
cost
of
the
kind
of
the
hacks
we
currently
have,
and
that's
also
scheduled
for
Shanghai.
If
you
remember
right,
can
I
want
to
confirm
that?
A
A
It
will
never
be
deployed
on
the
minute,
but
the
thing
is
like
it
has
kind
of
different
structures,
so
we
kind
of
design
the
evm
loop
interpret
a
little
differently,
but
the
instructions
they
operate
on
a
kind
of
share
between
Legacy
and
the
new
one
and
I
think
that's
the
current
current
direction.
We're
going
with
nobody
proposed
like
radical
changes.
I
think
like
radical
change,
would
be
just
to
take
some
other
VM.
Like
I.
A
Don't
know
we
try
to
develop
assembly,
maybe
the
fuel
VM
and
I'd
put
it
somewhere
on
L2
or
whatever,
whatever
I
don't
expect
to
see
so
drastic
changes
to
evm,
it's
kind
of
the
same,
it's
kind
of
the
same
of
as
the
question
like.
Why
do
we
have
256
bit
size
words
right
and
we
I
probably
there's
also
not
like
a
notary
option
to
shorten
it
to
something
smaller
all
right.
One
more
question.
H
A
A
So
they'll
do
some
technical
issues
like
one
is
about
having
this
immediate
values
in
the
instructions
which
are
not
like
fully
backwards
compatible,
and
secondly,
it
kind
of
doesn't
really
help
with
this
analysis.
So
this
was
one
one
because
for
the
simplicity,
the
jumps
will
still
work
the
same
and
they
can
cross
the
subroutines
easily.
A
H
C
A
A
Oh,
this
one
I
have
no
idea
honestly.
Maybe
someone
can
help?
Okay,
no
you're,
not
helping
no
I
text.
I,
don't
know
really
so
I
think
like
on
the
technical
level,
probably
not
so
many
I
think
it's
mostly
like
social
level,
which
is
problematic
or
like
this
like
some
way.
You
can
trick
people
to
do
something
and
there
is
no
way
back
or
but
I
I
am
not
an
expert
on
this
one.
Actually,
so
I
don't
think
I
can
answer
this.
You.
G
A
I
mean
that
that's
that's
a
good
question
so,
like
we
didn't
put
anything
like
any
kind
of
draft,
but
we
we
have
some
thought
about
that,
and
there
was
some
some
input
from
vitalik
as
well
recently
about
how
to
kind
of
model
that
I
think
this,
like
multiple
Dimensions,
you
can
try
to
kind
of
describe
it
like
Juanes.
That
current
memory
allows
you
to
just
just
use
whatever
index
you
want.
A
You
will
just
pay
more
gas
for
it
and
that
looks
kind
of
calculated
and
so
kind
of
the
memory
automatically
expands
to
the
to
the
use
and
there's
a
kind
of
different
way
of
doing
that.
So
you
kind
of
have
to
explicitly
inform
the
VM
up
front
like
okay,
please
allocate
moment
more
memory
for
me
and
and
if
you
use
something
that
is
outside
of
the
allocation,
it
will
just
terminate
execution
right
and
the
second
one
is.
This
is
the
model
that
webassembly
uses
right.
A
F
A
F
G
A
Oh
Asic,
okay,
okay
wow,
so
we
had
a
pro.
We
had
a
project
called
evm
jet,
which
just
was
compiling
evm
byte
code
into
let's
say
x86
like
native
code,
and
the
performance
was
great,
but
the
cost
of
compiling
that
was
also
big.
So
that's
kind
of
the
trade-off
and
at
some
point
we
just
scrub
it
it's
somewhere
around,
but
I
think
it's
a
difficult
time
to
decide
like
which
contract
you
want
to
compile
to
native
code.
If
you
don't
have
to.
C
A
A
The
code
yeah,
what
I
wanted
to
do?
Okay,
yeah
I
kind
of
wanted
to
put
it
in
perspective
in
the
sense
like
that
seems
at
least
to
my
opinion.
That
seems
like
more
advanced
because
I
don't
know
about
this
stuff
at
all
that,
like
doing
even
jet
compilation,
which
is
already
hard,
it's
like
compilation
is
not
hard,
but
it's
like
time
consuming.
A
So
you
have
to
just
squeeze
this
if
you,
if
you
have
Hardware
yeah
like
even
if
you
had
a
hardware
like
that,
the
gas
costs
nowhere
reflects
like
the
performance
of
it
right
so
I'm
sure
how
much
you
will
say.
You'll
save
like
you
you're,
like
machine
computational
time,
but
it
would
not
I
think
it
would
not
improve
the
network
unless
this,
like,
like
most
of
the
people,
use
it.
But
I,
don't
know
if
anyone
tried
that
I'll
be
definitely
interested
project
to
see
how
it
works.
G
Greg
Colvin
has
infamously
said
that
the
AVM
is
a
gas
counting
machine
that
does
computation
as
a
side
effect.
Do
you
think
there
could
be
any
benefits
to
reducing
the
Precision
or
the
Fidelity
in
terms
of
like
how
gradual
you're
doing
your
gas,
accounting
and
so
like
paying
for
more
gas
things
up
front
or
even
say,
like
the
memory
case,
would
be
one
case
where
you
pay
for
expansion
or
the
escalation
like
the
curve
that
it
follows,
isn't
actually
like
a
smooth
perfectly
smooth
curve.
G
A
I
think
depends
a
bit
like
what
kind
of
instruction
substance
you
mean
I.
Think
for
memory.
We
should
like
take
a
look
like
yeah
how
to
improve
gas
gas
housekeeping
for
these,
for,
like,
like
purely
computational
ones,
I
think
it's
not
so
big
deal
right
now,
so
the
one
thing
is
that
the
instructions
actually
do
quite
a
lot
because
they
are
like
two
56-bit
precision.
A
A
So
you
kind
of
can
hide
the
latency
of
gas
computation
there.
So
kind
of
the
CPU
is
doing
the
the
computation
itself
and
also
calculates
gas.
So
the
overhead
of
disabled
gas
calculation,
it's
not
I,
mean
if
you
have
really
efficient,
evm
implementation,
it's
it
can
be
like
seven
percent,
maybe
ten
percent.
So
this
is
not
like
huge
amount
and
the
same
for
the
stack
checks
and
all
of
that,
but
yeah.
So
I
I,
don't
know
what
like
for
evm
I
would
keep
it
as
this
I
think
it's
not
so
bad.
A
Definitely,
the
simple,
simple
gas
tools
will
have,
but
I
wouldn't
change
like
to
be
some
kind
of
different,
Precision
or
whatever,
but
we
also
don't
want
like
complicated
gas
rules
that
doesn't
blink
anything.
So
the
the
memory
is
unfortunately
like
another.
This,
like
example,
one
once
more,
which
means
you
just
compute
this,
like
32-bit
chunks
of
memory
which,
like
you,
need
to
do
some
additional
computation
to
to
calculate
the
gas
cost.
If
that
was
would
be
per
byte,
it
would
be
simpler
and
the
effect
would
be
the
same
right.
A
F
For
most
most
basic
blocks,
you
can
calculate
the
gas
costs
up
front
and
just
just
calculate
the
whole
basic
block,
and
obviously
things
like
a
store
and
so
on
the
variable.
But
but
for
you
know
for
many
many
basic
blocks
you
can
you
can,
as
this
can
I
probably
tell
you
you
can
you
can
pre-compute
it.
A
Yeah,
you
can
do
that,
like
with
one
like
like
comment
that
it's
like
for
the
basic
gas
ghost.
Some
instruction
has
like
basic
cost
and
then
like,
like
variabic
variatic
gas
costs.
Depending
on
the
arguments
and
something
like
that
yeah
we
did
try
that,
like
even
the
VM
implementation
and
it
it
brings
I
think
some
performance
but
I
think
we
kind
of
scrapped
the
idea,
because.
F
A
You
need
like
additional
analysis
phase
to
like
should
pre-calculate
that,
and
you
have
to,
and
so
a
quick
quick
like
description,
how
it
was
done
in
evmo,
and
there
was
like
the
old
interpreter
that
was
doing
this
and
the
analysis
cost
was
really
big
and
we
kind
of
transitioned
to
like
simple
design
but
efficient
design
of
evm,
which
doesn't
do
that
anymore
and
the
new
one
is
actually
faster
than
old
one.
But
to
be
fair,
the
old
one
didn't
get
so
much
attention
recently.
So
maybe
there's
some
like
performance.
F
G
1153
Otherwise
Known,
t-store
T
load,
one
by
let's
see
years
ago.
Do
you
have
any
thoughts
on
that
and
it's
specifically
to
the
memory
problem?
Would
that
reduce
some
of
these
pressures
on
reforming
memory?
Because
you
know
you've
got
this
transient
storage,
it's
not
hitting
disk,
it's
pretty
cheap.
How
do
you
feel
about
1153.
A
So
I'm
not
sure,
if
I'm
on
the
same
page
with
this
one,
but
does
it
like
have
the
same
kind
of
like
map
map
structure
that
this
storage
has
right.
So
yeah
like
for
me,
the
the
issue
is
that
you
have
this
like
map
structure
there.
So
it's
like
it's
like
this
is
like
chunk
of
memory.
You
actually
have
like
hash
map
or
like
whatever
the
implementation
is
because,
as
I
remember,
it
was
like
doing
the
same.
You
have
like
unlimited
number
of
256
bit
slots
you
can
assign
to
so.
A
A
So
it
kind
of
mostly
focus
on
that
like
single
call,
so
that
this
Transit
storage,
it's
it's
like
problematic
in
the
way
that
I
have
to
kind
of
Outsource
it
somewhere
else
so
like
the
client
of
like
client,
has
to
provide
some
way,
some
API
to
actually
access
it,
because,
like
for
for
my
VM
at
least
it's
that
I
just
start
the
AVM
context
on
the
when
you
enter
the
call
and
I
end
it
there.
So
I
don't
have
anything
that
lasts
above
that
so
but
yeah
I'm
kind
of
transitioning.
A
A
I
A
Like
from
my
perspective,
it's
not
any
different
to
access
a
store
because
I
kind
of
have
a
buffer
of
like
this
cache
of
this
s
store
and
I'd
like
for,
like
Yeah
from
like
the
like
the
Corey
VM
site,
it's
not
much
different,
but
I
think
it's
like.
So
the
difference
is
when
you
have
to
actually
go
to
the
database
on
disk
or
not
and
like.
A
A
A
A
A
All
of
this
like
fixed
point
or
automatic,
it's
really
hard,
if
you
so,
if
you
need
to
emulate
like
bigger
numbers
in
the
smaller
like
this,
like
more
like
smaller,
like
64-bit
word
size,
it's
just
it's
really
horrible,
and
when,
when
you
have
like
simple
design
like
interpreter
and
stuff,
so
you
need
like
to
drop
a
lot
of
instructions
to
emulate
that,
and
it
was
really
bad
on
some
workloads,
so
I
I.
We
can't
confirm
it's
like
the
based
the
the
best
word
size,
but
for
some
use
case
it
really
helps.