►
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/ethers-whats-new-in-v6/
Just a quick overview of some of the new APIs and features of Ethers introduced in v6, including Typed-Values, more-flexible Contract interaction and Layer 2 enhancements.
Speaker(s): Richard Moore
Skill level: Beginner
Track: Developer Infrastructure
Keywords: ethers,javascript,dapp
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
So
what
is
ethers?
It
aims
to
be
a
complete
compact
and
friendly
ethereum
library
that
developers
can
use,
but
also
part
of
user
friendliness.
Is
safety
like
you,
don't
let
user
don't
let
the
developer
do
things
that
like
bites
in
the
ass,
without
realizing
it.
So
one
of
the
cool
things
is
the
default
provider.
I,
don't
know
where
I
should
stand
so
with
the
default
provider
will
haul.
Basically
it
lets
you
just
connect
to
ethereum.
A
Historically,
you
had
to
either
run
a
node
or
you
have
to
like
sign
up
for
inferior.
You
have
to
do
something
to
start
using
ether
ethereum
right
away,
so
we've
got
like
a
bunch
of
relationships
with
these
third
party
providers
and
right
off
the
bat
you
can
just
connect
to
ethereum
start
doing
Simple
Things,
it's
heavily
throttled,
but
you
can
at
least
do
something
before
deciding
whether
you
want
to
like
get
your
own
inferior
ID,
and
all
that
this
is
all
the
old
stuff.
So
I'll
just
go
over
quickly.
It's
written
in
typescript.
A
Now
very
few
dependencies,
26
000
in
growing
test
cases,
ens
is
a
first-class
citizen.
Everything
including
all
dependencies,
are
MIT
licensed
and
there's
extensive
documentation
and
in
V6
the
documentation
is
getting
much
better
and
an
important
thing
is
to
understand,
like
I
made
ethers
because
something
I
needed
and
something
that
I
use
a
lot,
and
so
I
mean
it's
in
my
best
interest
to
keep
it
getting
better
over
time
and
that
sort
of
thing
I,
think
dog
fooding,
is
very
important
to
keeping
a
library
good.
A
A
Modern,
so
getting
into
the
new
things
than
V6.
That's
coming
out,
there's
currently
a
V6
available
both
on
npm
and
GitHub.
It's
still
very
beta,
but
it's
there
to
try
out.
So
one
of
the
biggest
features
is
modern
es
features
currently
V5
it
targets
ES3.
So
if
you
are
trying
to
run
ethers
in
IE,
3
from
2002,
it'll
probably
still
work
mostly,
but
that's
no
longer
a
priority,
and
so
the
goal
is
to
start
adding
kind
of
like
new
age.
A
Javascript
things
heavily
reduces
the
code
size
because,
rather
than
having
this
big
class
for
big
numbers,
you
can
actually
just
use
the
built-in
big
numbers
that
JavaScript
now
provides
you
so
I
mean
you
can
now
use
like
the
equals
equals
equal
sign,
which
is
super
exciting.
If
you
want
to
use
a
big
number,
you
just
put
an
n
on
the
end
and
that
tells
JavaScript.
A
This
number
should
be
treated
as
a
big
literal,
don't
go
doing
IEEE
or
yeah
IEEE
754
truncation
to
it
and
and
that
sort
of
thing
I'm
trying
going
to
try
to
go
through
this
faster
ish.
If
I'm
talking
too
fast,
let
me
know,
but
basically
it'd
be
nice
to
get
to
the
end.
So
people
who
have
questions
can
ask
questions.
A
So
another
really
cool
feature
that
modern
JS
offers
is
proxies.
For
those
that
don't
know
proxy
is
basically
and
are
are
an
object,
and
if
you
call
a
property
that
doesn't
exist,
code
gets
to
run
first
and
decide
whether
or
not
it
should.
Let
you
think
something
exists
and
continue.
So
this
heavily
improves
how
the
contract
object.
Works.
Historically,
you
had
like
a
ABI
with
multiple
different
signatures
for
for
different
methods.
It
really
required
you
to
understand
all
the
rules
for
how
formatting
Works
to
normalize
the
signature
in
order
to
access
it.
A
So
now
you
can
do
whatever
you
want
so
like.
Basically,
you
can
have
all
sorts
of
white
space
extra
little
letters
and
and
whatnot
in
there,
and
this
will
all
figure
it
out
at
runtime
and
map
it
back
into
that
and
get
the
right
thing
for
you,
basically
for
all
those
people,
who've
ever
had
duplicate,
ABI
definition
errors
and
have
filed
an
issue
saying
how
to
get
rid
of
them.
A
This
is
for
you,
typed
values
are
another
cool
thing,
so
going
back
to
the
same
situation
where
you
have
two
different
methods,
Foo
and
Foo,
and
they
take
in
different
things
in
V5,
there's
no
way
for
it
to
know
which
one
if
you
pass
into
parameters
an
address,
looks
very
much
like
a
number
of
160
bit
number,
but
it
looks
like
a
number
there's
no
way
for
ethers
to
actually
know
which
one
you
meant
to
call,
and
so
now
you
can
do
so
you
yeah.
So
this
would
be
an
error.
A
It
doesn't
know
what
this
is.
This
looks
like
it
could
be
a
number.
This
is
a
perfectly
valid:
u
in
256.,
so
now
you
can
force
it
and
tell
it
that
it's
a
typed
object
of
an
address,
and
then,
if
you
do,
this
it'll
automatically
know.
Oh,
this
is
the
one
you
wanted
so
again
really
cool
things
we
can
do.
This
is
sort
of
related
to
proxies
but
kind
of
its
own
thing.
A
Likewise,
if
you
have,
if
you're
doing
programmatic
things,
sometimes
you
just
have
a
bunch
of
keyworded
objects
and
so,
for
example,
you've
got
transfer
from
it's
got
an
from
a
two
and
a
value.
So
this
is
how
you
would
do
it
in
V5.
You
can
still
do
this
in
V6.
This
works
fine,
using
positional
parameters
for
those
that
are
used
to
python.
A
They
call
them
positional
versus
keywords,
but
now
you
can
also
do
types.keywords
and
pass
in
a
from
a
two
and
a
value,
and
it
knows
that
those
things
should
get
deconstructed
into
the
from
to
some
value.
This
order
doesn't
matter
either.
If
you
wanted
to
construct
this
object
from
a
bunch
of
other
lines
of
code
reading
stuff
in
you
can
just
build
an
object
up
and
add
a
two.
A
If
it's
not
null
and
out
of
this,
if
it's
not
that
and
then
it's
Off
to
the
Races
okay,
another
big
thing
is:
things
are
now
classes,
okay,
I'm
down
to
19
minutes,
so
things
have
class.
Basically,
oh
yes,
so
I'll
dive
into
this
a
bit
more
because
I
think
this
is
a
really
cool
feature
in
general
of
something
we
should
be
doing
more
in
solidity.
This
is
kind
of
steering
away
from
ethers,
specifically
into
more
solidity
generically
if
you're
using
V5
a
signature
is
literally
just
some
dumb
object.
A
It's
not
a
class,
it's
just
an
object
with
a
values,
r
s
and
V,
and
that's
all
you
get
by
making
it
a
class.
It
can
take
in
anything
whether
it's
a
like
a
raw
signature
or
whether
it's
an
RS
and
Y
parity,
r
s
and
v,
r
and
Y
parody
are
are
y
period
s.
Whatever
random
combination
of
things,
you
have
feed
it
in
it'll
figure.
A
Maybe
I
will
explain
this
quickly,
so
those
are
the
things
are
basically
done
today.
So
this
is
basically
people
that
pass
a
new
signature
for
first
solidity
for
doing
easy
recover
on
they
pass
into
bytes,
or
they
deconstruct
themselves.
So
that'll
be
the
third
slide
for
now,
but
they'll
pass
this
bytes
object
in
and
then
you've
got
this
expensive,
weird
byte
manipulation.
Library
I
mean
it's
well
written.
It's
by
open,
Zeppelin,
I,
think
but
you're
doing
a
bunch
of
string,
manipulation
on
byte
arrays,
to
figure
out
where
the
RS
and
V
sit.
A
It's
also
a
huge
amount
of
data.
Otherwise,
and
then
this
is
what
your
code
looks
like
the
cool
thing
with
these
new
things
are
classed.
You
could,
for
example,
in
your
code,
have
a
signature
that
has
an
R
an
S
and
a
v,
and
then
you
can
just
use
the
Sig
type
from
the
struct,
and
this
is
your
EC
recovery.
So
historically,
you
might
have
also
seen
a
verify
that
takes
in
a
byte32
digest
a
bytes,
32,
V,
bytes
or
sorry
bytes.
A
You
went
eight
V
byte
series
who
are
by
Sergio
s
and
go
off
the
races,
but
with
this
you
can
kind
of
pack
them
all
together.
This
is
the
same
size
for
the
ABI
point
of
view,
and
then
you
just
pass
in
the
signature
and
because
it's
a
class
when
it's
starting
to
build
out
that
encoded
piece
of
information,
it
knows
to
take
the
r
and
pack
it
together
with
the
S
impacted
out
the
v
in
a
nice
compact
format
and
then
you're
off
to
the
races.
A
So
one
important
thing
to
note
with
this:
the
next
slide
is
this
line
here.
Bloop
does
not
change,
and
so
you
see
you're
still
creating
a
signature
you're
just
passing
the
signature
in
verbatim
and
yeah.
Basically,
it's
because
the
ABI
is
encoding
it.
It
can
look
at
this
object
and
figure
out.
Okay,
I
need
to
take
the
difference
in
this
case
is
the
r
and
the
Y
parity
and
S
for
those
that
aren't
familiar
with
EIP
2098.
A
A
So
we
kind
of
just
like
slot
that
in
and
now
your
signatures
are
60,
30,
smaller
and
yeah
again
feel
free
to
ask
questions,
because
these
are
going
to
be
a
little
complicated,
but
you
need
a
little
bit
of
more
math
to
help
decouple
that
I'm
going
to
bug
the
the
facility
guys
to
see
if
we
can
kind
of
get
this
built
more
into
solidity.
So
you
just
pass
in
the
signature
directly,
but
in
the
meantime
this
is
still
much
simpler
than
the
like
couple.
A
A
So
if
you
use
decompose,
that's
96
bytes,
but
if
you
use
the
compact
representation,
it's
64,
bytes,
yeah,
I'm,
not
gonna,
go
to
more
than
that.
That
was
just
a
quick
thing
for
people
who
are
looking
at
the
slides
afterwards.
Transactions
are
also
now
an
object.
So
if
you
decouple
a
transaction,
if
you
just
feed
in
a
bunch
of
raw
like
a
raw
transaction
object
or
a
bunch
of
stuff,
if
you
start
updating
the
stuff,
it
updates
the
other
parts
of
it
as
well.
A
Yes,
basically,
when
you
have
just
an
object
and
you
set
some
property
on
it,
you're
only
opening
that
property.
But
with
this,
when
you
set
a
property,
it
sets
that
property,
but
also
updates
all
the
all
the
entangled
properties.
For
example,
if
you
set
the
gas
price,
then
the
serialized
version
of
that
transaction
should
update
and
you
can
just
set
things
you
can
set
them
to
anything.
That's
valid.
You
could
so,
in
this
case,
I'm
using
a
bigint,
but
you
could
pass
it
a
string.
A
A
A
This
way
they
haven't
been
consuming
your
your
bandwidth
every
time
that
you've
been
they've
been
doing
nothing
with
your
site.
So
you
can
pause
your
provider
and
then,
when
it
comes
when
the
tab
becomes
visibly
visible
again,
you
can
resume
and
you
get
the
choice
of
whether
you
want
to
replay
all
the
events
that
would
have
happened
during
the
time
that
was
paused
or
whether
you
kind
of
watched
you
just
drop
them
and
keep
keep
on
going.
A
Both
situations
have
like
valid
use
cases
so
up
to
your
own
personal
use
case,
the
cool
thing
with
this
feature
is
because
we
can
now
pause
and
unpause
providers
all
the
underlying
API
and
framework
changes
that
went
into
making
this
happen.
It
means
that
if
you
have,
for
example,
a
websocket
and
the
websocket
disconnects,
it
can
now
reconnect
and
re-subscribe
to
all
your
events
before
it
starts
feeding
you.
A
The
new
events
that
start
coming
in
it
can
actually
get
the
events
that
happen
from
the
time
it
disconnected
from
the
time
that
is
now,
and
so
all
your
events
come
back
in
order
and
you
don't
miss
a
beat,
and
you
don't
even
know
that
your
websocket
crashed
and
ordinance
I'll
just
go
to
these
quickly.
Basically,
networks
are
now
a
plug-in.
They
have
a
plug-in
system,
there's
a
lot
of
really
strange
networks
out
there
and
I
always
get
like
requests.
Saying
like.
A
Oh
my
network,
computes
hashes
in
this
strange
way
or
my
network
doesn't
doesn't
have
an
author
in
the
block
or
this
sort
of
thing
in
the
other.
So
this
makes
it
possible
that
ethers
can
stop
capitulating
to
each
of
these
individual
things
and
all
those
all
those
Oddities
which
are
fine,
I
mean
you
know.
Competition
ecosystem
is
good,
but
then
we
can
like
push
all
those
differences
into
the
the
network
object
and
let
it
handle
it.
A
Foreign
package
exports
I'm
moving
away
from
a
mono
repo
which
uses
a
bajillion
sub
packages
all
by
ethers
because
it
used
to
be
like
at
ether's
project,
ABI
Addie's
project
providers
and
that
sort
of
thing
package.
Exports
are
awesome,
they're
supported
by
all
major
bundlers
now,
and
it
means
that
there's
no
complicated,
weird
process
going
on
for
ether's
build
for
those
who've
used,
ether's
or
tried
modifying
ethers
at
all.
A
The
build
process
is
absolutely
insane
because
I
try
to
Target
again
ES3
and
react
and
I
try
to
build
for
everything
and,
as
a
result,
people
who
are
using
more
modern
utilities
like
people
complain
about
Vite
a
lot
or,
if
you're,
trying
to
build
a
bundle
for
node.
It
just
fails.
So
the
nice
thing
is
by
using
package
exports
instead
of
all
this
crazy
custom
scripts,
it
just
kind
of
works
with
all
these
tools
and
everyone's
happier,
I
hope,
we'll
see
that
after
I
launch
the
non-beta.
A
There's
better
and
fewer
dependencies
I'm
actually
going
to
grab
a
bit
of
water.
So
yes,
there's
basically
I
think
I'm
at
five
dependencies
ish
right
now,
but
down
to
four
authors,
which
is
an
important
thing.
I
feel
like
we've
all
seen.
We've
all
like
recently
been
pretty
worried
about
like
supply
chain
attacks,
going
on
from
mpm
installing
a
bajillion
things,
and
so
right
now,
there's
four
well-established
authors
that
are
responsible
for
all
the
library.
A
A
If
anybody's
questions
oh
and
come
find
me
afterwards,
I've
got
these
little
like
ahiva
I
brought
one
up
for
anyone.
Who's
like
curious
about
V6
I've
actually
started
to
write.
Oh
I
should
explain
that
so,
yes,
basically
I'm
trying
to
write
a
bunch
of
little
apps
right
now
against
V6
to
help
test
it.
So
this
one's
actually
found
quite
a
few
bugs
already
it's
an
nft.
It's
got
a
little
scratch
off
hologram.
A
When
you
scratch
it
off,
you
can
scan
it
and
claim
it,
and
you
can
you
know,
fold
your
little
papercraft
robot
up
and
like
do
this
and
then
take
pictures
of
him
and
post
it
into
the
contract,
and
you
can
like
I'm
thinking
more
of
like
that
little
gnome
from
Amelie.
You
know
you
can
take
it
around
and
show
you
those
things
visited
different
places
right
now.
It's
only
deployed
to
Gourley
for
anyone
who
actually
like
goes
through
the
effort
of
like
submitting
this
I
will
be
migrating
your
tokens
to
mainnet.
A
So
that's
just
like
a
little
demo,
I'm
flirting
together
to
to
test
and
make
sure
V6
works,
and
it's
definitely
not
ready
for
production
as
it
stands
right
now,
but
it's
getting
closer
and
I'll
probably
be
doing
a
few
more
little.
Weird
projects
like
this,
just
to
kind
of
like
find
those
little
foibles
and
and
things
that
happened
during
the
last
two
years
worth
of
rewriting
and
rewriting
and
rewriting
so
I've
got
7
Minutes
49
seconds
left
for
if
there's
any
questions
out
there,
I.
B
B
Where
it's
like
you
know,
smart
contract
auditing
is
important,
but
the
interaction
layer
is
equally
as
important,
especially
now,
as
people
are
getting
more
clever
like
like
you
know,
not
to
not
to
throw
shade,
but
you
know
like
when
I
saw,
you
know,
string
normalization
for
for
ABI.
It
calls
you
know,
I
instantly
thought
like
just
made
me
like
uncomfortable
in
my
gut
of
like
different
things.
That
could
happen
so
just
curious,
like
like
who's
helping.
A
So
basically,
the
auditing
is
all
done
by
me,
which
is
terrible
right
now.
One
of
the
cool
things,
though,
is
between
I've
got
like
oh
sorry,
the
EF
helps
sponsor
me.
I
get
GitHub
grants,
get
coin,
get
coin
grants
a
few
sponsors,
and
so
now
I'm
starting
developed
an
endowment,
so
I
am
hoping
to
be
able
to
get
like
a
proper
audit.
At
some
point
there
was
one
team
at
one
point
that
was
going
to
formally
verify
a
bunch
of
things.
A
Verification
like
it
helps
in
some
regards,
but
it's
not
a
Magic
Bullet
I
think
absolutely
like
proper
auditing
would
work
and
I'm
also
a
big.
That's.
Why
I'm
a
big
fan
of
tests?
I,
don't
want
issues
to
happen,
so
I
feel
like
test
I
mean
tests
can
only
find
the
presence
of
bugs,
not
the
absence
of
bugs
so
I
mean
it's.
A
great
question
talk
to
me
afterwards,
if
you've
got
some
ideas,
I'm
starting
to
get
some
money
off
to
the
side.
Now
that
I
can
actually
start
throwing.
A
A
A
Bash
transactions,
what
which
means
by
bachelor's
actions
like
via
Smart
contract,
wallets,
like
by
you
mean
through
smart
contracts
or
yes,
yeah
yeah
I
mean
that
all
already
Works
you
just
need
the
ABI
for
it.
There's
not
currently
in
ethereum
an
official
like
batch
standard,
but
you
can
do
with
smart
contracts
like
smart
contract.
Well,
it's
like
a
gnosis
safe
for
example.
Allows
you
to
send
mobile.
Is
that
I'm
sorry?
Is
that
what
you
mean
like
being
able
to
send
multiple
transactions
at
once?
An
atomic
atomically
I.
C
A
After
contracts
so
that
you
can't
currently
in
ethereum
in
general,
send
multiple
transactions
atomically
or
at
once,
you
basically
if
you
will
have
a
bunch
of
transactions
you're
trying
to
send
serially,
so
the
Nots
manager
already
does
that.
Basically,
it's
a
wrapper
that
goes
around
assigner
and
you
can
just
quickly
fire
off
transactions
and
it
will
automatically
bump
up
the
nonce
from
the
initial
amounts
of
fetched.
A
There
are
some
issues
with
that
as
well.
If
you
just
you,
know,
flood
the
mempool
with
a
bunch
of
transactions
from
the
same
address
that
are
all
serialized,
it
could
be
seen
from
the
Network's
point
of
view
as
a
Dos
attack,
and
so
it
might
drop
them.
So
that's
a
feature
I
want
to
add
to
the
nonce
manager
in
V6
as
well
is
kind
of
the
ability
to
rebroadcast
or
whenever
something
succeeds
kind
of
like
have
a
callback
that
lets.
D
D
D
So
yeah
more
than
deserved
one
question
about
philosophy-
and
this
is
this-
is
going
very
specific
on
being
that
guy.
But
one
thing
that
ethers
has
a
philosophy
is
really
the
how
it
returns
undefined
and
actually
it
doesn't
return
undefined
for
waiting
for
transactions,
and
we
actually
talked
once
in
one
of
the
PRS
of
typescript
really
giving
the
option
of
of
returning
undefined
money
transaction.
You
wait
on
it
and
it
doesn't
return
anything.
D
D
A
A
Okay,
so
for
background.
Basically
ether's
V5
was
started.
Two
years
ago.
I
was
still
kind
of
learning
typescript.
It
did
not
have
strict
null
checks
enabled,
which
basically
means
anything
that
returns
anything
I'll
turn
that
anything
or
no,
and
so
in
V6
I've
got
strict
null
typing
in
some
strict
null
checked
type
whatever.
You
know
that
what
the
plague
is
it's
disabled
and
so,
for
example,
the
provider's
method
for
get
transaction.
It
will
be.
The
return
type
is
null
or
transaction
response,
whereas
in
V5
it
was
just
transaction
response
and
I
just
trusted.
A
E
A
A
The
slide
that
shows
you
like
the
transaction
dot
Max
gas
equals.
So
that
takes
in
a
big
number-ish.
So
you
can
pass
in
a
bigint.
You
can
pass
in
a
string
that
happens
to
be
decimal
number.
You
can
pass
in
a
string.
That's
a
hex
number
that'll
all
be
munged
into
a
big
int
type,
but
you
can
still
pass
anything
anything
that's
not
ambiguous.
Ethers
will
accept.
A
So
if
you
pass
in
a
string,
that's
one
one.
It's
going
to
assume
as
decimal,
but
yes
it's,
it's
still
a
big
number.
It's
still
a
big
number-ish
and
there's
functions
as
well.
For
your
own
purposes,
that
will
convert
any
big
number-ish
into
a
big
number
or
any
numeric,
which
is
another
type
that
it
now
has
into
a
number.