►
From YouTube: Understanding Transactions in EVM-Compatible Blockchains Powered by Opensourceby Lefteris Karapetsas
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/understanding-transactions-in-evm-compatible-blockchains-powered-by-opensource/
Transactions are stored in the blockchain as hexadecimal data. That may be ok if you are a shadowy super coder but if you are like the rest of us you just need to have them explained in English.
If there are no tools that allow decoding of those transactions then the potential of web3 can not be realized
Its crucial such tools are developed in the open, as opensource code since decoding events for different chains and protocols scale faster than what any team of developers can maintain alone
Speaker(s): Lefteris Karapetsas
Skill level: Intermediate
Track: Developer Infrastructure
Keywords: ethereum,transactions,decoding
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've
been
in
ethereum
since
2014
I
worked
in
circles,
client
in
the
solid
compiler
did
Dao
staff's
white
hat
and
the
ATC
and
darwars
back.
Then
then
I
walked
on
L2
payments
for
many
years
and
founded
rotkey
today,
I'm
talking
about
user
transactions
and
how
we
can
start
to
understand
them
like
what
are
they
and
how
can
we
decode
them
in
a
human,
readable
format?
A
Everybody
has
used
ethereum
in
here
and
we
have
all
faced
these
two
big
problems
like
you
do
not
know
when
you
have
a
transaction,
you
do
not
know
how
to
get
it
like.
There
is
no
built-in
way
to
get
transactions
for
an
address.
You
need
to
utilize
some
kind
of
third-party
service
and
that
will
never
be
decentralized.
Also,
once
you
have
these
transactions,
you
really
don't
know
what
I
mean
there
is
a
complete
lack
of
a
universal
tool
that
will
decode
a
transaction
to
human
readable
format.
A
There
is
some
third-party
services,
but
again
they
are
centralized
and
they
tend
to
be
protocol
specific.
What
does
the
transaction
look
like?
Everybody
has
opened
everything
and
sees
this.
You
know
hex
block.
There
is
no
metadata.
There
is
no
human,
readable
info,
that's
what
every
new
user
to
ethereum
is
greeted
with.
There
is
no
way
to
understand
what
your
transaction
like
three
four
years
ago
has
done.
There
are
ways
we
are
no
longer
in
2014.
A
It's
easy
to
use
you
just
type
in
etherscan,
you
know
transactions
last
and
it
gives
you
using
insight
and
it's
totally
free.
Of
course
it
there
are
Cons
with
other
kind
of
centralized
it's
proprietary
and
closer.
That
means
that
you,
there
is
no
way
for
me
as
a
developer
to
see
how
they
do
what
they
do
or
extend
it
in
any
way.
A
They
know
everything
about
you,
I
mean
I,
know
the
guys
from
others
can
they
are
good
guys,
but
you
never
know
who
in
there
could
be
malicious.
They
can
match
IPS
to
your
addresses
and
know
who
owns
what
address
and
where
they
are
located,
and
it
actually
does
not
decode
everything.
We've
all
seen
that
there
are
transactions
that
data
can
doesn't
like
have
insights
for,
and
there
are
other
tools
that
actually
can
do
this.
A
The
graph
is
a
way
it's
kind
of
an
indexer
per
protocol,
you
they
have
sub
graphs
and
they
index
the
chain
for
a
particular
protocol.
And
then
you
can
query
this
index
and
get
any
insight.
You
want
the
cons,
so
the
process
is
that
it's
very
good
for
single
protocol
data.
So,
for
example,
here
we
have
the
other
V2
ethereum
by
massari.
A
This
is
a
subgraph
that
say
the
other
guys
can
run
in
their
interface
and
query
any
information
they
want
for
their
protocol.
But
it
has
many
many
disadvantages.
It
needs
payment
per
query.
This
is
their
Vision
that
everybody
should
be
paying
for
every
query.
It's
built
for
single
protocol
data,
so
they
subdress.
So
there
is
no
generic
solution.
A
If
you
have
a
portfolio
tracker
or
a
wallet
or
something
that
wants
to
decode
every
single
transaction,
no
matter
what
protocol
it
is
in
subclass
will
not
work.
You
will
have
to
basically
query
every
single
subgraph
and
create
a
subgraph
for
everything
that
doesn't
is
not
supported
yet,
and
it
does
not
work
with
local
apps.
What
I
like
to
call
true
dubs?
A
So,
basically,
when
the
company
that
makes
the
application
hosts
host
the
code,
they
can
have
an
API
key
and
pay
for
the
queries,
but
when
it's
a
local
application,
there
is
no
way
for
this
to
to
happen,
and
there
are
these
other
centralized
apis
like
covalent,
Morales
and
Alchemy
they're
easy
to
use.
They
have
pretty
cool
apis,
which
can
decode
transactions,
give
you
all
the
transactions,
but
the
same
concept.
Letters
can
apply
like
it's
centralized.
It
knows
everything
about
you,
it's
proprietary,
so
you
cannot
extend
it.
A
A
It's
it's
not
all
gloom
and
doomville.
There
are
ways
to
do
this.
Effort
can
again
comes
to
the
rescue.
They
have
many
apis
and
if
you
combine
free,
I
think
so
this
one
for
for
transactions,
then
there
is
one
for
reality
transfer
and
one
for
nfts.
If
you
combine
all
of
them,
you
get
a
pretty
accurate
picture
of
what
transactions
your
address
has
done.
A
It
is
centralized
so
it
can
go
down,
they
can
cut
access
to
the
API
or
they
can
do
what
I
said
before
that
they
can
monitor
you
and
map
IP
to
your
address
the
truly
decentralized
way
to
go
around.
This
is
something
by
my
friend
Thomas
de
Ross,
It's
called
true
blocks.
It
is
really
the
best
and
most
complete
way
to
get
transaction
data
two
blocks.
It
takes
all.
A
Appearances
of
an
address
really
I
have
seen
demos
where
TJ
basically
shows
etherscan
and
then
Compares
it
with
true
blocks,
and
you
can
see
that,
for
some
addresses
through
box
does
indeed
detect
more
appearances
than
the
other
scanner.
It
is
decentralized,
so
it
runs
on
top
of
your
local
node.
So
you
do
not
need
to
to
do
any
other
network
queries.
It's
super
fast,
like
it's
really
like
milliseconds
or
seconds,
depending
on
the
amount
of
addresses
that
you
query
for,
and
it's
built
to
share
the
this
index
with
others.
Of
course
like
like.
A
A
It
does
require
a
local
node,
so
you
need
to
be
running
an
ergon,
node,
I,
think
I'm,
not
sure
if
it
works
with
others
and
of
course
you
require
true
blocks
itself
to
create
the
index
so
building
on
this
I
would
like
to
like
present
what
I
try
to
call
the
stack
of
3D
centralization,
which
is
something
that
we
should
be
driving
striving
for
in
crypto.
So
everybody
should
try
to
run
their
own
node,
so
something
like
a
dab,
node
or
a
Raspberry
Pi,
with
whatever
setup
you
guys
want
to
have.
A
You
should
run
your
own
client
right
like
for
whatever
chain.
You
have
run
a
client
for
that
saying
that
you
want
to
to
use
and
triples
actually
works
for
all
chains,
only
VM
chains,
so
you
can
have
an
index
that,
like
Roblox
on
top
that
will
index,
attain
and
provide
you
an
answer
to
the
question
how
the
heck.
So
what
addresses
sorry,
what
other
access
does
my
address
have
and
on
top
of
it
all
to
come
and
bind
it
all?
A
You
have
the
aggregating
and
decoding
level
that
something
like
rotkey,
but
not
like
a
decoding,
so
Roti
right
now
is
a
an
application,
but
imagine
a
platform
where
you
can
have
a
generic
way
to
go
from
transactions
to
a
common,
readable
format
for
what
they
do,
and
it's
actually
consumable
by
humans
going
from
how
we
get
data
to
what
actually
would
go
into
this
decoding
platform.
That
was
that
my
talk
is
about
so
once
you
have
all
the
data
like
either
from
method
or
from
True
blocks.
What
kind
of
data
is
this?
A
If
you
have
tried
to
play
with
understanding
transaction
history
of
ethereum?
You
know
that
there
is
two
ways
to
get
data:
it's
either
a
trace,
a
transaction
trace
or
transaction
receipts.
There
are
two
kinds
of
traces:
one
is
the
gift
style
trace
and
the
other
is
a
parity.
Trace
I'm
gonna
go
through
them
a
bit
fast
for
those
of
you
who
do
not
know
what
they
are
so
give
style
traces,
the
tracing
that
comes
with
the
git
client.
A
When
a
transaction
happens,
it
touches
a
multi,
so
it
touches
multiple
contracts
right,
so
you
make
a
transaction
to
a
contract,
and
this
one
may
make
a
call
to
another
contract
and
so
on
and
so
forth,
and
as
they
do
this,
they
touch
the
state
of
these
contracts
and
they
they
make
some
changes.
So
this
is
what
the
trace
of
the
transaction
is
and
the
give
style
Trace
is
the
most
complete.
It's
like
super
detailed.
It
has
every
single
step
of
the
execution
with
the
op
code,
the
program
counter
the
storage,
diff
Etc.
A
A
A
It
gives
you
a
call
stack
like
this
of
what
did
your
transaction?
Do
there
like
the
cold
trace
of
the
transaction,
and
this
actually
does
not
require
an
archive
node
by
the
way
the
screenshot
is
from
a
very
nice
article
by
bantag
on
traces
that
came
out
like
two
months
ago.
I
think
so
Google
like
bunt
against
transaction
traces,
and
you
will.
You
can
read
about
it
in
more
detail
and
the
other
thing
that
you
can
use
to
understand
how
a
transaction?
A
What
has
it
done
is
the
parity
style,
Trace
div.
It
gives
you
a
state
the
for
each
account
that
you
touch.
It
gives
you
the
difference
in
Balance,
code,
nodes
and
storage.
The
cool
thing
is
here:
if
you
have
the
API,
you
can
play
with
it
a
bit
and
you
can
have
readable
names
for
the
storage
slots
and
how
did
they
change?
So
this
is
a
very
useful
Insight
on
what
did
the
transaction
do
and,
of
course,
then
transaction
receipts.
A
We've
all
seen
like
the
how
a
source
code
of
a
contract
looks
like
they
have
events.
These
events
are
actually
concerned
in
something
that's
called
the
transactionary
seat.
So
let's
say
for
a
token
transfer,
it's
a
I,
don't
know
like
transfer,
Source
destination
and
value
or
something
almost
everything
generates
them.
It
looks
like
like
this,
this
it's
all
hex,
but
if
you
have
the
ABI
of
the
contract,
you
can
decode
this
into
a
human,
readable
format.
A
A
What's
more,
some
decoders
feed
data
to
other
decoders,
so
the
erc20
transfers
create
the
rc20
transfer
event
and
this
gets
fed
to
unisop,
which
translates
it
into
swabs.
Such
a
decoder
platform
is
made
on
modularity.
This
is
rodky's
repo,
and
this
is
where
we
have
all
the
decoders
and
it's
like
a
huge
list.
A
It
doesn't
have
all
of
them
because
they
don't
fit
on
the
screenshot,
but
the
idea
is
that
it's
easy
to
write,
easy
to
use
and
drag
and
drop
that
uses
drag
so
you
drop
it
in
there
and
it's
caught
by
the
the
system
and
then
a
new
decoder
is
taking
into
account
whenever
we
we,
we
decode
a
transaction.
That's
the
idea,
we're
not
there!
Yet
we
build
binaries,
and
this
is
not
as
modular
as
it
should
be,
but
the
idea
is
that
it
should
just
big,
drag
and
drop.
A
A
So
it's
hard
to
read
probably,
but
the
idea
is
that
you
get
from
the
ER
security
transfer
decoder,
you
get
the
erc20
transfer
and
then
you
see.
Oh,
it's
a
spend.
The
counterparty
is
the
F
bits
of
hop
and
the
asset
of
fmatism
the
amount
matches.
So
then
we
transform
it
into
the
common
event
format
for
hope
and
give
it
a
nice
readable
explanation
which,
like
breeds
the
amount
of
heat
to
either
your
own
address
or
to
some
other
address
in
the
chain.
A
So
the
name
of
the
chain
via
hop
protocol
I
talk
a
lot
about
the
common
event
format,
it's
kind
of
a
POC
because
we
are,
we
are
only
consumer
right
now,
it's
changing.
So
this
is
how
it
looks
in
the
code.
It
has
like
a
sequence
index
inside
the
transaction.
So
where
did
it
happen
in
the
transaction?
Timestamp
location
location
is
mostly
something
that
we
use
in
rotkey
because
we
subtract
everything
into
this
format,
not
only
ethereum
transactions
but
pure
Kraken
trades.
A
Your
ethereum
stating
everything
gets
subtracted
into
this
less
common
denominator
format.
We
have
the
history,
type,
A,
History
event,
type
and
history
event
subtype.
So
this
is
what
defines
the
myth
of
how
you
define
an
event,
the
asset
and
the
balance
change,
and
then
some
extra
stuff,
like
the
location
label,
is
along.
A
This
is
how
a
front-end
can
consume,
and
so
this
code
this
should
be
read,
unfortunately,
because
I
didn't
take
a
nice
cases
from
the
bottom
to
the
top.
So
I
claim
my
Badger
airdrop,
so
it
has
two
events:
the
gas
fee,
that's
burnt
in
the
airdrop,
claiming
then
approval
to
one
inch
V2
and
the
gas
fee
for
this,
and
then
the
swap
for
in
one
is
for
basically
immediately
dumping
the
the
tokens.
A
A
A
Why
right
like
people
would
ask
why
the
heck?
Why
would
you
need
this?
Because
everybody
is
Reinventing
the
wheel?
There
is
again
as
I
said:
neighboring
protocols,
different
exchanges,
chains
jurisdictions,
it's
impossible
to
keep
up.
I
have
talked
I
have
spoken
with
people
in
both
small
startups
and
big
names
in
the
field
for
portfolio
trading
and
crypto
accounting.
Everybody
is
saying
that
this
is
just
too
much
to
give
up
and
maintaining
just
one
module
is
a
full-time
job.
A
A
Any
such
platform
would
have
some
super
basic
requirements.
It
needs
to
be
open
source
like
everybody
does
tries
to
reinvent
the
wheel
in
a
proprietary
clusters
way.
This
is
absolutely
idiotic.
It
needs
to
have
a
modular
architecture
so
that,
as
we
saw
before
like
be
pluggable,
have
pluggable
modules
you
you're
in
a
different
country
than
Germany.
A
You
can
just
plug
the
I,
don't
know
Netherlands
accounting
module,
you
don't
use
ethereum,
you
use
kusama,
you
do
the
substrate
module
and
you
can
do
all
the
polka.com
Etc
it
needs
to
have
a
this
is
a
hard
requirement
to
achieve,
but
it
needs
to
be
moved
illegally.
It
needs
to
have
multilingual
bindings
because
we
attract
your
python
house.
We
know
how
to
use
other
languages,
but
most
of
our
code
is
in
Python.
A
A
If
it
becomes
an
open
source
standard,
then
everybody
should
be
like
oh
wait,
I
mean
we
made
this
new
platform.
We
need
to
write
a
roti
module
for
it
also
because
otherwise,
it's
just
like
nobody
will
use
it
and
the
core
team
that
builds
and
maintains.
It
also
needs
to
be
incentivized
in
in
some
way
in
order
to
be
able
to
keep
building
the
ways
that
this
can
be
is
through
the
support
to
the
various
teams
or
through
slas
for
a
software
level.
A
So
it's
a
bit
funny
I
wanted
to
show
the
I
saw
the
timeline
thing
and
I
was
in
the
template
that
they
gave
us
and
I
thought
hey.
Why
not
put
a
timeline
so
how
the
heck
did
we
get
here?
2017
I
just
need
to
do
my
taxes
in
crypto
and
I
was
like
okay
I'm,
not
gonna.
What
is
the
the
way
to
do
this?
There
was
Bitcoin
to
attacks.
There
was
nothing
else
back
then
I'm
not
going
to
use
a
centralized
service.
Okay,
I,
just
don't
trust
them.
A
A
So
last
year
the
app
had
grown.
We
hired
one
more
developer
and
we
were
2000
users
and
200
paying
users
in
the
beginning
of
this
year.
There
is
many
people
who
use
rotkey
right
now,
some
like
it
some
complain
with.
They
always
want
more
and
more.
But
it
is
at
a
level
that
many
people
can
use
it.
We
are
a
team
of
seven
now,
six
thousand
around
six
thousand
users,
it's
hard
to
know,
because
we
it's
an
open
source
app
and
we
don't
have
Analytics
and
500
550
pen
users.
A
So
for
getting
this
POC
that
I
described
here
to
the
full
rot
division,
we
would
need
to
go
further
from
here
and
try
to
grow
and
potentially
get
some
funding,
because,
with
the
current
team
that
we
have
it's
very
impossible
to
actually
build
this
Vision,
the
POC
cannot
grow
to
a
level
of
something
that
can
be
used
by
the
entire
industry,
with
just
six
people.
Six
developers
is
just
impossible
so
with
this
I'm
coming
to
the
closing
notes.
A
A
We
came
here
thanks
to
you
like
seriously,
it's
a
boost
up
project
and
we
would
not
be
here
without
git
coin
donations
and
without
our
premium
users
so
keep
supporting
us.
You
can
donate
in
git,
going
grants
or
in
buy
premium
subscription
and
unlock
all
of
the
features
of
rodkey,
and
you
can
join
our
community
in
Twitter
or
Discord
like
that's.
Where
all
the
support
is.
B
Okay,
like
you
mentioned
the
graph
and
true
Vlogs,
the
one
thing
that
I
don't
understand
about
these
two
tools
is
the
two
query.
Historical
data
is
that
they
use
a
client
node,
and
this
node
is
basically
in
charge
of
the
story
in
this
data
in
an
SQL
database.
Isn't
this
centralist
way
of
saving
data
is
this
one
ipfs
comes
into
play
and
if
that's
the
case,
can
you
explain
how
ipfs
and
SQL
database
work
together
to
solve
this.
A
Doesn't
come
anywhere
in
there
like
the
graph
is
and
true
looks
completely
different
things,
so
the
graph
is,
it
creates
an
index
on
top
of
your
already
existing
node
data
and
truebox
does
the
same,
but
true
blocks.
Does
it
in
a
generic
way
for
all
of
your
transactions,
while
the
graph
has
specialized
subgraphs
written
by
developers
of
particular
protocol
that
basically
write
an
index
address
for
this
protocol
and
this
lives
on
top
of
your
node
data?
It
is
decentralized
like
the
graph
by
Design
is
also
decentralized.
A
True
blocks
is
itself
also
decentralized.
It
creates
this
index,
and
this
index
is
said,
I
think
it's
pinned
in
ipfs
and
shared
with
others
who
use
true
blocks,
I
I'm,
not
totally
sure,
on
the
details
of
sharing
of
true
blocks,
because
I'm
not
a
developer,
but
I
think
that
this
is
how
they
do
it.
As
for
the
graph,
they
have
a
decentralized
network.
A
A
D
Hola
awesome
presentation,
great
work
from
the
developer
perspective
on
on
a
solidity
developer,
I
think
will
be
very
useful
for,
for
example,
I
write,
a
smart
contract
and
I
write
the
decoder,
let's
say:
I
write
a
decoder
and
I
host
it
on
ipfs.
Have
you
thought
about
that
like
how
we
can
have
that
I
can
standardized
I
know,
let's
say
Parable
where
we
Define
the
URI
or
hash,
where
we
set
our
decoder
and
you
guys
can
use
it
because
you
have
a
list
of
the
course
on
GitHub
right,
yeah.
A
Yeah
yeah
I
mean
this
is
just
a
different
medium
of
of
delivering
the
decoder.
But
yes,
there
is
exactly
what
you
described
so
I'm
not
going
to
write
every
decoder.
My
team
is
not
going
to
write
every
decoder,
that's
impossible,
but
the
idea
is
exactly
that
you,
when
you're
at
your
smart
contract
for
a
protocol,
then
you
say:
okay
I'm,
also
going
to
write
a
decoder
for
this
and
then
somehow
it
should
be
delivered
to
this
middleware.
Yes,
it
can
be
through
a
link
it
can.
This
is
the
POC
of
what
we
have
right
now.