►
From YouTube: Experiments with EthereumJS | 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/experiments-with-ethereumjs/
The idea of the workshop is to present the EthereumJS stack and then help people to set up a local EthereumJS experimentation environment. We will demonstrate how how our packages can be used for research, testing and experimentation and will then let people experiment on their own (or in small groups), for example by activating one of the newer EIPs and testing blocks/tx, or even running our experimental client.
Speaker(s): Gabriel Rocheleau, Scott Simpson
Track: Developer Infrastructure
Keywords: Experiments,JavaScript,Execution
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
A
So
yeah
what
we
do
with
ethereum
JS
is
we
basically
build
a
set
of
tools
that
people
can
build
upon,
so
we're
used
by
lots
of
you
know:
JavaScript
tooling,
that's
here,
I'm
sure,
you're
familiar
with
and
yeah,
and
it's
really
a
great
set
of
tools
for
people
to
learn
about
blockchain
in
general,
because
JavaScript
is
a.
You
know,
really
easy
to
use
language
that
a
lot
of
people
a
lot
of
web
developers
are
familiar
with
and
yeah
we're
focused
on.
A
C
B
B
B
A
So
we
so
I'm
gonna
go
through
that
slide
quickly.
Just
to
give
you
a
sense
of
the
kinds
of
like
packages
that
we
have.
So
we
have
an
implementation
in
typescript
I
mean
we're
calling
from
JavaScript
but
technically
right.
At
the
moment,
everything
is
typescript.
We've
migrated
to
typescript
about
two
years
ago,
so
we
have
a
typescript
implementation
of
the
ethereum
virtual
machine.
We
also
provide
you
know:
building
blocks
like
transaction
block
block
blockchain.
A
We
also
had
to
have
a
bunch
of
like
smaller
scope-like
utils
like,
for
example,
if
you
want
a
rlp
like
recursive
line
prefixing
like
encode
things,
decode
things,
we
have
a
typescript
implementation
of
Merkel
pituitary
as
well,
which
is
you
know,
the
data
structure
that
ethereum
uses.
We
have
a
Dev
p2b
package
and
an
experimental
client.
It
has
sync
magnet,
there's
been
a
guy
who
was
was
able
to
sync
magnet
up
to
the
tip
of
the
chain.
A
It's
not
really
performant
so
I
mean
you
wouldn't
want
to
use
it
in
production,
and
we
don't
have
like
the
mitigation
that
are
in
place
for
more,
like
production,
ready
clients,
but
it
is
able
to
run
all
all
blocks
from
mainnet,
so
yeah
I
was
just
mentioning
it's
used
by
a
bunch
of
tooling.
So
all
these
are
some
of
the
you
know,
packages
that
I'm
sure
you're
familiar
with
like
hard
hat
truffle,
metamask,
remix,
webster.js
and
a
bunch
of
other.
You
know
projects
use
us
as
a
dependency
for
to
to
build
upon.
A
A
You
know
packages
so
at
the
very
bottom
we
have
client
which
Imports,
basically,
everything
that
we've
built
in
the
model,
repo
or
as
common,
is
just
going
to
be
more
like
General
things
that
you
probably
wouldn't
use
by
themselves,
but
are
going
to
be
helpful
for
like,
for
example,
in
common,
you
would
have
like
specifications
for
hard,
forks
and
stuff
like
that
which,
if
you
wanna,
you
know,
build
a
block.
You
know
you
need
to
know
like
which
hard
Fork,
You're
Building.
A
You
know
a
block
for
same
thing,
with
a
transaction
same
thing.
If
you
want
to
run
a
block
in
the
evm
and
stuff
like
that,
so
that
all
lives
in
common
we've
tried
to
modulize
it
in
a
way,
that's
more.
That
makes
more
sense
and
it
makes
it
easy
to
to
Import
and
Export
things
without
them
being
all
intertwined.
A
So
basically,
VM
is
like
a
higher
level,
like
virtual
machines,
virtual
machine
which
sends
you
know
you
would
provide
that.
Like
a
block,
you
would
tell
the
VM
hey
I,
want
you
to
run
a
block
or
I
want
you
to
run
a
transaction
that
it
would
forward
an
individual
like
message
calls
to
the
evm,
which
would
deal
with
like
the
op
codes
and
all
that
sort
of
stuff.
Then
the
evm
would
report
back
and
communicate
with
a
state
manager.
A
That's
going
to
update,
like
whatever
state
you
have
in
your
Miracle
particular
tree.
So
it's
much
easier
to
interact
with
the
state
manager,
because
then
you
can
just,
for
example,
update
an
account
balance
rather
than
like
finding
the
proper
key
in
the
Merkel
particular
tree.
Updating
that
and
recomputing
the
route
which
would
be
you
know,
super
tedious.
Obviously
so,
we've
abstracted
most
of
that
away
with
the
the
state
manager
yeah
I'll
leave
here
discarding
to
talk
about
the
portal
Network,
which
is
another
thing
that
we
are
working
on.
B
B
So,
essentially,
if
you,
if
you
want
to
interact
with
the
blockchain
right
now,
you
either
need
to
run
your
own
full
node,
which
is
a
very
heavy
process
requiring
a
lot
of
your
resources,
and
most
most
people
aren't
going
to
do
that,
and
most
devices
aren't
going
to
want
to
do
that.
I
have
some
most
reach
out
to
inferior,
which
is
a
centralized
access
to
the
blockchain
which
works
fine,
but
it
is
a
centralized
access
to
blockchain,
which
is
kind
of
the
thing
we're
trying
to
avoid.
B
So
it
people
have
been
working
for
many
years,
trying
to
figure
out
what
goes
up
in
that
top
left
box,
where
we
can
have
something
lightweight
accessible
but
also
decentralized
and
the
work
on
Les
light.
Clients
has
eventually
led
us.
This
concept
called
the
portal
portal
Network
portal
network.
Is
it's
an
in
it's
an
independent
peer-to-peer
Network.
It's
almost
like
a
bittorrents.
It's
working
on
that
principle
where,
if
you
need
access
to.
B
Some
amount
of
information
from
the
blockchain
you
don't
need
to
actually
sync
to
the
entire
blockchain
to
retrieve
your.
You
know
your
block
history
or
your
account
history
or
many
of
the
things
that
human
driven
wallet
interactions
need.
So
that's
the
idea
we
we're
building
networks
to
support
the
users
of
this
protocol,
not
necessarily
building
up
the
protocol
itself.
The
way
a
real
full
node
does,
and
therefore
this
can
exist
on
very
light
resource
constrained
devices.
B
B
B
Every
everybody's
got
a
piece,
a
little
piece
of
responsibility
of
the
network
and
they
hold
as
much
data
as
they're
willing
to
as
they
serve
much
as
they
can
or
want
to
so
for
a
practical
example
in
a
you
know,
just
a
Json
RPC
call
for
each
get
balance
right
now,
if
you're
running
a
node,
you
have
to
maintain
all
of
these
databases
where
you
can
look
up
the
the
canonical
index.
You
can
look
up
storage,
you
can
look
up
State
and
return.
These
things
calculate
them
and
then
return.
B
The
balance
portal
network
is
going
to
work
exactly
the
same,
but
instead
of
looking
into
your
own
databases,
your
own
huge
piles
of
state
and
history,
you
can
reach
out
to
these
light
networks.
You
can
to
see
if
your
balance
receive
the
history
receive
state
and
send
it
and
return
it
in
the
exact
same
way.
So
for
for
the
user
using
a
Json
RPC
call,
it
feels
exactly
the
same,
but
it
is
possible
with
very
very
limited
resources
and
ours
is
called
ultralight.
B
There's
two
other
teams,
one's
called
Trin
they're
working
in
their
rust
and
a
client
called
fluffy
that
is
working
in
nem.
So
the
cool
thing
about
ours
is
that
we
can.
We
have
a
CLI
client,
but
we
also
have
it
working
in
a
browser.
So
we
can
open
up
a
browser
page
too,
and
we
built
like
a
stupid,
just
a
small
block
Explorer.
B
But
you
open
up
your
browser
page
to
this
thing
and
the
browser
itself
becomes
a
portal
client
using
the
same
kind
of
same
kind
of
memory
and
and
storage
as
anything
else,
and
you
know,
can
both
can
both
look
up,
look
up
and
serve
yeah.
What
else
am
I
saying
yeah?
Essentially
your
your
app
can
be
a
portal
client.
If
you,
if
you
were
to
bake
this
into
bake
it
into
your
app,
it
can
basically
just
be
running
in
the
backgrounds.
B
We
have
been
building
the
history
Network
for
the
last
year
or
so,
and
that
is
imminently
operational
and
then
the
idea
is
that
the
other
networks
can
just
build
upon
that,
but
they
will
be
independent
networks.
So,
as
a
portal
client,
you
can
participate
in
one
or
all
of
them.
You
can
be
there
as
a
freeloader
and
not
contribute
anything,
and
it
really
doesn't
take
much
away
from
it.
B
B
B
So,
yes,
there
are
ways
to
attack
it.
There
are
ways
to
be
mean
about
it,
but
I
think
for
the
most
part,
as
long
as
as
long
as
enough
users
are
just
kind
of
passively
participating,
then
that's
not
as
this
isn't.
This
isn't
crucial
to
the
protocol
itself
like
portal
that
we're
going
down
does
not
affect
ethereum
in
any
way.
B
B
Yeah,
you
know
problems
that
we're
working
out
we're
we're
trying
to
steam
ahead
with
like
building
the
thing
and
then
like
solve
all
these
problems
along
the
way,
but
yeah,
please,
our
it's
Ultra
late
team
is
just
two
people,
it's
me
and
me
and
Andrew
from
our
team.
So
we're
always
looking
for
help
or
for
whatever
kind
of
contributions
are
out
there.
B
If
we
have
enough
of
those
it
just
kind
of
saturates
over
time,
we
also
have
kind
of
ideas
of
how
to
I
don't
know,
maybe
like
a
babysitter
node,
that
kind
of
like
circles
the
network
and
looks
for
gaps
and
and
kind
of
helps,
helps
fill
in
the
gaps
but
yeah.
It's
these
kind
of
bridge
nodes
that
originally
saturate
the
network
and
maybe
maintain
that.
B
C
A
All
right
so
we'll
we'll
move
ahead
with
a
demo,
video
m.js.
So,
as
you
know,
the
next
hard
for
hard
Fork
is
going
to
be
named
Shanghai
and
there's
a
test
net
running
at
the
moment.
It
was
down
for
a
couple
days,
but
it
got
back
up
I
think
this
morning
or
last
night,
it's
it's
a
test
net
that
basically
implements
a
subset
of
the
of
the
eips
that
are
going
to
be
part
of
Shanghai,
so
there
might
be
additional
ones.
A
The
one
on
this
list
at
the
moment,
but
that
like
tentative,
like
list
of
VIPs
that
are
going
to
be
included
at
the
moment
is,
is
the
one
you
see
on
the
screen.
So
the
beacon
chain
withdrawals
and
the
the
activate
self-destruct
aren't
deployment
implemented.
Yet
in
our
in
our
client
but
yeah,
the
shandoned
testnet
is
up
and
running.
We
have
it
running
with
lodestar
as
a
consensus
client,
which
is
like
the
typescript.
You
know
consensus,
client,
and
then
we
have
it
there
with
ethereum
js's
the
execution
client.
A
A
So
what
I'll
do
is
just
I
will
not
like
run
I
will
not
access,
like
the
actual.
You
know,
Live
Test
net,
but
I'll
run
like
the
test
net
locally.
To
give
you
a
sense
of
how
you
would
go
about
doing
that,
and
you
might
be
interested
in
running
that
yourself
when
we
go
into
the
more
like
interactive
part
of
the
workshop,
so
I
just
need
to
check
out
the
proper
pull
request
from
our
molar
repo.
A
C
A
A
A
Oh
yeah
yeah
they're
actually
available
on
that
pull
request
and
in
a
couple
slides,
there's
a
link
tree
with
all
of
these
outlines.
So
you
definitely
can
access
all
of
these
nodes
and
yeah.
It's
it's.
A
good
exercise
as
well
to
you
know,
run
that
yourself.
You
will
have
time
for
that
and
we'll
be
happy
to
help
everyone
get
that
running
so
yeah.
A
A
Yeah
Shandong,
so
we're
going
to
create
an
ethereum
folder
and
we're
going
to
create
a
load
star
folder
as
well.
So
now
we're
good
to
go
for
that
part.
So
the
next
step
is
we're
already
going
to
start
our
execution
like
assigned,
and
it's
going
to
use
a
Genesis.
That's
been
done
by
by
one
of
the
guys
on
our
team.
Usually
likes
Shandong
at
genesis.json
you'll
see
that
more
clearly
here
here
in
packages.
A
B
A
Yeah
and
there
we
go
hopefully
that
works
live
coding
is
always
a
bit
sketchy
and
the
Wi-Fi
is
pretty
good.
Actually,
if
you
haven't
noticed,
there's
a
workshop
specific
Wi-Fi
network
that
you
can
access,
because
they're
the
global
Wi-Fi
isn't
working
that
well
so
yeah.
We
see
that
we
have
a
Json
RPC
server
started
because
we
started.
You
know
our
client
with
the
RPC
RPC
engine
in
giant
flag.
We
have
a
Genesis
that
we've
specified
and
the
data
directory
is
ethereum.js
which
we've
just
created.
So
that's
pretty
fairly
simple.
A
So
by
default,
when
you
run
the
ethereum,
JS
client,
it's
gonna
consider
that
the
merge,
hard
Fork
has
been
activated
because
we've
specified
you
know
a
Genesis
after
that.
So
at
the
moment
it's
just
waiting
for
a
consensus
layer,
client
connection,
without
that,
it's
going
to
be
not
going
to
be
able
to.
You
know,
obviously
execute
blocks
because
it's
not
getting
getting
any.
So
this
is
exactly
what
we're
gonna
do
we're
gonna
start
the
load
star
consensus
client.
A
So
the
the
first
thing
we
need
to
do
is
we're
going
to
need
to
specify
the
Genesis
hash
to
the
to
the
consensus
layer
client.
So
to
that
to
do
that,
I'm
actually
going
to
bring
up.
You
know
inferior
and
we're
just
going
to
query
the
hash
of
the
I'm
not
going
to
bring
up
info
actually
I'm
just
going
to
query
the
local
RPC
that
we
we've
seen
specified
here.
You
see
somewhere
up
here,
start
Json,
RPC
server,
localhost
8545,
so
I'm
just
going
to
do.
A
You
know,
requests
a
bit
better.
So,
let's
see,
if
I
can
recall
how
to
do
that
by
heart,
we'll
see
so
we're
just
going
to
send
a
standard
like
Json
RPC
request
to
get
the
data
of
the
you
know.
The
very
first
block
in
that
you
know,
exit
execution,
client
state,
so
method,
then,
is
going
to
be.
What
is
it?
A
It's
eat,
get
blocked
by
number
and
if
you
see
me
make
a
title
be
sure
to
point
it
out
so
that
we
don't
break
our
execution
live
client
by
sending
him
like
bad
stuff,
and
so
we're
just
going
to
specify
you
know
the
very
first
block
we
could
specify
earliest
as
well.
This
second
option
is
just
if
we
want
the
transactions,
we'll
we'll
say
yes,
but
it
doesn't
really
matter
all
that
much
then
we
need
to
specify
an
ID
I.
Think
we'll
just
go
with
one.
A
Can
you
see
properly
yeah
cool
big
enough?
So,
let's
see
if
that
works,
cool
yeah.
So
we've
got.
You
know
the
first
Genesis
block
we
should
expect
like
the
parent
hash
is
going
to
be
zero.
This
is
post,
merge,
sort
of
mixed
hash
is
zero.
It's
it's
unused
and
denounces
one
two,
three,
four,
not
sure
what
that
is,
but
that
is
probably
like
a
default
value
or
something
so
we're.
A
A
C
A
So,
let's
see
if
this
works,
so
we
should
eventually
start
you
know
producing
blocks.
Oh,
we
see
publishblock
that
looks
pretty
good
and
then,
if
we
go
back
to
the
execution
layer,
client
it
should
have
picked
up
on.
You
know
the
consensus
client
starting
to
run
producing
blocks,
sending
them
back
to
it.
So,
let's
see,
if
we
yeah
it's
assembling
blocks,
build
block.
That
looks
perfect,
so
we
we
are
seeing
that
we
have
a
local
shangdong
blockchain
running
with
a
bunch
of
newer
eips.
A
Now
one
thing
we
can
do:
we
have
a
test,
Suite
I,
think
for
like
it's,
so
we
have
a
bunch
of
tests
here
that
we
can
run
to
see
if
the
you
know,
eips
have
been
properly
implemented,
so
I
won't
go
through.
All
of
them
feel
free
to
go
through
them
yourself.
So
EIP
like
3670,
is
a
like
the
eof
code
execution,
the
code
validation.
So
if
you
try
to
publish
like
a
contract
code
that
doesn't
conform
to
the
eof
standard,
it
will
get.
You
know
rejected.
A
C
A
A
A
All
right,
so
this
is
a
where
we're
going
to
start
like
the
more
interactive
and
I
feel
like
interesting
part
of
this
Workshop.
Where
I
mean
we
encourage
you
like
to
bring
actually
your
laptop
style
and
if
you
have,
if
you
don't
have
a
laptop
or
you
don't
feel
like
you
know,
coding
yourself.
I
would
really
encourage
you
like
to
to
meet
up
with
someone
or
to
pair
with
someone
who
actually
has
a
a
laptop
going,
because
I
feel,
like
that's,
probably
going
to
be
the
best
way
that
you
can.
A
We
can
show
you
about
the
mono
repo
and
if
people
have
like
different
degrees
of
of
skill
levels
or
familiarity
with
like
blockchain
in
general,
we
have
a
couple
of
like
suggestions
as
to
what
we
suggest
you
to
do
so,
if
you're
and
that
QR
code
is
the
link
tree.
I
was
mentioning
earlier.
So
it
has
links
to
all
all
of
these
things,
along
with
the
like
Shandong
test
net
instructions.
B
I
also
I
want
to
mention
the
structure
of
our
mono
repo.
You
can
clone
the
whole
mono
repo
and
it'll
come
with
what
is
it
12
packages?
However,
all
of
the
relevant
packages
will
come
in
the
mono
repo
if
you
clone
that
from
GitHub,
but
each
individual
package
is
also
installable
on
its
own.
So
you
can.
You
can
install
just
the
transaction
package
or
just
the
block
package
and
you
don't
need
to
have
the
whole
mono
repo
as
a
dependency.
You
can
have
each
individual
each
JS
package.
A
Yeah
clothing:
the
model
repo
is
probably
the
way
to
go.
If
you
want
to
experiment
a
bit,
especially
since
some
of
these
packages
are
and
they're
dependent
on,
you
know
each
other.
But
if
you
were,
for
example,
building
a
set
of
tooling
and
you
only
need
to
build
blocks
from
data
or
build
transactions
from
some
piece
of
data
that
you
have,
you
could
only
import
like
app
ethereum
Block
in
that
ethereum
transaction,
and
that
would
be
you
know,
all
that
you
need.
You
don't
need
to.
A
You
know
import
the
whole
model,
repo,
it's
just
package
based
so
yeah.
What
we
have
like
sort
of
prepared
for
you
in
terms
of
like
paths,
if
you're
more
like
I,
would
say,
beginner
but
like
if
you're,
more
novice
or,
if
you've
never
really
learned
about.
You
know
Merkel
Patricia
trees,
a
good
way
like
to
explore.
That
is
with
a
tutorial
that
have
been
written
like
two
years
ago
and
has
been
like
updated
recently,
and
it
basically
goes
through.
A
It
uses
our
tree
package
to
teach
you
about
the
very
fundamentals
of
that
data
structure.
So
it
just
starts
with
you
know,
putting
a
value
inside
the
miracle,
but
you
should
try
database
getting
the
value
Computing
a
hash.
Looking
how
you
can
you
know
make
proofs
from
these
hashes.
Eventually,
all
the
way
up
to
you
know
querying
data
on
the
blockchain
and
and
interacting
with
it
more
dynamically
in
a
way,
that's
more
similar
to
what
you'd
expect
in
the
real
world
context.
A
So
I'm
super
happy
to
help
you
as
well
answer
any
questions
on
trees.
It's
the
package,
I've
worked
the
most
on
in
the
more
I
guess
intermediate
track,
although
I
mean
Merkel.
Pursuites
are
certainly
like
not
super
easy,
so
we
could
have
put
that
in
their
intermediate
track
as
well.
You
can
experiment
with
like
rlp,
encoding
or
decoding,
so
this
is
the
serializing
algorithm
currently
used
by
ethereum,
and
we
cover
a
bit
of
that
in
the
Patricia
trees
tutorial.
A
But
if
you
want
to
experiment
with
like
oh,
what
does
a
an
area
containing
a
dog
and
cat
strings?
Look
like
when
you
are
all
pin
code
them?
That's
the
package
you
would
go
for.
It
contains
two
methods:
rlp.encode
rlp.d
code,
super
simple,
and
you
have
a
bunch
of
helpers
like
to
convert
hex
to
Strings
and
stuff,
like
that.
Another
I
feel
like
exciting
thing
that
you
could
use
are
packages,
for
is
the
block
and
the
transaction
packages.
One
of
the
things
you
could
do,
for
example,
is
query.
A
You
know
just
like
we've
done
here.
We've
query
the
block,
so
a
good
exercise
would
be
to
recompute
the
hash
of
that
block
from
that
data.
We
have
helpers
that
can
do
it
for
you,
like
super
easily,
where
you
basically
just
paste
that
Json
object
and
it's
going
to
recompute
like
the
hash
or
a
block
object
for
which
you
can
get
the
hash,
but
it's
also.
It
can
also
be
interesting
to
just
take
those
fields
like
manually
and
try
to
recompute
the
hash
yourself,
and
we
have
all
the
helper
methods
you
would.
A
You
would
need
to
to
do
that
and
if
that
feels
a
bit
a
bit
hard,
you
can
look
at
how
we
actually
Implement
our
helper
methods,
and
you
know
try
that
out,
go
back
to
the
but
yeah,
but
yeah
all
right
in
the
more
Advanced
I
guess
track.
One
of
the
things
you
could
do
is
invent
and
Implement
your
own
EIP.
A
That
might
look
like
super
hard,
but
we
have
an
example
here
of
a
super
like
minimalistic,
EIP
and
I'm.
Actually,
gonna
show
that
to
you
just
so
that
you
see
how
small,
like
potential
EIP
can
be
so
I
think
it's
18
for
yeah
right.
So
it's
adding
like
92
bytes
of
code,
removing
two
pretty
simple:
it's
in
the
IP
that
goes
into
Shanghai,
just
warms
the
coinbase
address.
A
So
if
you
take
this
as
a
as
an
example,
your
I
think
you're
easily
going
to
be
able
to
you
know
reproduce
at
least
the
scaffolding
for
an
EIP,
and
you
can
like
invent
this,
perhaps
not
so
useful,
but
like
easy
one
where
it
just
modifies
the
way.
Maybe
a
block
is
rounded,
maybe
modifies
the
the
name
of
field
or
something
like
that
and
yeah
that
I
think
that
PR
can
serve
as
a
guideline
for
how
to
do
that
and
yeah.
Most
of
the
implementation
is
actually
like.
It's
basically
just
that
line
here.
A
In
terms
of
other
things
that
you
could
do,
you
can
run
the
local
client,
as
we
you've
seen
us
do,
and
you
can
run
the
Shandong
test
net
with
lowestar
as
the
consensus
client,
so
yeah.
Now
it's
of
to
the
races,
as
return
always
says,
so
any
does
everyone
raise
your
hand
if
you
don't
have
a
laptop
well,
I
have
one
so
I
won't
raise
my
hand,
so
everyone
has
one
awesome.
So
was
everyone
able
to
scan
that
link
tree
thing
all
right
cool?
If
not,
the
link
is
just
linked,
linktr.ee,
slash
ethereum.js!
A
So
do
I'm
wondering
how
to
best
like
structure
this
so
either
I
can
go
through
one
of
those
myself
for
those
who
want
a
more
follow
along,
but
I
think
what
would
be
helpful
is
maybe
if
we
just
help
everyone,
you
know
set
up
a
local
environment
and
if,
at
some
point
you
want
to
follow
with
what
I'm
doing
you
can
do
it
or
if
you
want
to
work
on
your
own
thing,
you
can
do
that
as
well.
Does
that
sound
good
to
everybody.
A
A
A
A
Okay,
so
I
think
you
just
entered
so
yeah
just
you
can
clone
the
ethereum
JS
motor
repo.
The
second
link
intermediate
Link
in
the
in
the
link
tree
that
you
see
here
and
then
yeah
just
make
sure
you're
on
the
you're
on
the
master
branch
that
should
be
default
and
then
yeah
just
pull
the
latest
and
npm
I've
to
install
the
model
repo.
That
should
be
all
that
you
need.
A
A
Awesome,
okay,
cool
I
wouldn't
quite
recommend
it.
It
does
cover
some
of
the
stuff
that
were,
we
would
be
doing
in
Block
transactions
in
the
rlp,
but
it
just
guides
you
through
them,
rather
than
just
showing
you
out
there
who's
thinking
of
just
going
straight
intermediate
and
building
blocks
transactions,
all
right
and
who's.
Thinking
of
trying
to
implement
their
own
EIP
is
anyone
motivated
all
right
awesome
and
what
about
running
the
client
or
running
the
Shandong
test?
Net?
C
A
Yeah,
so
this
is
the
folder
that
you
should
go
in.
If
you
want
to
do
that
tutorial
and
the
readme
is,
is
you
know
the
tutorial
itself?
What
we
also
have
is
a
set
of
examples
like
I
had
written
this
tutorial
in
JavaScript,
just
so
that
people
who
know
wanted
to
learn
about
ethereum,
didn't
know
about
typescript
didn't
really
have
to.
You
know,
learn
about
it,
so
those
are
like
GS
files
that
you
can
just
run
with
a
node.
A
C
A
A
A
A
Okay,
the
the
the
principle
is
going
to
be
the
same
for
all
of
the
packages
themselves.
So
if
you
go
within
the
individual
package
that
you're
trying
to
run
the
test
in
just
do
npm
run
tape
and
tape
is
like
the
testing.
You
know
framework
that
we
use.
Then
you
do
double
I
think
those
are
called
Dash
in
English
I'm,
not
even
sure
then
test
to
look
at
the
test.
Folder,
and
then
you
just
select
the
file,
basically
that
you
that
you
want
to
run
right.
A
Do
that
and
it's
going
to
run
that
test
individually,
if
you
do
npm
run
tests,
it's
just
gonna
run
like
a
massive
Suite
of
of
tests,
including
like
integration
tests
that
depend
on
browser
integration.
Stuff
like
that,
and
that's
typically
like
super
long.
We
only
do
that
like
in
the
CI
once
in
a
while
but
locally,
it's
a
bit
tedious
so
and.
C
A
A
All
right
so
there's
you
know
a
bit
of
preliminary
info
that
you
might
want
to
read.
You
know.
Data
structure
of
ethereum
is
called
a
miracle
pituitary,
it's
a
basically
a
combination
of
a
myrtle
tree
and
a
picture
should
try.
A
try
is
a
data
structure
in
which
Keys
represent
the
path
leading
to
a
specific
node,
and
the
mergle
tree
is
a
structure
in
which
a
parent
node,
the
key
of
that
is
the
hash
of
the
all
the
child
nodes.
A
Miracle
3,
is
interesting
because
if
you
want
to
prove
that
the
certain
value
is
part
of
the
data
at
the
large
Market
restructure
that
you
have,
you
can
do
so
by
providing
a
bunch
of
like
sister
nodes,
we'll
see
that
super
clearly
in
the
tutorial
itself,
so
yeah
the
instructions
are
here,
they're
the
same
that
you've
just
ran
so
clone
the
model,
repo
install
it
and
then
go
inside
of
that
try
package,
so
I'll
Bing,
going
through
these
like
fairly.
You
know
slowly
so
feel
free.
A
If
you're,
you
know
want
to
go
a
bit
faster
to
just
go
forward
and
don't
let
me
like
slow
you
down,
but
the
so.
The
first
example
we're
going
to
use
the
try
you
know
library
before
is
creating
and
updating
a
base
Drive.
So
what
does
that?
Look
like
so,
first
of
all,
we're
importing
the
try
class
from
the
the
try
package
and
we
can
look
at
what
you
know
that
looks
like
it's
probably
like
try
file
yeah.
A
So
try
is
simply
a
class,
and
you
know
it
has
a
bunch
of
properties
that
you
would
expect
on
the
you
know.
Database
like
structure
it
does
use
like
checkpoint
DB
is
a
as
like
a
database,
and
then
you
can
provide
options
for
the
tree.
So
some
of
the
options
are.
Do
you
want
to
use
this
specific
type
of
keys?
You
want
to
use
like
plank
keys
or
hashed.
Keys
like
are
what
is
used
in
ethereum.
Then
we
instantiate
database.
A
You
could
provide
like
your
own
database
here,
where
you're
instantiating
a
new
like
map
DB
and
yeah
instantiating
a
new
tree
when
we,
you
know,
construct
a
tree
with
the
tree
class,
and
you
can
see
you
have
a
set
of
methods
here.
You
can,
for
example,
you
know,
get
the
root
of
the
tree.
You
can
verify
if
a
certain
route
exists,
you
can
get.
Those
are
like
these
two
methods
or
the
ones
we're
going
to
be
using
the
most.
A
So
we
have
a
get
method
to
retrieve
a
value
by
providing
a
key,
and
then
we
have
a
put
a
put
method
which
stores
a
given
value
at
a
specific
key.
So
fairly
standard
you
know
database
stuff,
but
this
is
going
to
give
us
insight
into
how
you
know
the
that
actual
data
structure
works
because
it's
not
like
a
simple
database.
A
C
A
A
Am
I
doing
yes,
typo?
Oh
it's
within
Merkel
trees
and
then
example,
one
a
there
we
go.
So
this
all
I'm
going
to
be
doing
here,
as
you
can
see,
is
instantiating
a
new
tree
with
you
know
the
the
try
package
from
the
model,
repo
and
then
logging
the
root
of
that
tree,
and
this
is
going
to
give
us
the
the
root
of
the
tree,
which
is
you
can
look
up
in
the
Docks.
A
But
it's
basically
that
the
the
the
encoding
of
I
think
an
empty
array,
rlp
encoding
of
an
empty
array.
So
yeah
we
see
like
pretty
fast.
We
see
we
output,
a
buffer
which
is
a
which
is
that
now
that
doesn't
tell
us
a
whole
lot,
but
we
could
look
up
in
the
docs
and
see
that
this
is
actually
exactly
what
we'd
expect
in
as
the
root
of
Genesis
like
root
of
a
of
a
try
like
data
data
structure.
A
So
then
we're
going
to
move
on
to
a
more
you
know,
a
more
interesting
test.
I'd
say
we're
gonna
we're
gonna,
try
to
just
put
a
value
in
it
and
see
if
we
can
actually
retrieve
it.
Another
thing
we're
also
gonna
be
able
to
see
is
how
the
the
route
you
know
has
been
updated.
Given
that
so
yeah,
what
do
we
do
here?
We're
creating
a
key
I
mean
a
try.
A
Natively
uses
buffers
so
we're
doing
like
buffer
from
for
for
all
of
these,
so
we're
having
test
key,
that's
going
to
be
your
key
and
we
have
test
value.
This
is
going
to
be
our
value
and
then
we're
doing
an
asynchronous
operation
like
putting
that
key
value
pair
inside
of
the
try
and
then
we're
going
to
try
to
retrieve
that
value
fairly
simple.
What
we
should
expect
here
is
a
so
what
should
be
the
value?
A
Well,
it
should
be
the
you
know:
the
encoded
version,
the
buffer
from
version
of
test
value
and
the
value
string.
We
should
expect
to
see
value,
and
if
we
don't
there's,
there's
been
an
issue
either
you
know
in
the
library
or
in
the
way
we've
used
it.
It
should
also
update
the
tree
root.
So
one
thing
I'm
gonna
do
is
I'm
gonna,
also
log.
A
A
A
Just
logged
the
same
thing
twice
the
value
that
we've
retrieved
is
it's
this.
If
you
are
familiar
with
the
you
know
this,
just
the
hex
correspondence
for
all
of
the
all
of
the
characters
and
then,
if
we
convert
that
to
a
string,
we
get
back
to
this
value.
This
is
exactly
what
we
expect.
Then
we
see
that
the
try
route
has,
you
know
massively
changed,
as
you
would
expect
from
any
kind
of
hashing
if
it
differs
slightly
totally
different.
A
A
The
the
only
slight
difference
is
that
Merkel
Patricia
trees
use
like
hash
keys,
so
instead
of
using
the
key
we'd
use
like
the
the
hashed
version
of
that
key,
and
this
is
only
to
balance
out
the
tree
so
that
there's
no
Vector
of
attack
where
you
always
update
like
values
in
a
similar
region
and
make
it
more
costly
for
those
to
run
operations
the.
So
what
I
think
your
question
is?
Is
you
know
there
are
there's
a
if
you
had
a
normal
little
structure
like
this?
You
would
always
like
Traverse.
A
So
if
you
have
a
key
of
like
you
know,
32
bytes,
then
you
would
Traverse
like
all
these
nodes
on
the
way
down
there.
Now,
Merkel
Patricia
trees
are
more
efficient
than
that
because
if,
if
they
know
that,
given
a
certain
path,
there's
only
one
possible
path
down,
they're
gonna
create,
what's
called
an
extension
node,
which
extends
all
the
way
down
to
the
to
the
leaf.
So
this
allows
you
to
shortcut
unnecessary
paths.
A
What
you'd
see
if
you
didn't
have
that
is,
there
would
be
a
bunch
of
layers
in
there
Merkel
pituitary,
where
there's
only
like
one
specific
branch
that
has
a
value
and
then
you
go
down
and
there's
only
one
specific
Branch
so
for
like
sparse
trees,
meaning
like
trees
that
aren't
filled
like
with
data
all
over.
This
is
incredibly
more.
You
know
efficient
because
you
don't
have
to
store
like
all
these
unnecessary
nodes.
B
A
Is
about
yeah
there's
a
couple
of
additional,
like
notes,
Here,
that
you
might
be
interested
in
some
of
them
I
mentioned,
while,
while
doing
it,
it's
also
talking
a
bit
about
the
rlp,
you
know
encoding
function.
This
is
a
actually
not
up
to
date.
That
link
I,
think
it's
probably
here.
Yeah
yeah,
so
there's
some
very
nice
ducks
in
on
ethereum.org
for
developers
like
if
you're
looking
to
learn
a
bit
more
about
rlp,
you
would
just
go
there.
A
They
have
a
bunch
of
examples
and
you
couldn't
even
like
use
our
library
to
test
it
out
and
play
around
with
it.
So
before
values
or
so
there's
a
bunch
of
values,
you
could
want
to
store
in
the
miracle
Patricia
tree
right
and
those
need
to
be
serialized
before
they
are.
You
know,
put
inside
of
the
tree.
This
serialization
is
done
with
the
recursive
lamp,
prefix,
encoding
function
and
and
yeah
as
I
mentioned
Keys,
also
go
in
additional
additional
transformation.
A
C
A
The
key
so
how
we're
going
to
do
that
is
we're
just
gonna.
You
know
import
the
kick
to
56
that
we
have
in
you
know:
ethereum
jazz,
slash,
util
package
and
the
only
difference
is
we
are
going
to,
as
you
see
here,
put
the
value
at
the
Keck
of
the
key
instead
of
the
key
itself,
so
everything
else
is
going
to
be.
You
know
exactly
the
same.
A
A
Industry,
okay,
so
the
the
values
themselves
are
enhatched,
because
otherwise
we
wouldn't
be
able
to
retrieve
them.
Since
you
know,
hashing
is
one
way.
The
only
thing
that
we
hash
is
I
mean
this
is
like
a
key
value.
You
know
data
structure,
the
value
we
keep
you
know
native.
We
just
rlp
encoded,
for
you
know
serialization,
so
that
it's
compatible,
but
the
the
key
itself
that
we're
hashing.
B
A
A
All
right
so,
as
we
said
like
fairly
fairly
straightforward,
now
we're
going
to
do
something.
You
know
a
little
bit
more
interesting
now.
What
we've
seen
is
that
the
the
like
we've
used,
the
kecac
256
of
the
key,
but
there's
a
you
know,
there's
a
property
of
the
tree
that
we
can
just
use
in
order
to
do
that,
natively.
A
That
property
is
called
use
key
hashing,
it's
a
Boolean
that
defaults
to
false,
but,
as
you
can
set
to
true,
if
you
want,
when
playing
around
with
a
tree,
is
just
more
convenient
to
set
it
to
false
or
have
it
you
know
default
to
false,
just
because
you
you
don't
have
like
to
to
all
do
all
that
additional
computation.
It's
also
easier.
A
If
you
want
to
debug
what
a
value
you
know,
if
you,
if
you
only
have
the
the
hash
of
the
key,
you
can
never
know
like
what
was
the
actual
key
that
I
used
to
update
this.
You
cannot
retrieve
it
back,
which
is
actually
an
issue
that
has
also
come
up
when
making
the
transition
from
Myrtle
trees
to
Vertical
trees,
but
that's
a
different,
that's
a
different
topic.
A
I
think
it's
basically
the
same
thing,
but
just
using
the
use
key
hashing.
So
what
we
should
expect
unless
our
yusuke
hashing
Boolean
is
implemented
improperly
is
we
should
expect
exactly
the
the
same
values
that
we
have
here,
including
the
updated
tree
root,
given
that
we're
using
the
same
yeah
testing
this
valued?
That
should
work.
So,
let's
see
and.
C
A
Okay,
now
we're
going
to
do
a
a
different
operation.
So
among
the
operations
that
are
possible,
you
can
retrieve
a
value
you
can
update
the
tree
by
adding
new
values.
You
can
also
delete
values
from
the
tree.
So
let's
see
what
this
looks
like
the
as
I
as
I
kind
of
mentioned
before
every
tree.
That
is
similar.
That
has
all
the
same
data.
Should
you
know
compute
the
same
route?
That's
how
we
get.
You
know
the
security
properties
of
these
of
these
trees.
A
All
right,
yeah
create
it
update.
It
then
delete
using
the
weight
deal.
Helper
method,
get
it
again.
We
we
shouldn't
be
getting
a
value
when
we
try
to.
You
know
retrieve
at
that
key
I'm,
not
exactly
sure
what
we're
going
to
get
I'm,
not
sure
if
it
throws
or
oh
it
looks
like
yeah.
It's
going
to
be
null
fair
enough,
and
let's
see
about
that
all
right,
so
we
are
starting
out
with
the
M3
empty,
try
route
here
it
starts
with
56
E8.
A
Then
we
are
updating
the
tree,
we're
getting
an
updated
tree
root
which
is
similar
to
the
like
unhashed
key
one
we
had
before,
and
then
we
are
delaying
that
value
again.
And
what
do
we
get
back
when
we
query
that
that
tree
for
that
key?
We
we
get
back
now,
which
means
like
empty.
No,
it's
not
there
and
the
tree
route
that
we
get
back
after
the
deletion
is
the
same
that
we
start
with
so
yeah.
I
kind
of
demonstrates
that
every
you
know
same
tree
is
going
to
have
the
same
root.
A
A
All
right
all
right,
so
there
are
four
kinds
of
notes
in
Myrtle,
Beach
trees.
So
there's
the
null
node,
which
is
the
one
we
just
queried
accidentally
by
you
know
deleting
the
tree.
That's
a
non-existent
note!
You
get
back
now
when
you
query
for
something
that
doesn't
exist.
There
is
a
branch
note
what
a
branch
node
does
is
it's
basically
an
intermediary
node
that
points
to
a
bunch
of
child
nodes.
There
is,
then,
the
leaf
node,
which
is
you
know
this
is
called
the
tree.
The
leaves
are
the
very
end.
A
A
C
A
A
Yeah,
how
how
is
that
initial
route
created,
yeah,
good
question,
I'm
I,
think
it's
the
rlp
encoding
like
it
has.
Basically
still
you
know
it's
it's
the
hash
of
the
value
at
that
root,
because
it's
initialized
with
a
value
if
it
wasn't
initialized
with
a
value,
would
just
be
null.
You
know
initially
the
way
they're
defined
I'm.
C
A
A
A
C
C
A
All
right,
so
this
is
importing
the
encode
method
from
the
rlp
library.
So
what
do
we
should
expect
to
get
back
from?
You
know
an
empty
string.
Rlp
encoding
would
be
Ox
80,
which
is
you
know
the
buffer.
We
we
just
saw
before
so
I'm
gonna
have
to
move
out
of
that
repo
going
to
the
example
solder
and
then
run
this.
C
D
C
D
C
A
A
A
C
A
128
we
we
got
back
the
decimal
value,
but
128
is
like
ox
80
in
decimals,
which
is
the
the
value
that
we're
using
inside
of
the
tree
to
compute
the
root
hash.
So
we
are
basically
just
to
to
compute
that
you
know
root
hash.
We
are
just
hashing
ox80.
So
if
we
take
the
kecought
hash
of
the,
let
me
look
back
at
a
place
where
we
were
using
KitKat,
so
I
don't
have
to
re-import
manually.
A
A
So
we
have
a
buffer
to
hex
util
in
the
package.
Now
the
way
my
testing
thing
is
set
up
might
not
allow
me
to
import
that
yeah
yeah,
so
I
would
need
to
do
buffer
to
hex
here.
Well,
since
I'm
now
running
on
a
like
JS
thing,
I
would
need
to
build
it
before
I'm
able
to
run
this.
So
I
will
not
do
this
here,
but
those
are.
C
A
Cool
any
other
questions
before
we
move
on
to
going
to
all
specific
kinds
of
notes,
we're
good
all
right,
cool
everybody's
following
along
all
right
nice,
so
yeah
we're
just
going
to
start
with
creating
and
looking
up
null
node.
So
how
do
we
we're
not
actually
really
going
to
create
a
null
node,
we're
just
going
to
query
for
a
key
that
is
not
present
in
the
Merkel
particular
tree.
So
it's
basically
the
simplest
like
test
case
you
could
imagine
so
what
we're
going
to
run
is
to
to
a
right.
D
A
That's
here,
yes,
we're
instantiating
a
new
tree.
We
are
trying
to
find
a
path.
You
know
to
the
to
the
key
test
key
and
we'll
see
what
kind
of
node
we'll
get
back
now.
What
you
will
see
now
is
that
we're
using
findpath,
which
is
going
to
provide
us
with
the
actual
node
and
then
all
the
object,
instead
of
just
providing
us
with
the
value.
A
So
if
you
want
to
query
the
the
three
four
actual
values
just
do
get,
but
if
you
want
to
get
more
information
as
to
you
know
what
the
path
is
and
what
the
node
looks
like,
you
would
just
do
a
fine
path
so
we're
running
example:
eight.
This
provides
us
with
yeah
a
null
node,
as
we
would
expect.
We
could
change
that
to
pretty
much.
You
know
anything
and
we
would
get
back
now
as
well.
A
A
A
Basically,
a
way
to
bootstrap
the
tree
so
that
it
starts,
you
know
with
something
you
could
Define
like
a
new
Mercury
patriotary
data
structure.
That
uses
like
something
different,
obviously
from
rlp
encoding
and
also
has
a
different
like
root
hash.
You
don't
necessarily
have
to
use
it.
It's
useful
in
the
context
of
ethereum,
because
we
obviously
want
to
be
consistent
throughout
like
implementations.
But
it's
not
it's
not
a
necessary
part
of
the
data
structure
like
that
you
could
Define
It
Anyway
any
way
you
want
so
yeah.
The
null
node
is
a
bit.
A
A
Each
note
is
a
hex
value
right,
so
let's
say
the
next
part
of
the
key
is
like
seven,
you
go
branch
number
seven
and
then,
if
it's,
you
know
four
like
in
this
example,
you
take
branch
number
four
and
you
go
all
the
way
down
now,
since,
like
murder,
trees
are
like
optimized
with
extension
nodes,
you
wouldn't
get
a
branch
every
part
of
the
way
down.
What
you
would
see
is
you
would
start
at
seven.
Let's
say
you
only
had
like
one
of
the
keys,
it
would
start
at
seven.
A
It
would
give
you
straight.
It
would
go
you
straight
to
the
end,
because
there's
only
one
value
that
starts
with
seven,
so
it
would
like
kind
of
compress
the
tree
for
you.
So
if
we
want
to
create
a
branch
node,
that's
like
acts
as
an
intermediary
node,
you
would
wanna.
You
know
we
want
to
store
keys
that
are
all
basically
in
the
same
spot
and
then
Branch
out
at
some
point,
and
that's
actually
interesting,
because
it's
super
easy
to
do
that.
You
know
with
what
we're
going
to
do
in
this
example.
A
But
if
we
were
using
a
hash
tree,
then
it's
basically,
you
know
impossible
to
do
that.
Do
that
voluntarily,
and
that
gives
you
a
sense
of
why
that
was
chosen
in
the
first
place
right.
Why
we're
choosing
to
Hash
keys
in
the
context
like
a
production,
you
know
database
in
ethereum
to
prevent,
like
dos
style
attacks
with
you
know,
just
putting
keys
are
always
in
the
same
spot.
A
A
What
it
is
that,
like
native
format,
that
this
tree
accepts
like
you
could
do
it
like,
we
could
have
an
implementation
that
just
basically
allows
you
to
input
anything,
but
it
would
still
be
converted
into
something
that's
natively
adjustable
by
the
tree,
so
the
tree
is
defined
as
a
like
hexary
hexiratory,
meaning
that
every
key
must
be
like
hexadecimal
for
it
to
be
like
conformed
to
the
data
structure.
If
we
didn't
have
small
values,
we'd
have
to
convert
it
anyways,
so
that
I
mean
so
that
it
maps
to
like
a
16
16
width
key.
A
A
Yeah
absolutely
yeah
so
and
also
like
rlp
encoding,
encodes
things
in
Exodus
mode,
so
we're
all
like
working
with
Native
like
hexadecimals.
Here
it
was
in
that
tree,
so
yeah,
if
we
like,
unlike
like
hashes
buffer,
is
going
to
be
it's
just
like
the
the
hexary
like
encoding
of
the
these
keys.
So
we
should
expect
these.
All
these
values
do
still
be
quite
similar,
and
that
is
what
we
see
here
so
right.
We
have
the
prefect
test.
Keys
come
in
for
all
of
them
and
test
key
is
basically
that
part.
A
A
There's
going
to
be
path,
number
three
and
path:
number
four
like
in
indexes
of
the
array,
then
it's
going
to
go
down
all
the
way
to
you
know
a
leaf
node,
because
it's
basically
the
end
of
the
path
for
that
part
of
the
path
and
then
41,
which
is
going
to
be
the
another
part.
For
that
you
know
other
path.
Does
that
make
sense
to
everybody.
B
C
A
Yeah
and
something
like
to
mention
here,
this
is
only
keys
right.
This
is
not
the
values
themselves
and
like
later
a
bit
in
the
tutorial.
We
see
how
you
know
the
hashes
of
every
like
parent
is
computed,
which
is
like
different.
You
know
from
this,
but
yeah.
So
if
we
had
like
also
a
a
key
address
T,
we
would
see
like
that.
That
would
be
only
74,
because
that,
like
lowercase
T
is
74
in
HEX,
and
we
would
see
a
branch
note
at
74..
A
A
A
C
A
Have
you
know
for
the
three
buffers,
then
we're
updating
with
all
those
three
keys,
so
we're
updating
the
tree
with
desk
key
test
key
zero
test,
key
a
which
all
have
the
same
prefix.
We
query
the
the
node
that
lives
at
Key
test
key,
which
is
the
the
common
prefix
for
all
those.
So
what
we
see
so
this
is
index.
A
A
A
C
A
Is
you
know,
index
4.,
and
then
we
have
nothing
all
the
way
down.
An
interesting
thing
is
we
also
have
a
value
already
here
at
address.
You
know:
that's
basically
test
key
and
hex,
so
a
branch
node
is
not
only
an
intermediary
node,
it
can
also
contain
values.
You
know
itself
in
the
case
of
keys,
which
would
always
have
the
same
length.
A
All
right
yeah,
so
that's
exactly
exactly
what
we
see
and
we
can.
We
can
take
the
value
of
that
node
and
see
if
we
can
like
the
value
here,
we
can
yeah,
we
can
parse
it
to
string.
Let
me
find
you
the
code,
so
it's
more
revelatory
of
what's
actually
going
on
so
yeah.
We
we
found
a
path.
We
found
a
node.
We
take
that
node.
We
look
at
the
value
at
that
specific
point
and
it
should
be
the
the
value
that
we've
put
at
test
key
now.
A
A
A
A
Think
we're
there's
a
bit
more
clarity
about
that,
after
so
I
think.
The
next
example
is
going
to
clarify
that
for
you
and
if
it
doesn't,
we
can
come
back
to
it
and
play
a
little
bit
more
with
it.
It
is
like
getting
like
nodes
in
how
they're
structured
and
how
they
they
operate
within
one
another.
Is
that
trickier
part
but
yeah
Branch,
nodes
and
extension
nodes,
which
are
you
know
somewhat
similar
in
structure
or
the
more
configured
part
of
that?
A
B
Yeah,
if
you
see
that
array
of
16
buffers
and
two
of
them
have
have
keys
in
them,
every
every
parent,
as
soon
as
that
branches
out
has
automatically
16
children,
regardless
of
how
many
values
are
actually
there
and
like
where
they
go.
If
there's
only
one,
then
we
can
compress
it
down
and
call
it
an
extension
node.
But
here
where
there's
like
two
in
that
array,
you
just
automatically
have
the
rest.
B
A
Yep
yeah
absolutely
so
this
clarifies
this
is
a
bit
like
in
in
the
other
example,
but
I
think
this
clarifies
you
know
what's
going
on,
so
it
might
look
a
bit
confusing
because
we're
using
very
similar
keys
and
values.
So
this
is
actually
the
values
and
they're
also
you
know
similar,
but
we're
not
really
concerned
with
this
similarity.
You
know
of
the
values
we're
concerned
with.
We
went
all
the
way
down
to
a
branch
node.
We
had
two
paths
that
were
defined
and
we
had
also
a
value
that
lived
there.
A
So
your
question
is
basically
well.
Why
is
it
an
array
that
lives
there
right?
So
the
area
contains
the
two
pieces
of
information
that
we
need
to.
Finally,
like
get
the
value
at
the
leaf
node.
So
this
is
pointing
you
know
to
an
old
and
it's
telling
you
well.
Actually
the
the
remaining
part
of
the
path
is
going
to
be
3
0.
and
then
the
remaining
part
of
the
path
is
going
to
be.
You
know
tree
one
and
then
the
value
you're
going
to
retrieve
at
that.
You
know
and
end
point
is
going
to
be.
A
You
know
that
whole
thing,
and
this
is
the
thing
that
if
you
parse
it
to
a
string,
you
would
get
like
test
value,
zero
and
test
value
a
and
it's
the
reason
why,
when
we're
trying
to
retrieve
you
know
the
values
here,
we
are,
you
know
taking
the
corresponding
indexes,
but
then
taking
the
first,
not
the
first
like
the
second,
but
index
number
one
this.
This
is
exactly
that's
the
value
now
we're
working
with
like
fairly
small
values,
so
the
values
are
directly
inside
of
the
tree.
C
A
A
A
So
we're
gonna
run
that
again
and
we're
gonna
all
that
we're
interested
in
at
the
moment.
For
you
know
this
example
you've
suggested.
Is
that
the
branch
note
like
what
does
it
look
like
at
that
point
and
then
it's
going
to
have
a
child.
That's
also
going
to
be
a
branched
out
right.
That's
what
we
would
you
know
expect.
A
All
right,
so
what
we
see
is
it's
actually
quite
similar
to
what
it
was
before,
but
instead
of
getting
an
array
we're
getting
a
larger
larger
buffer.
So
what
is
that
larger
browser
that
larger
buffer
is
now
there's
two
kinds
of
keys
in
Myrtle
Beach
trees?
That's
just
a
hash
that
points
to
a
different
node
right.
So
it's
not
about
you
know!
Path
path
is
still
like
path.
A
A
Okay,
so
if
we
look
at
those
keys,
you
have
a
common
path
that
is
test
key
zero
and
then
you
have
a
slightly
like
longer
path.
That
is
that's
q1.
So
what
we
should
expect
again
is
a
branch
node.
At
that
point,
it's
going
to
contain
the
value
itself
because
test
key
zero
is
actually
defined.
You
know
as
a
valid
key
that
contains
a
value,
but
it's
also
going
to
continue
at
one
and
now
obviously
we're
dealing
with
like
text
conversions
of
this.
A
So
it's
not
going
to
be
at
the
actual
index,
one
it's
going
to
be
at
a
different
index,
but
where
we
do
see
that
there's
exactly
one
valid,
you
know
branch
that
points
to
another
node
and
then
there's
an
actual
value
here
and
if
we
were
to
you
know,
convert
that
actual
value
to
a
string.
We
would
expect
to
get
back
whatever,
like
gar
badge,.
A
I
have
to
do
actually
branches
true,
and
then
this
would
be
the
remaining
part
of
the
path,
and
this
is
going
to
be
the
value.
So
if
we
do
the
string,
we
should
expect
to
retrieve
that
number
three.
You
know
thing
that
we
had
above,
let's
see
if
that
works
and
yeah
we're
getting
back.
You
know
number
three
well.
C
A
D
C
A
A
Okay,
I
know
what
that
is.
So
zero
is
actually
like.
It's
encoded,
as
like
two
hexary,
you
know
number
is
only
like
not
a
like
a
single
one,
so
we're
seeing
tree
because
that's
the
like
second
number
of
the
zero.
At
which
point
you
know,
we
have
a
value
like
directly
there,
but
we
have
we're
branching
out
so
I
think
if
I
created
like
another
one.
A
Yeah,
so
here
we're
getting
again
like
you
remember
how
we
were
getting
like
a
path
in
the
value
that
was
because
that
was
the
only
valued
F
now
we're
again
getting
a
hash
pointing
to
the
common
path
of
like
the
next
one.
It's
going
to
be
a
branch
note
again,
we
could,
you
know
again,
query
find
the
path
to
that.
A
Yeah
well
there's
a
value
like
if
I
query
test
key
O2,
there's
going
to
be
again
a
value
here,
but
yeah
I'm
not
actually
sure
why
we're
always
at
this
index
I'd
have
to
look
at
the
the
way
this
is
in
code.
I
suspect
it's
like
the
always.
The
the
latter
part
of
the
number
two
is
what's
used
here
instead
of
tree
itself.
A
C
A
C
A
Yeah,
it's
not
lining
up
perfectly
too
yeah
exactly
so.
If
we
wanted
to
do
like,
if
we
could
natively
like
compute,
you
know
buffers
and
hexes,
then
it
would
be
much
easier
to
see.
What's
going
on
now,
we're
using
like
human,
readable
keys,
so
I
mean
they're
broken
down
to
that
they're.
You
know
they're
coming
to
hex,
so
at
each
each
part
of
the
way
down
that
we
go.
It
doesn't
line
up
exactly
with
the
end
of
the
key.
A
B
A
Yeah
so
like
most
of
what
we've
done
so
far
has
been
like
working
on.
You
know
just
Miracle
Patricia
trees
themselves,
a
bit
further
down
in
that
tutorial,
like
I,
encourage
you
to
just
keep
going
at
home
and
ping
me
like
on
Discord
or
telegram
or
Twitter,
if
anything
like
doesn't
work
as
you'd
expect,
but
there
are
like
we're
working,
also
like
with
blocks
and
with
transactions
and
rlp
encoding,
which
is
quite
I,
feel
like
it's.
A
B
A
Yeah
we
have
a
massive
number
of
external
contributors,
who've
helped.
You
know
over
the
years
the
repo
is
fairly
old,
I,
think
it's
like
six
years
old
or
perhaps
like
even
more
than
that.
Sometimes
I'll
work
on
a
part
of
the
code
and
I'm.
Seeing
like
the
get
blame
like
five
five
years
ago,
or
something
like
that.
So
it's
really
like
a
pretty
old
repo.
We,
we
are
extremely
open
to
external
contributors.
A
Like
sometimes
we'll
have
people
come
up
and
just
help
out,
and
then
we
we,
you
know
we
include
them
in
the
the
team
like
not
in
the
formal
like
team
itself,
but
we
do
like
chat
with
them
and
are
always
happy
to
help
people.
You
know
help
the
project
we're
working
on
our
future
projects
are
we're
trying
to
improve
the
client
thinking.
At
the
moment
we
only
have
full
sync:
it's
super
slow
and
you
know
you
know
that
would
never
use
that
you
know
in
production.
Obviously
we're
trying
to
do.
A
B
A
Exactly
you
can
just
go
through
the
list
of
what
we've
implemented
and
just
you
know,
come
up.
You
know
with
easy
ones
that
you
want
to
implement
and
it's
a
good
way
to
get
started.
Learning
about
our
repo,
my
side,
I'm
working
more
on
R
D
for
vehicle
freeze
and
statelessness,
which
is
you
know,
sort
of
related
to
the
Merkle
tree
stuff.
A
E
I
feel
like
one
last
question:
I
had
a
friend
who
actually
worked
with
ethereum,
yes,
and
he
was
like
telling
me
about
like
he
also
used,
that
is
this
actually
interconnected,
just
for
a
3dmgs
or
it
can
be
like
interoperable
in
other,
like
I,
don't
know
proof
of
proof
of
History
like
Solana
or
something
like
that.
I
don't
know
if
I'm
just
telling
nonsense,
but
he
was
telling
me
like
he
used
that
for
our
RCP
support
kind
of
the
thing.
A
So
you
could
also
like
there
are
chains
like
Cela
I,
think,
which
has
like
different
rules
for
computing
transaction,
hashes
and
stuff,
like
that.
I'm
not
like
I
haven't
worked
with
that.
So
I'm
not
sure
how
easy
would
be
to
configure
it,
but
you
can
definitely
adjust
some
parts
of
the
code
and
provide
your
own
like
hashing,
algorithm
and
use
that
instead
same
thing
with
like
the
Myrtle
Beach
trees
thing
we've
been
working
with,
you
could
provide
your
own
hashing
algorithm.
It
defaults
to
caca,
but
I
mean
you
can
use
whatever
you
want.