►
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 IPFS and more.
https://archive.devcon.org/archive/watch/6/fuel-scaling-ethereum-with-the-fastest-modular-execution-layer/index
Fuel is the fastest modular execution layer. It brings UTXO-based parallel transaction execution, a more flexible transaction format, a more efficient virtual machine, and a superior vertically-integrated developer stack to Ethereum.
From the creator of optimistic rollups, this exclusive talk will discuss how users and developers will be able to leverage Fuel for global scale, without having to sacrifice decentralization or the security of Ethereum.
Speaker(s): John Adler
Skill level: Intermediate
Track: Layer 2s
Keywords: Fuel,Modular Execution Layer,Rollup
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
I
also
can't
see
the
slide
so
I'm
gonna,
like
also
attack
us
on
the
trailer
okay,
so
I'm
going
to
talk
a
bit
about
how
we
got
to
where
we
are
today
with
you
all.
By
going
through
at
least
timeline
of
events
in
June
2019
I
introduced
the
optimistic
raw
design
Paradigm
under
the
title
of
minimal,
viable
emerging
census,
and
this
kind
of
kicked
off
the
whole
idea
that
you
can
have
some
sort
of
scalable
execution
system
anchored
into
ethereum
for
security.
A
Since
then,
up
until
January
2022,
we
were
essentially
heads
down
building
out
fuel
V2,
which
was
an
evolution
of
the
protocol
from
a
payments
only
platform
to
a
general
purpose:
smart
contract
execution
platform.
So
we
published
our
code
and
GitHub.
Since
then
the
code
has
been
developed.
It
has
been
open
source
and
entirely
developed,
planned
and
Etc
all
in
public,
not
a
lot
of
projects.
I
should
do
this
entirely
in
public.
We
ask
you
to
all
our
development
in
public.
A
Then
June
of
2022
we
launched
a
sway
swamp
demo
sway
swap,
is
a
part
of
Junior
soft
V1
to
sway,
which
is
the
high-level
language
that
I
imagine.
Most
of
you
are
here,
excited
about
and
a
lot
of
the
private
tests
now
and
then
in
September
of
2022.
So
just
a
short
month
ago,
we
we
released
the
beta
one
public
testing
of
the
fuel
protocol.
This
is
actually
completely
permissionless.
A
Let's
talk
about
the
three
pillars
of
fuel
and
what
makes
the
protocol
so
great
to
use
and
to
build
with
Etc.
So
we
have
three
fundamental
pillars.
One
of
them
is
performance
performance
through
parallel
transaction
execution.
The
second
one
is
flexibility
and
waste
reduction
through
the
fuel
virtual
machine
and
the
last
is
a
superior
intact
unmatched
development
experience
through
Sway
and
fork
and
I'm
going
to
be
expanding
unusual,
these
colors
in
the
coming
slides.
A
One
performance
through
parallel
transaction
attribution:
this
one
is
actually
going
to
be
the
shortest
of
the
three
floors
of
Calvert,
because
it's
actually
fairly
straightforward
to
explain,
which
is
that
you
can
see
from
the
start
here
the
well.
The
number
of
transistors
on
CPUs
has
been
increasing
exponentially
over
the
years.
You
know
this
is
Moore's
law.
These
single
threaded
performance
in
the
last
you
know,
10
plus
years,
hasn't
increased
exponentially.
It's
kind
of
stalled.
It's
basically
leveled
off
what
has
increased
exponentially,
however,
over
the
years
has
been
the
number
of
cores
right.
A
So
if
you
have
a
system
that
is
sequential
that
can
only
leverage
a
single
core.
It's
like
you're
running
it
on
a
10
year
old
computer
right.
It's
not
it's
not
exactly
a
very
good
place
to
be
when
you're
trying
to
build
a
Global,
Financial
access,
Etc
system
right.
You
really
want
to
leverage
the
same
that
is
increasing
exponentially
year
over
year,
and
that
is
this
parallel
execution.
A
Multi-Core
multiple
cores,
multiple
threads
running
in
parallel,
the
fuel
virtual
machine
is
designed
and
the
fuel
protocol
is
designed
to
be
able
to
run
transactions
in
parallel
as
opposed
to
evm,
which
unfortunately,
can
only
run
transactions
sequentially.
This
will
lead
to
a
vast
increase
in
throughput,
all
of
us
being
equal,
not
because
you
need
a
more
powerful
computer,
but
just
because
you're,
using
all
the
resources
of
your
computer,
that
in
in
the
VMware
just
kind
of
sitting
there
wasted.
A
So
that's
the
again.
That's
really
all
there
is
to
it
parallel
transaction
execution,
massive
increase
in
Drupal
now
on
to
waste
production,
an
increased
performance
on
the
single
threaded
model-
oh
I,
guess
I
didn't
collect
this
and
on
laser
function
and
improved
reference
within
a
single
thread
through
the
fuel
virtual
machine.
A
So
there's
also
some
QR
codes
here
that
you
guys
can
scan
if
you
so
wish
that
link
to
some
of
our
documentation
around
these
things,
just
in
the
slides,
will
all
be
posted
later
on.
So
if
we
don't,
if
we
don't
want
to
scan
them
right
now,
they'll
obviously
be
available.
The
fuel
VM
is
fundamentally
the
evm,
but
improved.
A
One
amazing
thing
you
can
do
in
rollups
is
experiment
with
improvements,
enhancements
Etc
and
there
have
been
many
many
erps
and
just
ideas
that
that
didn't
even
make
it
to
erps
that
have
been
proposed
over
the
years
for
ethereum,
but
that
could
never
be
implemented
because
of
a
need
for
backwards.
Compatibility,
also
limited
developer
resources.
You
know
just
worries
of
too
too
much
change
too
fast
might
be
risky
if
you
have
a
large
code
based
on
Randy
with
a
lot
of
tech
debts
all
right,
but
people
still
want
these
changes.
A
They've
been
proposed,
you
know,
if
you
take
a
roll
up-
and
you
know
you
might
say:
oh
okay,
I'm
an
evm
equivalent
roll
up
I
want
to
improve
it.
I'm
going
to
start
implementing
eips
to
improve
it
right,
I'm,
going
to
add
a
counter
traction
number
we're
going
to
add:
parallel
transaction
execution.
Etc,
that's
fuel
right.
The
fuel
of
M
is
the
evm
but
improved.
So
if
you're
looking
for
the
evm
of
five
years
from
now,
that
is
the
fuel
VM.
A
Next,
one
stateless
account
attention
some
other
projects
give
like
an
entire
talks
about
this
one
topic,
but
this
is
just
one
of
the
many
things
you
get
in
fuel,
so
it
just
gets
one
side.
Fuel
supports
account
of
traction,
but
statelessly
State,
full
account
attraction
is
actually
a
denial
service.
Vector
so
be
wary.
If
any
project
that
says
it
has
state
state
full
account,
abstraction
we
have
State
lost
account
abstraction.
What
does
it
allow
you
to
do
well,
like
any
account
abstraction
protocol?
A
It
allows
you
to
Define
conditions
under
which
a
transaction
is
valid,
not
conditions.
You
know
not
logic
of
what
the
transaction
will
do,
but
actually
conditions
under
which
the
transaction
is
valid
or
not.
You
know
the
most
obvious
case.
One
thing
you
could
do
is
use
a
different
signature
scheme.
I,
you
know,
use
snore
signatures.
If
you
want.
B
A
And
this
is
actually
what
enables
us
to
use
any
wallet
whatsoever
for
fuel
right.
Obviously,
you
know
we're
building
a
native
wallet
that
has
all
the
bells
and
whistles.
You
know
things
like
transaction
simulation.
You
know
and
a
mode
where
you
can
like
log
into
pretend
to
be
in
any
public
key
or
any
address
Etc.
But
you
know,
maybe
if
someone
doesn't
want
to
install
a
new
attention
because
they
use
Solana
right
and
they
have
assign
a
lot
or
they
use
ethereum.
They
have
metamask
right.
You
can
use
any
of
these
things.
A
Enzyme
transaction
on
fuel
because
of
a
kind
of
traction
that
allows
you
to
define
the
validity
conditions
that
are
basically
well
whatever
signed
message.
Whatever
log
you
want
will
do
it
checks
out
for
validity
and
users
are
the
ones
that
Define
the
spending
conditions,
the
validity
conditions
of
this,
not
the
protocol,
not
those
anyone
in
the
world
can
go
in
and
just
Define
some
new
condition,
and
you
know
it'll
work
with
a
new
blockchain
just
like
that.
No
protocol
change
is
required,
required
no
governance
required
just
as
a
user.
A
We
all
know
that
transferring
tokens
are
a
really
painful
thing
right,
there's
like
super
extremely
actually
for
real,
this
time,
safe
transfer
from
right
needed,
because
there's
so
many
there's
so
many
vulnerabilities
and
something
as
simple
as
just
transferring
a
token
properly
fuel
supports
multiple
multiple
assets,
multiple
assets,
natively.
So
every
token
is
a
native
asset.
So
you
have
like
a
die
as
a
native
asset.
You
could
have
used
to
see
as
a
native
asset
you
could
have
well
either.
A
Obviously
is
a
native
asset
and
this
these
native
assets
can
be
pushed
with
contract
calls,
which
means
you
don't
need
the
notion
of
token
approvals.
You
can
push
them
their
first
class
citizens
just
like
how
in
ethereum
you
can
push
ether
with
a
contract,
call
Noah
token
approvals.
So
not
only
are
you
getting
better
security
from
not
needing
you
know
some
sort
of
safe,
it's
not
transfer
from
function
transfer
from
function.
A
We
also
don't
need
token
approvals,
and
this
is
actually
a
really
big
thing
for
users,
not
developers,
because
as
users,
you
know
that
token
approvals
are
a
really
big
ux
pain.
Point
right:
it's
due
to
approve
the
exact
amount
you
want
to
spend.
If
you
do,
then
you
have
to
always
add
a
second
transaction.
Every
time
before
you
interact
with
the
protocol,
it's
more
expensive,
it's
slower!
It's
worse,
ux!
If
you
do
internet
approvals
now
the
protocol
has
a
bug.
They
can
train
all
your
tokens.
A
A
A
A
Cross
call
shared
memory
again.
This
isn't
like
all
these
things
are
either
eips
directly
or
like
variations
or
inspired
by
EVS.
If
you
guys
have
heard
of
transient
storage
right,
transient,
storage
is
storage
that
persists
across
contract
calls
within
a
single
transaction.
That's
what
this
is
right.
It's
some
piece
of
memory
that
is
accessible
across
contract
calls
the
fuel
virtual
machine.
All
contract
call
frames
share
this
Dynamic,
which
allows
you
to
do
things
like
a
completely
in-memory
re-entrancy
card.
You
don't
have
to
set
a
storage
slot
for
re-entracy
card.
A
You
can
do
an
entirely
in
memory
and
in
fact
this
is
already
implemented
in
the
sway
standard
Library.
It
was
a
function
to
do
an
in-memory
reaction
zero.
So
it's
not
just
theoretical.
It
also
allows
you
to
pass
large
data
around
with
contract
calls.
So
if
you
happen
to
do
some
data
data
computation
intensive
tasks,
you
can
do
it
just
by
passing
a
pointer
to
the
data.
A
A
You
need
a
transaction
first
to
approve,
make
a
complete
and
then
transfer
fund,
and
it
has
to
be
done
in
two
transactions,
because
an
ethereum
transaction
can
only
call
a
contract.
It
can't
call
two
contracts
or
call
two
contracts,
then
do
some
conditions
and
call
a
third
contract
or
fourth
one,
depending
on
the
same
condition.
A
A
It
could
call
one
contract
it.
We
call
two
contract
contracts,
they
could
do
an
atomic
approve
and
transfer
from
obviously
for
fundable
assets.
Like
I
said
before
those
you
know
multiple
native
assets,
so
you
don't
actually,
ironically,
you
don't
need
this
for
a
proven
transfer
from
atomically
for
Native
assets,
but
it
will
be
useful
for
things
like
if
you
have
a
non-fungible
token
that
does
have
a
proven
transfer
from
then
you
can
use.
You
can
do
that
atomically
in
a
single
transaction
thanks
to
transaction
Scripts.
A
This
also
allows
you
to
do
things,
like
you
know,
add
liquidity
to
a
pool
or
for
two
different
tokens
Etc,
so,
basically
anything
that
nowadays
you
would
need
multiple
transactions
to
do
just
due
to
the
nature
of
ethereum.
Only
processing,
a
single
contract
call
for
transaction.
You
could
do
it
in
a
single
transaction
until
we're
getting
to
the
end
of
the
section
and,
last
but
not
least,
to
reduce
waste.
The
virtual
machine
is
register
based
and
it
uses
64-bit
words.
A
A
You
can
just
add
two
numbers
together,
and
this
goes
really
fast
and
combining
these
things
together,
including
being
register
based,
means
that
you're
executing
a
lot
fewer
instructions
to
do
the
same
work
in
addition
to
just
executing
faster
and
that
reducing
the
number
of
instructions
executed
to
do
the
same
work
is
very
important,
because
gas
accounting
overhead
is
a
huge
portion
of
the
overhead
of
the
virtual
machine.
It's
like
enormous,
and
you
want
to
reduce
that
overhead
as
much
as
possible
to
squeeze
as
much
throughput
as
you
can
on
the
same
physical
Hardware.
A
A
lot
of
things
are
moved
to
the
standard
Library
one
example
that
we'll
reuse
and
subsequent
slides
is
the
EC
recover
right.
This
thing
here
will
recover
the
public
key
or
the
address.
Does
an
implementation
detail
from
a
signature
and
a
message
hash
right
in
solidity.
This
is
part
of
the
language
itself.
In
other
words,
the
compiler
developers
need
to
go
in
and
add
some
special
magic
method
into
the
compiler
embed
it
into
the
compiler
easy
recovery
right.
A
That
does
not
exist
in
swine.
This
way
you
compiler
and
the
sway
compiler
team,
don't
know
what
EC
recovery
is.
This
exists
in
the
standard
Library,
which
is
written.
The
standard
library
is
better
in
Suite,
although
it's
software
not
embedded
into
the
compiler
here's
a
QR
code,
I
think
to
link
to
the
implementation
of
easier
government.
A
Why
is
this
good?
It's
good
because
it
means
that
the
standard
Library
can
move
very
fast
because
you
don't
have
to
get
the
compiler
developers
to
do
something.
This
is
in
this
way
any.
If
any
of
you
can
write
solidity
right,
you
and
you
can
write
sway.
You
can
just
add
stuff
to
this
movement,
submit
a
PR
and
just
add
stuff
to
the
standard
Library.
You
don't
need
to
know
how
a
compiler
works
right.
You
just
might
swag,
which
is
writing
the
smart
contract
code.
A
So
it
allows
the
language
to
move
quickly
because
it's
lean
and
it
allows
the
standard
library
to
move
quickly
because
it
doesn't.
You
don't
need
to
know
how
compiler
Works
to
contribute
to
the
standard
Library
and
this
basically,
almost
every
function
that
isn't
actually
like
core
to
the
language
itself
is
in
the
standard
library
and
not
in
the
language
itself.
A
A
Generics
is
the
diagonal
brackets
right,
so
you
can
Define
the
type
of
assign
later
some
types
are,
you
know
either
one
or
the
other,
rather
kind
of,
like
unions
combine
them
together
and
you
can
get
things
like
a
result,
for
instance,
which
we'll
talk
about
on
the
next
slide.
But
generics
are
very
good
because
they
they
allow
you
to
reuse
code,
to
reuse
logic
without
having
to
duplicate
code
right.
There's
a
safe,
math
library,
right
versatility,
but.
B
A
A
Now,
why
do
we
care
about
results
specifically?
And
why
is
this
important
we're
going
to
go
back
to
our
example
of
easy
recover
on
ethereum
and
solidity?
The
easier
recover
function
will
return
something
special.
If
there's
an
error,
can
someone
yell
out
what
that
something?
Special
is
okay,
someone
someone
says
zero,
perfect
right.
So
if
the
signature
is
invalid,
then
easy
recover
will
return
a
magic
value
of
zero.
You
know
those
address
zero.
Has,
you
know
signed
over
this
message,
hash
with
a
signature.
A
Obviously,
that's
not
true,
because
you
know
if
you're
new
with
it.
If
you
knew
the
private
keys
of
the
address
zero,
the
things
would
be
very
bad,
but
the
easy
recover
doesn't
tell
you
anything
explicitly
right.
There's
this
magic
value
and
if
you
don't
remember
to
check
this,
then
someone
can
pretend
they're
from
address
zero
right
and
maybe
like
do
a
bunch
of
nasty
stuff
and
in
fact,
just
a
few
months
ago
a
contract
forgot
to
do
this
and
I
think
about
exploited,
or
maybe
it
wasn't
exploited.
A
At
least
it
was
still
there
as
a
bug
in
code
with
results,
you
can
actually
wrap
the
return
of
things
so
easy
to
recover
in
sway
which
again
the
standard
Library
function
does
not
return
a
value.
It
returns
a
result
over
a
value
and
an
error
right.
So
if
the
if
the
signature
is
invalid,
is
not
going
to
return
zero,
it's
going
to
return
an
error,
and
if
you
want
to
actually
get
into
the
value
you
have
to
unwrap
the
result,
and
you
have
to
do
this.
A
A
In
some
types
allows
us
to
have
results
along
with
all
the
things,
and
this
allows
for
explicit
error
handling,
which
means
safer
code,
because
the
compiler
tells
you
you
don't
have
to
go
and
remember
yourself,
okay,
next
one
type
in
front,
we
probably
all
hate
writing
types
of
things,
especially
when
those
types
are
long,
especially
relevant.
When
you
have
generics,
there's
a
left
keyword.
A
Now
an
alternative
would
have
been
a
VAR
I
guess,
but
you
know,
there's
been
some
bike
shedding
I
think
on
Twitter
I
saw
a
fairly
recently
on
the
slack
keyword,
so
this
one
has
a
left
keyword
and
this
allows
you
to
have
type
in
fronts
right.
We
use
the
same
type
system
as
rust,
so
you
can
just
you
know,
whatever's
on
the
right.
It
can
be
inferred.
You
have
to
actually
write
out
very
few
types
and
if
you
look
at
our
standard,
Library
I
think
sniper
inference
is
used
quite
a
bit
throughout
it.
A
And
onto
okay,
next
one
is
namespace
storage
access
in
solidity,
storage,
variables
and
regular
variables
are
all
in
the
same
namespace,
and
if
you
have
a
storage
variable
Foo
and
the
local
variable
Foo
and
you
go
like
you
know,
Foo
dot,
whatever
you
know,
which
one
are
you
accessing
right?
Likewise,
what
happens?
If
you
have
two
variables
that
are
close
in
name
right,
you
have
like
you
know,
count
and
CMT.
A
Let's
say
right:
you
can
use
the
wrong
one
by
accident
right
you
intended
to
increment
something
in
storage,
but
you
incremented
it
only
locally
or
vice
versa
and
sway.
Storage
accesses
are
namespaced
with
a
storage
dot
keyword,
which
means,
if
you
want
to
access
a
storage
variable,
you
specifically
have
to
write
out
storage
dot.
This
means
you
can
just
look
at
the
code.
Typos
are
not,
and
you
can
see
what
parts
of
the
code
are
actually
touching:
storage
versus,
not
right,
so
additional
explosiveness
and
it
means
additional
safety.
A
This
one
was
implemented
quite
quickly
by
one
information,
compiler
Engineers
Emily,
for
those
of
you
who
aren't
familiar
with
pattern,
matching
it's
a
match
statement
right
and
it
allows
you
to
exhaustively
enumerate
all
the
possible
cases.
So,
let's
say
you're
matching
in
a
Boolean.
The
exhaustive
cases
are
true
and
false
right
and
if
you
only
matched
on
true
the
compiler
would
tell
you
hey.
You
haven't
matched
exhaustively.
A
This
means
that,
unlike
in
solidity
where
you
have
to
do
an
if
else
chain
and
hey,
if
you
forget
to
check
a
case
and
you're
in
the
in
your
state
machine
right
for
your
contract,
if
you
forget
to
check
your
case
well
too
bad
so
sad,
the
compiler
tells
you
nothing
right
with
exhaustive
magic
Expressions.
Well,
not
only
is
it
cleaner
because
it's
all
like
in
a
single
thing,
instead
of
a.
A
Next,
one
is
zero
cost
obstructions.
This
is
kind
of
a
first
class
notion
in
this
way,
language
and
this
way,
combin
binder
that
this
little
pilot
doesn't
really
do
one
example
of
a
zero
cost
attraction.
There's
zero
cost
things
in
general.
It
means
moving
stuff
from
runtime
to
compile
time
wherever
possible.
That's
what
the
ethos
is
really
about.
One
example
is
well
what
happens
if
you
could
check
method
payability
at
compile
time
instead
of
at
runtime
right
it's
a
solidity.
Compiler
will
actually
inject
some
runtime
code
into
every
method.
That
is
non-payable
right.
A
Okay
and
another-
that's
not
least,
I-
think
I'll
Zoom
through
since
I
have
one
minute
left
is
reagency.
Reentions
exploits
are
still
happening
to
this
day,
six
plus
years
later
after
the
dial
tooling
should
pick
this
up,
but
it
doesn't
that's
why
compiler
will
warn
you
if
your
contract
has
some
potential
reaction
to
Golden
vulnerability,
because
it
violates
the
check
effects,
interaction,
pattern
or
other
patterns.
A
This
way
to
Milo
will
actually
warn
you
so
goodbye
other
days
of
re-entracy
vulnerabilities,
because
we
now
have
two
of
them
that
can
warn
us
about
that,
all
right
and
last
but
not
least
on
the
language
side,
but
on
the
tooling
side
we
have
Fork
the
fuel
orchestrator,
which
is
the
equivalent
of
Foundry
or
cargo
npm.
This
allows
you
to
do
a
variety
of
things,
including
building
deploying
managing
dependencies.
A
Thank
you
so
much
okay,
it
allows
you
to
build,
apply,
manage
dependencies
in
the
same
way,
cargo
does
so
no
weird
git
modules.
This
is
an
Australian
formatter
test,
a
language
server.
We
actually
had
a
language
server
before
so,
if
you
want
to
there's
a
QR
code
to
link
to
the
sway
book,
if
you
want
to
learn
how
to
write
Sway
and
dive
in
a
head
first,
this
will
take
you
straight
there.