►
From YouTube: Little-known Web3.py by Marc Garreau | 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/little-known-web3py/
A Web3.py maintainer steps though how to use some of the lesser-known features recently released: async functionality, off-chain data lookups, plugin support and more.
Speaker(s): Marc Garreau
Skill level: Beginner
Track: Developer Infrastructure
Keywords: Python,Web3,Ethereum
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
think
it's
important
to
start
with
the.
Why
question
so,
besides
selling
jpeg
monkeys,
what
are
we
all
doing
here?
I
think
we've
reached
a
critical
mass
or
we've
gathered
a
critical
mass
of
people
here
that
I
actually
believe
we
stand
a
chance
at
re-architecting
rethinking
and
even
adopting
some
core
level
systems
that
we
we
rely
on
things
that
touch
on
our
our
governance
systems,
our
financial
systems
and
some
of
our
social
coordination
systems.
So
how
we,
how
we
work
together,
I
think
our
window
of
opportunity
is
unknown.
A
A
So
this
is
the
sort
of
the
framing
for
this
talk.
My
goal
is
to
increase
awareness
of
a
set
of
python
tools,
some
best
practices
and
some
other
projects.
That
I
think
you
might
benefit
from
being
aware
of
sort
of
the
template,
for
this
talk
is
that
I'll
give
you
just
enough
information
to
know
whether
you
want
to
learn
more
about
it
and
point
to
somewhere,
where
you
can
learn
some
more.
So
this
is
a
blog
post,
I
wrote
about
a
year
ago
now
that
I
think
still
relevant.
A
A
My
wife
and
I
welcomed
triplets
into
our
family
and
then,
while
I
was
on
paternity
leave,
I
helped
establish
developer
Dao,
which
is
a
very
reasonable
thing
to
do.
I'm
excited
about
developer
Dow
because
it's
it's
sort
of
this
hive
mind
of
of
bright
and
passionate
people,
all
sort
of
focused
and
digging
into
this.
A
This
solving
challenges
of
adoption,
I'm,
proud
to
be
part
of
this
ethereum
ethereum
Foundation,
python
team-
we
are
a
small
team
and
we'll
be
most
of
us-
will
be
hanging
out
at
an
impact
Booth
hub
for
a
lot
of
the
day
tomorrow.
So
if
you
want
to
come,
say,
hey
meet
some
of
the
team
and
get
some
very
exclusive
snakey
mcnake
face
swag
come
find
us
there
come
hang
out.
We
just
welcomed
our
fifth
teammate
this
month,
Linda
so
hi
Linda.
A
Welcome
to
the
Ruckus
I'm
going
to
take
a
moment
to
burn
a
couple
seconds
of
time
here
that
I
don't
really
have
to
say
that
this
is
like
a
full
circle
moment
for
me.
When
I
joined
the
EF
in
2017,
my
first
Devcon
was
in
Cancun
Devcon,
3
and
EV.
Fraga
is
in
the
audience
who
was
on
stage
giving
a
shout
out
or
like
given
the
talk
for
the
Miss
browser
team,
and
he
gave
me
a
a
welcome
shout
out
so
I
am.
A
It
brings
me
joy
to
make
this
a
a
newfound
tradition
quickly.
The
EF
python
team
manages
or
maintains
about
a
dozen
python
libraries,
most
notably
web3pi
and
Pi
VM,
the
rest
sort
of
roll
up
into
those
two
libraries
or
help
make
those
two
libraries
work
a
shout
out
to
our
open
source
community
of
contributors.
They
also
help
things
move
along
here
and
shout
out
to
our
the
snake.
Charmers
who've
come
before
us
that
kicked
off.
Essentially
all
of
these
libraries
let's
get
to
web3
pylon,
starting
with
the.
Why
question
again?
A
Why
does
web3pi
need
to
exist
and
the
same
question
is
applicable
to
ethers,
JS,
web3.js
and
language?
You
know
libraries
in
other
languages.
The
short
answer
is
because
Json
RPC
exists
or
more
specifically,
that
the
execution
clients
in
ethereum
speak
Json
RPC
to
if
you
want
to
communicate
with
them,
you
have
to
speak
their
Json
RPC
standard
effectively,
so
in
a
command
line.
If
you
want
to
make
a
an
eth
call
request
to
an
ethereum.
A
Node
might
look
like
this,
where
you've
got
a
stringified
Json
object
that
you're
passing
along
the
ethereum
client
comes
back
to
you
with
this
bit
of
this.
This
blob
of
data,
which
is
then
up
to
you
to
decode
and
make
sense
of
web3pi
and
similar
libraries,
give
you
like
a
human,
readable
interface
for
this,
so
you
make
the
request
for
whatever
it
is
you're
looking
for,
and
ideally
you
get
back
exactly
the
data
you're
looking
for
for
the
Deep
dive
into
what
happens
under
the
hood.
A
There
I've
got
another
blog
post
for
you,
so
what
might
you
know
web3pi
for
already,
in
order
to
communicate
with
an
ethereum
client
you'll
have
to
configure
a
provider.
This
is
this.
Is
your
friendly
reminder
that
the
most
secure
way
to
do
this
is
to
run
your
own
node
on
your
own
machine
and
connect
to
it
via
an
IPC?
Socket
all
know,
well
that
this
is
an
unreasonable
ask
for
most
of
the
ethereum
community,
so
I'd
like
to
plug
here
another
project
to
keep
an
eye
out
on
the
portal
network.
A
Is
there
was
a
great
talk
given
Yesterday
by
pipermerium
about
the
portal
Network,
what
it
is,
how
it
works?
What
the
progress
is.
The
idea
here
is
that
there
is
a
fundamental
redesign
of
the
peer-to-peer
protocols
to
actually
allow
light
clients
that
are
light
enough
to
run
in
your
consumer
grade
Hardware.
A
That
was
intentionally
quick
if
any
of
these
concepts
are
new
to
you
or
you're
new
to
ethereum
in
general,
then
welcome
to
this
weird
and
wonderful
world
and
our
docs
are
fairly
good,
but
I've
also
written
a
couple
of
introductory
blog
posts
that
will
hopefully
make
these
Concepts
a
bit
easier.
So
what's
new,
a
lot
of
work
has
gone
into
making
async
functionality
just
plain
work.
In
web3pi
this
year,
we've
started
with
the
HTTP
provider
because
that's
where
the
biggest
bang
for
the
buck
is.
A
This
is
available
today
in
beta
versions
of
web3pi
instantiating
or
like
configuring.
These
new
providers
is
a
little
bit
more
verbose
and
that
will
improve
over
time,
but
you're
welcome
to
use
it
already
so
very
quickly,
like
an
example
of
what
some
python
or
asynchronous
python
code
might
look
like.
In
this
example,
we're
just
grabbing
the
first
50
blocks
from
the
ethereum
blockchain,
using
async
IOS
as
completed
method.
A
So
as
each
one
of
those
requests
goes
to
your
remote
node
and
comes
back,
we
just
print
out
the
block
number
that
was
received
so
you'll
you'll,
get
it
in,
in
this
case
a
fairly
random
order.
The
the
takeaway
here
is
that
if
you
spend
a
lot
of
your
application
doing
read
operations
you
in
particular
to
and
from
a
remote
node,
you
can
see
some
massive
performance
improvements
like
in
the
neighborhood
of
10x.
A
Moving
right
along
ens
support
is
not
new
to
web3pi,
but
it's
gotten
some
love
in
the
last
year,
so
you
might
know
it
best
for
looking
up
the
like.
It's
read
operations
so
looking
up
the
in
address
and
address
for
a
name
resolving
a
name
from
an
address
or
getting
some
arbitrary
text
that
ens
allows
you
to
store,
as
part
of
your
record
new
this
year
is
async
support
for
ens.
A
So
if,
for
whatever
reason
you
want
to
fetch
the
address
of
Shaq
vitalik
and
Paris
Hilton
in
30
times
in
Rapid
succession,
you
can
see
some
massive
gains
in
performance
here
same
async,
I
o
as
completed
code
sample
there.
That's
the
takeaway.
Your
gains
are
might
be
even
more
significant
than
the
standard
web3
methods.
Let's
get
a
little
weirder
web3pi
introduced
support
for
ccaf
ccip,
read
functionality,
so
this
EIP
was
introduced
by
Nick
Johnson
of
ens.
A
Ccip
stands
for
cross-chain
improvement
proposal
and
read
alludes
to
your
reading,
some
data
on
off
chain,
or
otherwise,
not
on
ethereum
mainnet.
So
this
EIP
introduced
a
standard
for
contracts
to
let
the
user
know
it's
going
to
fetch
some
data
from
somewhere
else,
other
than
I
mean
ethereum.
The
simple
version
of
how
this
works
or
what
this
introduces
is
just
a
pattern
for
using
a
custom
solidity
error
to
return
some
metadata.
A
In
of
of
note,
you
can
include
one
or
more
URLs
where
that
off-chain
data
can
be
fetched
from,
and
then
a
callback
function
for
where
that
off-chain
data
should
be
returned
to
to
be
verified
as
authentic.
Essentially,
this
diagram
is
included
in
the
EIP
and
we're
going
to
use
it
as
a
quick
example
of
what
this
looks
like
in
practice.
So
the
use
case
we'll
chat
through
is
ens
placing
some
or
there
let's
say
ens
is
some
sub
domain
is
registered
on
on
a
layer.
Two
like
optimism.
A
In
our
case,
the
client
is,
is
your
web
3
script
or
app?
We
will
be
making
some
funk
in
this
case
is
looking
to
resolve
the
domain
or
the
subdomain
of
an
address.
The
contract
is
an
ens
resolver
contract.
That
says
this
value
does
not
live
on
mainnet
ethereum,
but
you
can
find
it
on
off
chain
somewhere
at
this
optimism,
Gateway,
for
example,
and
that
information
is
packaged
up
in
this
off-chain
lookup
revert
message
so
under
the
hood.
A
Without
the
user
having
to
know
this
is
even
happening,
web3pi
will
go
and
make
a
get
or
post
request
to
that
optimism.
Gateway
get
that
address
back
and
then
pass
the
relevant
data
to
the
specified
callback
function.
The
Callback
function
within
the
same
ens
resolver
contract
then
reads:
the
signature
verifies
that
this
address
came
from
a
source
that
it
trusts
and
sends
back
along
the
answer
to
web3pi.
A
So
just
for
context
here,
ens
had
to
implement
a
protocol
change
of
their
own
to
support
this
functionality
called
wild
card
resolution.
If
you're
interested
here,
they've
they've
got
a
full
open
source
example
of
their
resolver
contract
that
supports
this
functionality.
Also
of
note,
Nick
is
giving
a
talk
directly
after
this
one
and
I
believe
he's
digging
in
a
bit
further
into
ccip.
Read
functionality
cool
little
update
from
last
week.
A
The
lens
protocol
folks
announced
that
they're
going
to
be
using
the
same
feature
set
to
supply
social
graph
data
from
from
their
protocol
via
their
own
ens,
resolvers,
I,
guess
they're
running.
If,
for
whatever
reason,
this
functionality
introduces
some
security
concern
that
is
not
compatible
with
your
use
case,
you
can
fundamentally
disable
that
at
the
provider
level
level
or
at
the
Contra
or
the
the
call
level
and
then
again
for
more
information,
go
hang
out
with
Nick
or
check
out
his
blog
post.
A
Your
next
option
is
a
custom
method,
so,
if
you're
using
a
a
client
like
Aragon
or
autoscan,
one
of
these
I
have
some
non-standard
RPC
functions.
You
can
choose
just
to
lump
those
directly
into
the
the
East
module
or
whatever
feels
appropriate
for
you,
and
you
can
use
some
of
our
data
formatters
and
call
that
just
like
you
would
any
other
eth
method.
Also
of
note
here
is
that
you
can
use
this
to
override
any
existing
method
in
the
in
the
module.
A
So
if
you
want
to
change
the
way
that
any
call
or
getting
of
Gas
Works,
etc,
etc,
you
can
essentially
replace
it
with
your
own
version.
Your
third
option
is
external
modules.
This
is
intended
to
be
plug-in
support.
So,
if
you
want
to
include
an
entire
API
within
web3pi
a
whole
set
of
functions,
you
can
do
that
via
external
modules.
This
is
very
flexible
as
well.
You
can.
A
Our
only
stipulation
is
that
you
create
these
classes,
and
if
you
need
to
make
use
of
the
parent
web3
module,
then
you
are,
or
you
have
access
to
that
via
the
the
in-net
method.
You
can
Nest
these,
how
you
choose
I
think.
That's
all
there
is
to
that
one
and
fourth
custom
providers
you're
unlikely
to
reach
for
this
unless
you're
creating
something
like
a
custom
test
harness
or
you
just
need
to
fundamentally
alter
the
way
that
every
request
is
made
I'll
leave
that
one
there.
A
Finally,
I,
don't
recommend
it,
but
if
you
got
a
monkey
patch
things
do
what
you
got
to
do
for
more
context
done
one
you
might
reach
for
each
of
these
got
another
blog
post.
Just
for
you
are
we
good
we're
taking
breaths
out
there
all
right?
Let's
talk
about
the
merge
as
a
app
developer.
What
do
you
need
to
care
about?
The
good
news?
Is
that
not
much
else
like
not
not
that
much
has
changed
here.
So
a
couple
things
we
said
goodbye
to
some
test:
Nets
Gourley
is
still
a
good
choice.
A
A
A
Reorg
to
occur
So
based
on
your
use
case,
explore
those
block
tags
and
finally,
we've
got
the
beacon
API,
which
has
existed
for
a
little
while
within
web3pi,
but
maybe
it's
more
interesting
to
you
now.
We've
got
there's
nothing
fancy
here.
It's
a
very
simple
wrapper
around
the
beacon,
node
restful,
httpi,
endpoint,
HTTP,
endpoint
I,
don't
know
where
the
eye
came
from.
That's
about
all.
A
There
is
to
that
a
couple:
debugging
tips
these
both
revolve
around
East
call
I've
prepared
this
little
example
scenario,
but
in
the
interest
of
time
I'm
going
to
skip
straight
to
the
good
stuff.
What
does
these
call?
You
might
be
familiar
with
it,
you're,
probably
more
likely
to
use
it
and
as
attached
to
like
the
contract
object.
So,
for
example,
you,
if
you're
going
to
execute
a
function
on
a
contract,
you
effectively
have
two
options
to
do
so.
One
is
to
call
call
on
that
method
or
transact.
A
Transact
will
submit
that
application
to
the
transaction
pool
to
be
to
get
picked
up,
but
if
you
call
call
that
simulates
the
effect
locally,
so
that
didn't
feel
like
the
perfect
explanation.
But
let's
see
if
we
can
get
there,
eth
Cole
simulates,
a
transaction
in
your
local
environment.
We're
going
to
use
it
in
isolation
here
to
like
highlight
a
couple
of
debugging
tips
that
might
help
you
out
the
second
parameter
it
takes.
The
first
is
the
transaction.
A
The
second
is
that
block
identifier
and
the
default
is
latest,
so
you
would
play
out
a
transaction
in
whatever
the
current
state
of
the
blockchain
is,
let's
say,
for
example,
you
wanted
to
find
out
why
a
transaction
failed
at
some
point
in
the
history
of
of
the
chain.
So
the
revert
reason
is
not
something
that's
stored
on
chain,
but
you
can
get
it
by
essentially
replaying
a
transaction
at
the
time
it
originally
occurred.
So
in
this
example,
we've
got
a
transaction
we're
interested
in.
A
We
build
up
a
transaction,
a
new
transaction
object
to
replay,
and
then
we
call
it
at
that
block
number
-1
to
replicate
the
state
that
it
was
in
at
the
time
it
occurred,
and
then
you
get
that
human
readable
revert
message
that
you
can
then
do
whatever
it
is.
You
need
to
do
with
for
some
more
detail
here.
Another
blog
post,
but
that's
not
all.
There
is
a
third
optional
argument
on
each
call,
at
least
within
Geth
and
Aragon,
and
possibly
some
others
called
State
overrides.
This
can
save
you
some
serious
development
Cycles.
A
If
you
need
to
get
a
contract
in
a
specific
state
to
perform
whatever
testing
it
is
you
need,
for
example,
you
need
specific
State
values
in
that
contract
or
you
need
the
you
want
to
even
alter
the
bike
code
a
little
bit
to
or
like
the
the
operations
within
some
of
the
contract
itself
or
like
undo
a
condition
for
which
the
contract
would
normally
revert
just
to
see
what
would
happen.
Otherwise,
you
can
override
that
in
real
time
within
the
eth
call
method.
A
In
this
quick
example,
I
am
telling
I'm
using
so
in
this
example,
we
are
we're
telling
each
call
that
the
contract
that
lives
at
this
particular
address
I
would
like
you
to
replace
its
runtime
byte
code,
with
this
altered
version
that
I've
made
this
version
that
I'm
interested
in
testing,
and
then
we
can
run
that,
and
in
this
example,
we've
got
a
successfully
executing
call
in
the
last
example.
That
would
have
reverted
for
more
detail
here,
check
out
the
blog.
A
Finally,
last
chapter:
we,
the
python
team,
know
that,
as
time
goes
on,
more
and
more
of
our
users
are
going
to
be
using
our
tools
through
one
or
more
layers
of
abstraction,
and
that's
a
good
thing
specifically
in
mind.
Are
development
Frameworks
that
sort
of
package
together
a
bunch
of
functionality
that
let
users
be
super
productive
in
a
much
shorter
time.
A
So
again
this
this
gets
us.
This
enables
our
users
to
be
more
powerful
to
do
more
and
to
solve
their
local
problems.
So
that's
a
good
thing,
so
that's
that's
what
I've
got
for
you?
We
covered
everything
today
show
of
hands,
make
it
a
little
interactive.
Did
we
touch
on
anything
you
weren't
already
aware
of?
Is
there
anything
that
you're
ready
to
dig
into
a
little
deeper?
That's
like
for
the
camera
out
there,
that's
like
4
000
people
that
all
raise
their
hands.