►
Description
We got Ben Jones (https://twitter.com/ben_chain) from Plasma Group (https://twitter.com/plasma_group) for the Whiteboard Series this time speaking about the layer 2 technology built on top of Ethereum along with our Co-Founder, Alex Skidanov (https://twitter.com/AlexSkidanov)
This Whiteboard Session was taken during ETH Denver 2019 at the Enterprise Co-working Space in Denver, Colorado.
------- About Whiteboard Series ---------
The Whiteboard Series with NEAR is a set of video interviews with Founders who are building scalable solutions for Blockchain. We deep dive into their story, what they're developing and how it is helping the ecosystem.
Know more about Plasma Group here: https://plasma.group/
Download the video here: https://near.ai/b95f1
Follow the latest from NEAR Protocol on,
Discord: https://near.ai/discord
Medium: https://near.ai/medium
Twitter: https://near.ai/twitter
GitHub: https://near.ai/github
#WhiteboardSeries #PlasmaGroup
B
A
B
B
So
particularly
the
thing
that
we're
going
to
talk
about
is
we're
gonna,
assume
that
you
have
a
bit
of
knowledge
about
plasma
cash
and
we're
going
to
talk
about
the
like.
The
key
difference
in
this
particular
variant
that
we've
implemented
and
basically
what
it
comes
down
to,
is
an
attempt
to
solve
the
fixed
coin
denomination
problem
so
like,
if
you
remember
in
you
know,
maybe
in
in
in
the
plasma
cash
world,
you
have
these
unique
coins
which
have
a
unique
coin.
B
B
So
that's
really
really
cool
and
it's
great,
because
plasma
cash
solves
like
a
lot
of
problems
by
doing
this
over,
like
what's
called
like
plasma
MVP,
which
was
the
state
of
the
art
before
so
like
the
main
thing
that
it
solves,
is
like
no
mass
exits.
Okay,
so
very,
very
briefly
like
why
that's
important
this
is
just
important
like
with
cosmic
plasma.
Cash
generally
is
in
earlier
versions
of
plasma,
because
coins
weren't
defined
with
this
sort
of
non
fungible
ID.
B
So
there's
actually
really
not
a
ut
EXO's
in
the
plasma
cash
model.
There's
just
like
coin
transfers.
Okay
great.
So
that
was
really
really
good,
really
really
good
thing
that
plasma
cash
introduced
kind
of
bad
thing
that
introduced
was
these.
Coins
have
to
be
a
fixed
size
right
they're,
like
these
discrete
non
fungible
things.
B
Right
so
in
theory,
these
can
have
different
denominations
and
I
believe
there
are
some
cosmic
cash
implementations
that
do
have
different
nominations.
However,
for
example,
in
our
implementation,
we
do
still
have
a
notion
of
these
coins,
however
they're
all
fixed
denomination,
because
we
solve
this
sort
of
changing
denominations
in
a
different
way.
Okay,
so
what
is
it
that
we
actually
do
to
change
that?
It's
a
pretty
simple
change.
It
just
requires
like,
like
thinking
about
very
carefully,
to
make
sure
that
it's
still
secure
in
the
context
of
the
exit
game.
B
It's
a
very
simple
concept.
The
concept
is
simply
that
we
treat
transactions
over
ranges
of
coins
instead
of
particular
coins.
So
now,
here
now,
instead
of
sending
just
one
coin,
I
define
a
transaction
on
a
range
of
coins.
Okay-
and
this
is
one
transaction,
just
one
single
transaction-
and
with
this
transaction
we
may
update
all
of
these
coins
simultaneously,
but.
B
So
that's
a
very
good
question
and
we'll
hopefully
get
into
that
later.
The
essence
of
it
is,
is
you
have
to
do
that
separately
and
that's
gonna
involve
basically
atomic
swaps.
We've
explored
a
few
ways
to
do
it.
It
seems
like
the
best
is
probably
voluntary.
Atomic
swaps,
in
essence,
like
the
idea,
is
that
if
you
have
some
points
here
and
some
coins
up
here-
and
someone
has
some
points
here
and
some
coins
here,
it's
advantageous
for
both
of
you
to
align
all
of
those
coins
because
you
can
treat
them
and
one
exit
right.
B
Okay,
so
that's
that's!
The
sort
of
basic
transaction
format
is
just
you
want
to
do
transactions
over
range
of
coins?
Okay,
so
what
does
that
mean?
There's
a
lot
of
in
in
previous
discussions
on
plasma
plasma
cash
flow.
Some
people
have
definitely
talked
about
this
as
being
like
coin
splitting
or
coin
merging,
I
want
to
sort
of
try
to
break
down
that
idea.
B
With
this
with
this
video,
it's
really
not
about
coin
splitting
or
coin
merging,
it's
about
the
coins
being
very,
very,
very,
very
small,
so
maybe
a
three
coin
transfer
is
very
bad
to
transfer
example
in
this
case.
In
reality,
in
our
implementation
we
have
16
bytes
worth
of
coins,
and
so
that's
literally,
like
you
know,
bajillions
whatever
you
know
exactly
1
bajillion
possible
coins
and
you
might
transfer
like
thousands
of
coins,
so
you
can
so
basically
the
way
to
really
imagine
it
is
like
coins
on
a
number
line
right.
B
So
that's
literally
how
we
treat
these
transactions,
so
we
say,
like
you
know,
a
transaction
might
be
on
the
range
100
200
right
and
what
that
means
is
there's.
You
know
like
a
zero
here
and
then
out.
Here
is
a
hundred
and
then
out
here
is
200,
so
you
can
send
all
of
these
coins
right
in
just
one
go,
and
that
is
the
really
important
property
that
we
have.
So
it's
gonna
be
even
probably
in
practice
way
more
than
100.
B
Yes,
so
this,
so
what
you're
getting
at
is
like
going
to
be
probably
ended
up
being
the
meat
and
potatoes
in
this
video,
because
what
it
turns
out
to
be
it
turns
out
to
be
the
case
is
that
it's
very
tricky
to
define
a
transaction
format
in
this
way.
That
does
still
allows
you
to
have
like
clients,
okay,
so
maybe
we'll
like
erase
this,
and
let
go
over
a
little
bit
on
how
light
clients
work
in
plasma
cash
so,
along
with
mass
exits
yeah,
maybe
we'll
just
write
it
here.
B
First,
like
light
light
proofs,
we
call
them
like
proofs
white
proofs
are
a
really
really
really
important
thing
that
you
can
get
okay.
So
what
does
this
mean?
This
means
that,
to
ensure
that
your
particular
coins
are
safe
instead
of
downloading
an
entire
block,
you
may
download
just
one
branch
in
the
block
one
branch
in
this
Merkle
tree
and
that
allows
you
to
have
clients
which,
like
like
we
have
like.
B
If
you
go
to
burner
class
mode,
that
group,
you
can
do
full
verification
and
it's
like
a
full
full
node
on
these
light
proofs
on
your
phone
and
that's
because
they
only
have
to
download
one
branch.
So,
even
if
you
have
the
operator
running
this
massive
like
AWS
instance,
that's
like
a
bajillion
transactions
per
second,
you
can
verify
just
one
and
about
the
same
height,
and
so
it's
just
one
single
inclusion
and.
B
Block
right,
absolutely,
you
are
downloading
it
for
every
block.
You
absolutely
must
do
that.
Yeah,
okay,
so
the
light
Crips
were
the
other
big
thing
that
we
do
maybe
will
erase
this
and
talk
about
what
those
light
proofs
look
like
in
plasma
cash
and
why
they
work
and
that
will
sort
of
inform
why
the
range
based
version
is
a
little
tricky.
B
Okay,
so
I
love
my
Merkle
trees,
right,
aligned,
I,
don't
know
how
the
other
viewers
feel
about
this,
but
I
think
this
is
just
like
the
best
way
to
draw
Merkle
tree
so
I'm,
a
big
fan
as
I
say:
messing
it
up.
Okay,
so
this
is
like
we
can
think
of
this.
The
block
structure
in
plasma
cash
so
we're
just
gonna
review
how
plasma
cash
work
so
at
each
of
these
things,
are
these
non
fungible
coins
right.
So
we
have
like
Z
0
1
2
by
the
lot
right,
so
in
normal
plasma
cash.
B
The
way
that
you
do
a
transaction
on,
say,
coin,
to
write.
If
we
want
to
turn
that
into
like
you,
color
it
in
square
right,
the
way
that
you
do
that
is
in
the
pipe
block
at
high
10.
Whatever
in
this
block,
you
must
get
like
the
inclusion
proof
for
to
write
that
is,
like
you
know,
Alice
sending
to
Bob.
B
Let's
say
right:
ok,
so
at
this
exact
trace
right
along
the
Merkel
branch
right,
you
must
get
a
transaction
right
and
of
course,
if
there's
no
transaction
here,
then
you
know
things
that
have
been
computed
right.
So
very
simply
like.
That
is
the
light
proof
structure
and
the
whole
point
is
that,
because
a
transaction
on
point
2
is
only
valid
in
index
2,
then
you
don't
care
about
any
of
the
rest
of
the
structure.
This
whole
subtree.
You
can
ignore,
write
this
this
apart,
you
can
ignore.
You
don't
need
the
whole
thing.
B
So,
of
course
one
note
in
Merkel
incursion
proofs
right.
You
need
like
the
siblings
of
each
node
right.
So
in
reality
it's
going
to
be
like
you
know
this
guy
and
a
guy
here
and
a
guy
here
right,
corresponding
to
this
guy
and
this
guy
and
this
guy
right.
Yeah
and
that's
how
you
that's,
how
you
do
that,
but
effectively
you
can
think
of
it
as
just
like
this
branch
right.
That's
how
I
like
to
think
about
it?
Okay,
so
that
makes
sense.
That's
possible!
That's
plasma,
cash,
okay,
cool,
okay!
B
So
that's
wonderful!
We
don't
have
to
download
any
of
this
stuff.
It
doesn't
matter
at
all.
Now.
Here's
where
the
problem
comes
in
the
question
that
you
have
to
ask
yourself
is
what
branch,
what
index,
what
leaf
index
in
the
Merkle
tree
does
a
range
go
in
right
because
we
don't
want
it
to
go
in
every
coin.
That's
in
the
range
right!
So,
for
example,
if
we
had
a
transaction,
let's
say
we
want
to
do
a
transaction
over
coins,
two
three
and
four
right.
We
want
to
have
just
one
inclusion
proof
for
that.
B
If
we
had
one
at
point
two
and
at
coin
three
and
icon
for
that,
might
as
well
just
be
a
transaction
of
point
two
three
and
four,
so
we
need
some
way
to
describe
ranges.
So
we
need
something
right.
That
looks
like
something
like
this
branch
right
that
says:
okay,
actually,
it's
the
range
two
through
four
right:
that's
what
we
want
to
do
there.
A
B
A
B
B
B
It
doesn't
intertwine
histories
of
coins,
so
one
interesting
property
that
we'll
see
later
perhaps
is,
for
instance,
if
the
range
50
to
150
is
transaction,
transacted
right
and
then
I'd,
like
you,
know,
I'd
like
an
and
then
at
like
block
n
plus
1
right.
We
see
on
like
a
hundred
hundred
to
two
hundred
transacted
right
if
I
and
then
like,
let's
say,
like
I,
eventually
received
coins
like
one
hundred
through
150.
B
Okay
I
do
not
need
to
know
whether
or
not
the
owner
and
this
transaction
owned
coins.
50,
200
and
I
do
not
need
to
know
whether
the
the
the
person
transacting
coins
one
hundred
to
two
hundred
owned
coins,
one
fifty
to
one
hundred.
So
this
section
because
I'm
not
receiving
it.
This
section
I,
don't
care
about,
and
in
this
section,
I
don't
care
about.
So
how
so
like
the
real
worry
with
that,
so
sure
you're,
like
1
billion
coins
thing,
is
a
problem.
B
The
really
bad
thing
would
be
if
this
could
sort
of
like
fan
out
and
end
up,
like
everyone
downloads,
the
full
history.
So
we
do
at
least
have
this
property
maintained
that
you
only
care
about
the
transactions
and
the
owners
on
the
particular
range
of
the
transactions
they
care
about.
So
very
interestingly,
right
like
it
could
be
that
this
transaction
is
like
both
valid
and
invalid
at
the
same
time,
but.
B
And
the
way
that
that
is
manifested
in
practice
is
that
the
challenges
that
you
perform
are
on
a
particular
coin:
ID.
They
are
not
on
like
a
range.
So
when
you
like,
when
you
like,
submit
a
challenge
on
an
exit
and
exit
is
over
arranged-
and
you
say
I'm
shaoling
that
exit,
but
I
only
have
to
specify
one
invalid
coin
in
that
exit
to
invalidate
the
whole
thing,
and
so
I
just
specified
the
one
and
it
doesn't
matter
yeah.
B
Okay,
great,
so
we
kind
of
got
to
it
before
I.
Don't
you
know
I
think
maybe
we'll
go
to
a
better
example
than
points
2
through
4,
because
that's
kind
of
a
small
range
and
like
in
practice.
What
we
want
here
is
like
it's
like
much
larger
things.
So
let's
do
that.
Ok,
so
basically,
the
problem
that
we're
gonna
outline
here
is
like
is
effectively
a
double
spent
problem.
This
is
effectively
like
a
naive
attack
on
this
range
space
solution.
Okay,
so
let's
see
what
that
means:
okay,
I'm
just
gonna,
do
like
a
height.
B
Well
yeah,
let's
just
let's
just
do
it.
You
know
I
hate
to
tree.
Okay,
so
let's
say
right
here
we
have
a
transaction
on
100
200
and
by
the
notation
that
we
usually
use.
This
is
like
inclusive
and
next-closest,
but
whatever
okay,
okay,
so
let's
say
that
we
have
a
transaction
here
on
on
range
100
to
200.
Okay,
that's
great!
That's
what
we
want,
however,
anytime,
that
I
receive
a
transaction.
I
must
be
insured.
Not
only
did
I
am
receiving
a
transaction,
but
also
that
there
is
not
a
double
spend
included
at
the
same
height.
B
B
Let's
say
that
this
leaf
is
the
transaction
on
this
range
yep.
We
want
the
property,
so
maybe
maybe
wants
me
to
know
they're
one
of
the
one
of
the
huge
advantages
that
this
scheme
gives
you
over
over,
like
the
the
simpler
plasma
cash
right.
It
is
a
positive
cash
variance,
but
one
of
the
huge
improvements
is
that
the
height
of
the
tree
is
not
determined
by
the
number
of
coins.
B
B
It
it's
yes,
it's
very,
it's
very,
very
tricky,
you're,
totally
right
right.
So
what
is
the
problem?
So
obviously
the
attack
here
is,
if
I
download
this
branch
right.
Basically,
what
I
get
is
I
get
this
thing,
I
get
this
guy
and
I
get
this
guy
right
and
I'd
use
that
to
compute
the
route
and
verify
it
against
the
route
on
the
etherion
main
chain.
Okay,
so
what's
the
problem,
the
problem
is
that
I
haven't
downloaded
these
guys
right.
B
So
the
solution
that
we
will
impose
will
like
be
sorting
will
end
up
being
sorted.
Absolutely,
however,
like
it's
one
thing
to
note
here
that
you
don't
like,
you,
could
theoretically
implement
this
stuff
without
doing
any
sorting
environment,
and
you
just
would
lose
like
client
support,
which
is
very
interesting,
because
you
remember
that
before
we
wrote
the
2mass
exit,
the
mass
exit
problem
as
being
one
of
the
problems
with
older
versions
of
plasma
where,
if
an
invalid
exit
began,
everyone
else
had
to
get
out
those.
B
Those
older
versions
also
didn't
have
light
clients
like
plasma
cash,
sort
of
like
found
both
the
mass
exit
solution
and
like
clients,
and
one
go.
If
we
do
this
range
thing,
interestingly,
we
can
actually
get
rid
of
mass
exits,
but
not
have
support
for
light
clients.
So
if
you
just
were
required
to
download
all
of
these
leaves
and
make
sure
that
there
wasn't
a
100
200
transaction
there,
that
would
be.
That
would
actually
still
be
better
because
it
would
solve
the
math
eggs
problem.
B
So
the
beautiful
solution
is
that
we
need
some
way
for
just
the
information
in
this
branch.
We
need
a
way
for
just
that
information
to
be
sufficient
to
prove
to
the
white
client
that
no
other
such
valid
transaction
on
the
same
range
on
an
intersecting
arrangement
and
an
intersecting
range
exactly
right
exists
over
here,
right
and
so
effectively.
What
we're
gonna
do
is
we're
gonna
do
like
a
like,
like
a
branch
validity,
condition
right,
so
we
already
had
one
of
these
in
vanilla,
plasma
cash.
B
Okay,
the
bridge
validity
condition
is
very,
very,
very
simple:
for
a
transaction
on
range,
three
for
a
transaction
of
coin,
three,
the
valid
branch
is
branch,
three
right.
That
was
a
very,
very,
very
simple
ability
condition
and
that's
the
basis
for
like
crime
proofs.
So
all
we
need
to
do
is
do
a
blanch
loaded
condition
for
ranges
right,
that's
what
we
need
to
figure
out
right
and
like
that
really
ends
up
being
like
the
key
problem
that
you
have
to
solve
with
this.
Okay,
so
does
that
make
sense
questions.
B
Great
okay,
so
the
trick
is,
we
no
longer
are
doing
a
simple
Merkel
tree,
okay,
so
there's
actually
so,
interestingly
enough,
shout
out
to
Dan
Robinson,
who
came
up
with
an
incredibly
beautiful,
even
more
elegant
solution
to
this
than
we
previously
had.
So
in,
like
lots
of
nice
research
posts
and
stuff,
there's
been
a
more
contrived
answer
called
the
Merkel
some
tree.
B
Okay,
what
we're
going
to
go
over
today
is
something
that
actually
I,
don't
think
has
been
written
up
to
date,
but
it
is
a
merkel
index
tree
and
it's
a
little
more
intuitive
way
to
think
about
it,
actually,
a
lot
a
lot,
a
lot
more
intuitive
way.
It's
like
it's
very,
very
beautiful
shout-out
to
Dan
he's
amazing,
okay,
but
the
basic
idea
in
all
this
is
that
a
Merkel
tree,
just
ain't
gonna
cut
it.
We
need
to
add
something
into
the
Merkel
tree.
Something
extra
does
it
allow
us
to
prevent
this
now.
B
I
haven't
really
explored
thoughts
either,
but
you
might
even
imagine
that
you
know
you
could
do
some
RSA
accumulator
magic,
all
the
fun
plasma
memes
right,
but
the
best
one
would
be
to
just
embed
it
in
the
block
structure
itself.
Okay,
so
that's
we're.
Gonna
do
okay!
So
like
what
does
that
mean
in
practice
like
it's
like
to
define
like
an
arbitrary
binary
tree
right
like
what
like,
like
the
way
that
you
define?
That
is
simply
like
the
parent
function,
right
of
left
and
right
right.
B
So
this
is
the
left
sibling
and
the
right
sibling,
whoops,
I'm,
saying
sibling
right
right.
So
in
a
Merkel
tree
right,
a
Merkel
tree
is
a
binary
tree
where
a
parent
equals
hash
right,
very,
very,
very,
very,
very
simple.
Okay,
so
we
are
going
to
make
so
that
so
that's
like
Merkel
right,
like
this
is
like
vanilla,
Merkel
right.
What
we
are
going
to
define
is
something
called
a
Merkel
index
tree.
B
Okay,
so
maybe
one
other
thing
to
note
here
is
that
we
would
have
to
define
like
what
are
the
what
is
the
set
that
left
and
right
belong
to
as
well.
Like
you
know,
sort
of
math
sense
so
like
in
practice,
we
would
also
have
to
say
that
the
left
and
right
are
these
32
byte
hashes,
that
the
parent
resolves
to
okay.
So
now
we're
gonna
define
a
new
parent
function
and
we're
going
to
define
new
data
elements
for
the
left
and
right
so
before
maybe
I'll,
just
maybe
I'll.
B
Just
like
continue
the
like
the
vanilla,
Merkel
tree
thing
here
right
and
we
will
save
vanilla,
so
there's
been
no
Merkel
tree
has
a
parent,
that's
just
a
hash
function
right
and
the
elements
right
like
the
the
nodes
will
call
them
the
nodes
right
like
every
one
of
these
things
right
is
a
node
in
the
Merkel
tree,
so
the
nodes
are
bytes,
32,
hashes,
okay,
very,
very
simple:
most
hash
functions
return
to
32
bytes,
so
the
hash
function
is
like.
The
only
thing
that
we
need
is
that
the
parent
emptied
resolves
to
a
node.
B
So
it
requires
that
the
hash
function
resolve
to
32
byte
hashes,
and
then
we
have
the
effect
that
we
want
that.
Do
you
you
know
we
can
build
the
whole
binary,
recursive
beautiful
thing.
With
this
data
structure,
okay,
so
now
we've
got
to
update
the
nodes
and
we've
got
to
update
the
parent.
Okay
great.
So
let's
do
this
we're
going
to
call
this
index
index
merkel
some
tree
okay
and
so
as
a
spoiler
alert
like
the
reason
we're
gonna
call.
B
This
index
is
because
it's
gonna
refer
to
the
index
of
some
coins,
so
it's
actually
gonna
refer
to
some
coins
as
we
go
up
the
tree
and
maybe
that'll
begin
to
start
making,
you
think
about
what
this
actually
does.
So
very
simply
a
now
a
node
equal
is
a
tuple.
It
is
a
bytes
32
hash
and
it
is
a
coin
ID.
B
B
B
The
parent
function
is
the
hash
of
the
nodes.
So,
like
left
and
right
note
that
this
includes
the
cornea
is
the
coin
IDs
as
well
right
so
you're
committing
both
to
this
hash
in
this
hash
so
like
in
practice.
What
you
do
is
you
take
the
left,
bytes
32,
concatenate,
the
left
coin,
ID
concatenate,
the
right,
bytes,
32,
concatenate,
the
right
coin,
ID
right,
and
so
that's
all
we're
gonna
Express
with
that
and
then
believe
it
or
not.
It's
simply
the
left,
that's
going
a
coin
ID.
This
is
why
it's
a
it's
much
more
beautiful!
B
This
part,
it's
very,
very
beautiful.
Before
we
were
doing
an
edition
of
the
coin
IDs
effectively,
it
was
very,
very
messy.
This
is
a
lot
cleaner,
yep,
so
that
says,
left
coin
ID
there.
So,
let's
give
me
the
property
so
believe
it
or
not.
That's
gonna
give
us
backlight
clients,
super
cool,
super
cool.
Let's.
B
B
B
Very
very
interesting
question,
so,
interestingly,
the
validity
condition
will
enforce
a
sorting,
so,
namely
the
property
that
we
must
have.
Is
that
as
you
go
up
the
tree,
the
coin
IDs
for
the
things
that
are
being
merged
in
from
higher
and
higher
up,
must
be
greater
than
the
previous
step
down.
So
as
you
work
your
way
back
up
the
Merkle
tree,
the
coin
ids
that
you're
pushing
in
must
be
to
the
right
of
the
coin
ids
on
the
left,
and
they
must
be
like
increasingly
to
the
right
and
that's
gonna,
end
up
being
the
property.
B
Against
transactions
yeah
exactly
so
we're
get
one
thing
that
we're
gonna
need
to
figure
out.
How
to
do
is
what
we
call
like
parsing,
the
the
the
transactions
into
the
bottom
nodes
like
turning
the
leaves
into
the
bottom
level
of
the
tree,
and
it's
and
it's
and
it's
and
it's
actually
going
to
end
up
being
the
effectively
the
left
of
the
the
left
of
the
range
is
what
it's
uniting
as
well.
We
had
a
much
more
complex
thing
where
you
had
to
subtract
stuff,
Oh
point
ID,
so
beautiful,
it's
so
beautiful,
alright,
so
example.
B
Okay,
so
let's
say
maybe
0
10,
let's
say
10
50.
Let's
say
you
know
whatever
50
100
and
then
let's
say
like
100,
500:
okay,
let's
go
with
that
and
maybe
I'll
erase
it
very
simple,
Markel
tree
here.
Okay,
so
we're
just
gonna.
Do
four
we'll
just
do
four!
For
now?
Okay,
it's
maybe
hopefully
won't
be
to
degenerate.
We
might
want
to
add
more
but
and.
B
So
this
is
a
valid
example,
is
there's
no
intersections
and
what
we're
gonna
do
later,
like
spoiler
alert
we're
gonna,
try
to
change
one
of
these
to
an
overlapping
range
and
we're
gonna
show
why
that
breaks
the
validity
condition.
So
that's
what
I'm
doing
yeah
so
that's
in
effect.
The
idea
is
that
if
this
has
ability
condition,
this
can't
also
have
a
validity
condition.
It's
like
one
or
the
other
right,
absolutely,
okay,
cool!
So
let's,
let's
get
our!
Let's
get
our
handy-dandy
parent
minds,
okay,
cool!
B
So
this
aren't
gonna
end
to
be
pretty
easy.
I'm
not
going
to
write
the
hashes
up
here
right
because
that's
like
sort
of
just
like
you
know.
We.
We
assume
that
we're
committing
things.
It's
a
Merkle
tree,
whatever
right,
so
the
base
property.
Is
that
you
literally
it's
it's
so
simple!
Honestly,
you
take
the
leftmost
thing
in
in
each
of
the
ranges.
So
here
we're
gonna
get
0
here.
We're
gonna
get
ten
here,
we're
gonna
get
50
here,
we're
gonna
get
100
okay,
so
that
is
our.
B
That
is
our
thing
and
like
notably,
this
was
like
an
actual
steps
that
we
just
did
here.
Where
we
took
this
transaction,
which
is
also
going
to
have
like
you
know
in
a
sender
and
recipient
Alice,
Bob
blah
blah
blah,
we
turn
that
into
just
the
hash
of
that
thing
and
we
also
pull
out
the
start
right
so
like
each
of
these
are
really
like.
We
implicitly
did
a
function
here
to
turn
these
from
transactions
into
hashes
with
an
index,
but
we're
just
gonna
write
the
index
cuz,
that's
the
important
part!
B
Okay,
so
it's
very
simple
parent
function
is
equal,
the
hash
of
both
of
them
right,
we're
gonna,
execute
the
hash
and
the
left
coin.
Id!
Okay!
So
here
where
you
take
the
hash,
it's
the
left
so
zero!
Here
we
take
the
hat
that
you
know
we
take
the
hash,
take
the
left,
so
it's
50
right-
and
here
you
have
the
hash.
It's
your
right.
It's
always
going
to
end
up
being
zero
at
the
top
okay
right.
B
So
what
is
the
validity
condition?
So
the
validity
condition
states
that
that
this
zero
I'm
able
this
like
pointed
out
and
say
in
words:
it's
like
a
little
tricky
to
write.
This
0
must
be
greater
than
or
equal
to.
This
0
and
this
0
and
this
0
right
effectively
like
the
the
transactions
range.
It
must
be
within
the
bound
of
this
0
right.
The
other
property
is
that
this
10
must
be
less
than
or
equal
to
this
1,
and
it
must
also
be
less
than
equal
to
this
1.
B
B
So,
notably,
when
you
get
this
50,
you
never
actually
see
this
10.
So,
let's
maybe
this
was
simply.
This
is
a
better
case
actually
right.
So
let's
look
at
this
50
when
you
download
this
Merkel
branch.
What
do
you
get
you
get
this
and
you
get
this
right
right,
and
so
you
know
it'll
probably
useful
to
do
like
an
S
size,
8
tree,
because
this
is
you
know,
there's
not
like
a
lot
of
things
going
on
here,
but
it's
a
good
simple
example.
B
A
B
So
that's
so
this
is
the
beauty.
Okay.
So
that's
exactly
right.
What
we
want
to
do
is
try
to
break
this
thing
right,
okay,
so
what
you're
saying
is
a
great
way
to
break
it
like
the
way
that
you
break
things?
Is
you
make
intersecting
ranges?
The
trick
is,
though,
oh
that
only
really
breaks
it
if
both
of
the
ranges
pass
the
validity
condition.
B
So
let's
change
this
to
55,
like
you
said,
and
let's
do
the
check
so
I'm
going
to
I'm
gonna
erase
these
circles,
because
we're
gonna
get
some
new
circles
for
this
inclusion
proof
and
it's
probably
worth
probably
worth
circling
them.
So
hopefully
that
is
very
aesthetic
right.
Okay,
so
we're
gonna
do
this
one!
So
what
do
we
get?
We
get
this
one.
We
get
this
one
right,
okay,
so
check
it
out.
We
get
this.
We
get
this
zero.
B
We
see
the
you
know
blah
blah
blah,
so
the
ten
is
good
right,
because
the
pan
is
greater
than
the
zero,
its
greater
than
the
ten
here
right.
Yes,
so
we
also
did
get
this
one
actually,
so
the
10
is
greater
than
here
right
and
then,
like
the
you
know,
this
is
a
valid
left
index
tree
where
this
zero
isn't.
You
know
indeed
goes
up
right
right,
so
the
10,
the
10
checks
out.
However,
the
55
does
not
check
out.
Why
is
that?
The
reason
is
because
this
55
is
greater
than
this
50,
but.
A
A
As
a
light
client
right
so,
let's
say
I'm
a
light.
Client
and
I
receive
this
transaction
right.
So
someone
says
I'm
sending
you
range
from
50
to
100
and
it's
going
to
be
in
the
Merkel
tree.
It's
going
to
be
at
the
position
here,
and
so
what
I
assumed?
What
I'm
going
to
do
is
I'm
going
to
get
this
position
and
then
load
it
from
like
all
the
way
from
the
past,
like
for
in
every
block,
I
will
download
this
miracle
path
right
with
indexes.
B
B
A
B
B
B
B
This
isn't
going
to
be
the
case
right,
there's
gonna
be
big
ranges
of
coins
where
the
owner
is
doesn't
want
to
spend
the
coins,
and
so
there's
going
to
be
gaps,
and
so
the
next
example
that
we'll
look
at
will
increase
the
height
of
this
tree
will
double
the
height
or
increment
the
height,
and
we
will
make
some
gaps
and
then
that
may
be.
That
will
be
pretty
informative.
B
B
Okay,
am
I
maybe
I'm
gonna
start
I'm
gonna
start
down
a
little
lower
and
bigger.
So
I,
don't
kick
myself
in
the
foot
here?
Okay,
so
let's
go
here,
we'll
say:
0
10,
okay,
now
we'll
go
here,
we'll
say:
let's
make
a
gap,
so
we'll
say:
20,
30,
okay
and
my
space
inside
right,
3,
4,
5!
Ok,
I
need
to
do
this
smaller,
honestly,
don't
I,
so
I'm
just
gonna
do
that?
Okay!
So
let's
go
2030.
B
Let's
do
you
know
whatever
I
mean
this
can
be
you
know,
literally
whatever
we
want
so
50
hundred
right.
Let's
make
it
thousand
two
thousand,
maybe
maybe
I'm
gonna
regret
having
to
read
one
check
two
zeros
up
there,
but
oh
well
something
invalid.
Maybe
oh
that's
a
good
idea
yeah!
So
why
don't
we
do?
Why
don't
we
do
7.
B
B
Right
exactly
right,
exactly
right!
Yes,
it's!
Yes,
exactly!
Okay!
So
we've
only
drawn
eight
transactions
here,
so
it's
not
a
full
tree,
but
maybe
I
will
do
one
more.
So
we
have
this
invalid
75-100
here
and
then
I'll
maybe
give
that
a
sibling
and
we'll
call
this,
like
you
know
back
to
a
valid
thing.
So
we'll
call
it
like.
You
know
two
thousand
three
thousand
okay,
so
take
there's
gonna
be
some
extras
here.
We're
just
gonna
draw
like
a
truncated
version,
sort
of
ignore
the
subtree
okay.
So
let's
do
that
OOP!
B
Here
we
go
all
right.
How
are
my
Merkle
tree
skills
we're
doing?
Okay,
we're
doing?
Okay?
Of
course
this
is
going
to
have
a
like
that
we
haven't
seen,
but
imagine
it's
there.
It's
not
gonna
matter
for
our
examples
and
then,
of
course
we
have
the
root.
Okay.
How
does
this
look?
Does
this
look?
Fine?
Yes,
yes,
we
have
drawn
a
Merkle
tree.
Wonderful!
Well,
we've
drawn
a
binary
tree,
I!
Suppose,
okay,
so
why
don't
we
consider
some
of
these
some
of
these
gaps
over
here?
B
A
B
A
The
time
of
militias
operator
I'm
colluding
actually
on
this
example
right
as
I
compute,
the
merkel
root,
then
the
murder,
the
miracle
tree.
I
will
just
say
that
the
coin
ID
here
is
2,000,
which
is
incorrect,
which
is
a
lie
which
is
a
lie,
but
but
I
will
compute
the
proof
all
the
way
up
right.
So
it's
also
going
to
be
2,000
here
and
then
for
someone
over
here
I
will
say:
oh
you
know
what
your
proof
is.
Your
proof
is
this
node
right,
yeah,
it's
I!
A
B
The
trick,
well
that
that's
that's
the
beauty
of
it,
because
this
says
mm
you
are
guaranteed,
because
when
it
is
because
when
this,
because
when
this
person
tries
to
exit
right,
they'll,
they'll
they'll
they'll
try
to
submit
that
proof
to
the
smart
contract
in
smart
country,
okay,
75,
Shore,
2,000
Shore.
Now
we
want
the
left
node,
they
won't
get
a
75
there's
75
years,
2000,
oh
go,
and
it's
not
going
to
work.
So
it's
it's
an
invalidity,
it's
a
validity
condition
and
then
in
practice
like
where
it
is
in
our
code.
B
Right
now,
for
example,
is
what
what
is
going
to
happen
is
the
route
hash
is
not
going
to
be
the
same
route
hash
that
you
end
up
with
as
the
root
hash
of
the
as
root
hash.
That
was
submitted
right
because
the
smart
contracts,
as
it's
simulating,
the
the
inclusion
proof,
is
going
to
put
a
75
here
and
because
the
mm
was
put
here,
the
entire
root
hash
was
going
to
be
wrong,
and
so
it
won't
be
used,
and
so
that's
the
beauty
of
it.
B
As
soon
as
this
guy
sees
this
mm,
he
knows
that
even
if
this
range
does
intersect
this
stuff,
it's
going
to
be
invalidated,
it's
not
gonna
be
okay,
and
so
he
doesn't
care.
What's
there,
the
operator
can
screw
up
other
portions
of
the
coin,
but
he
knows
his
is
good
of
the
corn
range
yep,
okay
yeah!
So
maybe
we'll
just
finish
this
tree.
So
we
go
to
zero
5000.
It's
always
zero
at
the
top
mm
mm
yeah.
So
this
is
an
interesting
case
here.
B
B
B
You're
absolutely
right:
yeah
yeah
you're,
you
totally
right
yeah.
So
particularly
the
coins
like
in
the
range
like
50
to
75
are
sort
of
like
these
proofs
they're
like
I,
don't
know
what
to
do
with
this.
It's
sort
of
invalid
right
and
that's
like
interview,
a
problem
for
them
hundred
percent
yeah,
but
you're
totally
right
this
guy.
This
guy
will
be
totally
pleased
and
these
maybe
pleased
as
well
yeah.
That's
right!
That's
right!
Yeah!
Okay!
B
So
what
do
we
want
to
do
with
this?
Okay?
So
maybe
we
can
walk
through
like
a
simple
check.
So
let's
walk,
let's
walk
through
the
check
of
this
guy
I'm
sure
that
it's
right
and
then
we'll
walk
through
the
checks
of
these
guys,
I'm
sure
that
this
screwed
things
up.
Okay.
So
let's,
let's
do.
Let's
do
this
check?
So
let's
call
us:
let's
do
a
triangle?
Okay,
and
so
what
is
this
inclusion
proof
get?
This
gets
this
guy
gets
this
guy
gets
this
guy
and
that's
it
right.
The
wonders
of
vlogs!
B
So,
ok,
so
this
guy!
He
gets
this
this
and
this.
So
what
are
the
checks
he
needs
to
perform?
The
1
check.
They
need
to
perform
is
that
for
the
left
guy,
the
the
his
his
start
of
his
transaction
right
is
like
is
like
greater.
You
know
it's
greater
than
or
equal
to
all
of
like
the
indices
going
up.
So,
oh,
and
actually
he
also
gets
this
one
as
well.
It
is
required
to
give
this
thing
that
this
is
parse
to
like
take
it
back.
Actually
it
can
be.
It
can
be
implicitly
inferred.
B
Okay,
yeah,
you
don't
yeah
it
just.
It
calculates
it
from
the
20
right
there,
okay,
so
the
20
he
looks
here
he
goes.
Okay,
great
is
my
is
my.
Is
my
0
less
than
my
20?
Yes,
okay,
we're
good
sweet.
Does
this
check
out
through
the
left
thing?
Yes,
we're
good!
Okay!
Now
he
goes
through
this
level.
He
goes.
Okay
is
my
30
less
than
or
equal
to
my
50.
He
goes
yes,
oh
my
gosh
great.
It
is
so
we
can
go
here.
Is
this
zero
the
same
as
the
zero
here?
Yes,
it
is.
B
Does
the
hash
check
out,
obviously
to
now
he
gets
this
guy?
He
goes.
Okay.
We've
got
a
75
so
for
the
75
he
needs
to
be
sure
that
this
75
is
greater
than
this
previous
50.
So
he
goes.
Okay,
75
is
getting
the
50.
Oh
my
gosh,
we're
almost
there
75
and
zero.
Does
it
go
to
zero?
Yes,
we're
good,
okay!
So
the
triangle
transaction
in
this
tree
that
we've
constructed
the
triangle
is
like
totally
happy
he's
a
happy
cat
can
keep
on
transacting.
B
Do
it
every
one
right,
but
of
course
we
did
insert
this
sneaky
little
guy
here,
so
we're
gonna
see
how
it
breaks
okay.
So
let's
watch
how
it
breaks.
Okay.
So
let's
do
maybe
a
square
for
the
50
to
100
note
that
this
is
going
to
be
the
one
that
really
really
breaks,
because
there's
a
75
to
100
there
right
as
well.
Okay,
so
what
the
square
get
the
square
gets
this
guy.
He
gets
this
guy
and
this
guy
as
well
right,
so
very,
very
quit
somewhat
similar
okay.
So
what
does
he
do
so?
B
He
sees
okay
I've
got
50
to
100.
What
did
my
50
turn
into
a
50?
Yes,
we're
good.
Did
this
50
turn
into
this
50?
Yes,
we're
good
50s,
you
know
less
than
equal
to
50,
so
we're
okay.
Now
he
goes
to
his
100.
He
goes
okay,
I
got
this
guy
is
my
100
greater
than
or
equal
to
less
than
or
equal
to
my
1,000?
Yes,
oh
my
gosh.
It
is
wonderful!
Okay,
so
we
go
up
here.
Okay,
we
got
the
zero
here.
Is
the
zero
less
than
the
50?
B
Yes,
is
the
zero
the
one
propagated
up?
Yes,
okay,
great
now
he
gets
this
one.
He
goes.
Okay
is
our
75
greater
than
or
equal
to
our
a
thousand,
because,
oh
no
we're
not
so
we
see
here
that
this
is
like
the
breaking
point
for
this
inclusion
proof
because
of
this
overlap
right.
That
is
what
ends
up
happening
so
like
we
have,
because
75
is
not
greater
than
a
thousand,
because
that's
not
true,
then
this
would
be
an
invalid
block
and
it's
an
invalid
block
and
this
person
must
stop
so
any
transactions
and
exit
there.
B
B
B
50
so
let's
say
that
I
own
range,
30
to
50
and
I
want
to
be
ensured
that
my
money
was
not
spent.
What
do
I
need
for
that
believe
it
or
not.
It
is
just
one
branch
and
that
is
really
really
really
awesome.
So,
as
a
matter
of
fact,
this
triangle
branch-
both
fruit-
is
what
we
call
a
an
a
non-inclusion
proof
for
coins
3250,
just
as
much
is
an
inclusion
proof
for
coins
20
to
30,
okay.
So,
let's,
let's
think
about
that,
why
that
is
okay.
B
A
B
Yeah
sure,
no!
Oh!
No!
No!
No,
because
it's
okay
for
him,
it's
okay
for
him
yeah!
It
will
work,
Yeah
right,
okay,
yeah,
wonderful,
so,
okay,
so
let's
say:
I
didn't
transact
coins
30
to
50
right.
What
do
I
see?
What
from
this?
Well
they're.
Really.
The
only
thing
that
I
care
about
is
I,
see
that
this
that
this
30
is,
like
you
know,
less
than
or
equal
to
my
30,
that
you
know
that
I
own
right
so
like
because
this
transaction
ends
at
30.
B
I
know
that
this
transaction
can
only
talk
about
twenty
to
thirty
right
so
at
work,
so
we're
so
we're
good
on
what
this
guy
can
do
right
and
then
we
see
obviously
the
zero
and
the
zero
and
the
zero.
It's
like
a
valid
branch
like
that's
obviously
important
and
the
other
thing
we
see
is
we
see
this
50
right
here
and
the
cool
thing
about
this
50
is.
B
B
B
A
So
I
think
my
the
most
interesting
question
that
I
have
right
now
is
so,
let's
say:
I'm
I'm,
a
merchant
I'm,
a
coffee
shop
and
I
saw
a
lot
of
coffee
during
the
day.
So
during
the
day,
I
got
a
lot
of,
and
let's
say
lowest,
elimination
is
five
dollars
and
happens
to
be
exactly
the
price
of
a
latte,
and
so
I
got
a
lot
of
them.
How
do
I
defragment?
How
do
I,
how
do
I
bring
all
of
them
together
to
send
all
of
them
to
my
cold
storage,
so
I.
B
Will
so
I
will
push
back
on?
One
thing
you
just
said,
which
is
let's
say
the
lowest.
A
nomination
is
five,
so
in
this
model
even
means
this
15
or
100
is
way
smaller
numbers
than
we
deal
with
in
practice.
So
like
we
actually
in
code
like
in
code
way
into
our
into
our
coin,
IDs,
because
literally
like
the
size
of
like
the
the
what
these
numbers
are
defined
the
size
not
like
the
amount
of
transactions
or
anything
so
in
reality,
like
the
all
of
these
constructions.
B
Allow
you
to
do
like
you
know
many
like
a
millionth
of
a
cent
pretty
much
at
the
same
price
as
if
the
minimum
denomination
was
five
anyway.
Your
point
is
still
totally
valid
right.
So
the
question
is
so
high.
Maybe
there's
like
a
good
way
to
visualize
this
okay,
so
like
the
way
that
I
sort
of
visualize
the
plasma
cash
flow
construction
is
I.
Imagine
like
a
number
line
and
I
imagine
different
colors
on
differ
segments
of
that
number
line
and.
B
Is
the
owner
exactly
yeah,
so
we
might
have
liked
it.
You
know
like
a
like
a
dark
purple
section
here
and
then
a
light
section
here
and
then,
like
a
Dayak,
you
know
a
diagonal
thing.
Obviously
we
don't
have
a
lot
of
Karluk
colors,
so
this
is
like
the
best
we
can
do
right,
but
but
you
might
have
something
like
this
right
and
so
absolutely
the
the
thing
that
you
need
to
solve
in
this
in
in
this
scheme
is
even
though
we've
broken
down
the
denominations.
B
The
coins
are
not
adjacent,
and
that
means
that
they
need
to
be
exited
separately
and
that's
bad
so,
like
imagine
that
this
guy,
so
imagine
the
coffee,
the
cup.
Let's
say
the
coffee
shop
owner
is
like
a
squiggly
squiggly
right.
So
imagine
that,
like
this
is
block
N
and
like
a
ten
plus
one
like
a
bunch
of
people,
buy
coffee
right.
So
now
so
now,
like
this
guy
bought
some
squiggly
coffee
here
and
the
rest
is
still
his
right
and
this
guy
bought
some
scooted
coffee
here,
but
the
rest
is
still
his.
B
It's
like
it's
changed
right,
almost
right.
The
next
guy
bought
is
who
they
coffee
here-
Oh
God,
I
kind
of
did,
squeal
spice
here,
we'll
crosshatch.
There
we
go
and
then-
and
then
this
guy
still
has
his
leftovers
here
right
and
similarly,
this
guy
did
a
bit
here
so
azen's
leftovers
there
right.
So
the
problem
is
that
now
the
coffee
owner
the
squiggly
guy
owns
this-
is
this
oops
this
and
owns
this
right?
B
In
theory,
there's
something
called
like
a
mass
exit
or
like,
like
the
like.
How
do
I
want
to
say
this?
Okay,
so
like
in
theory,
what
we
need
to
do
at
the
smart
contract
level
is
support
effectively
like
arbitrary
compression
algorithms,
on
the
ranges
of
coins
that
you're
exiting
so
like.
We
have
a
very
simple
compression
algorithm,
in
effect
on
our
in
our
current
exit
game,
which
is
start
and
end
right.
You
know
when
you
exit
coins
50
to
100
right
in
plasma
cash.
B
What
you
do
is
you
say,
I
magazine
coin
50
on
I'm
51
on
exiting
20,
50,
I'm,
Isaac,
153
right,
and
so
we
technically
like
our
exits,
are
like
a
compression
of
that
right,
which
is
very,
very
simple.
It's
just
the
start
and
the
end
right
so
very,
very
like
basic.
Like
compression
you,
don't
the
structure
of
these
coin.
Ids
is
all
being
adjacent,
so
one
thing
that
we
want
might
want
to
do
is
like
provide
the
coffee
store
owner.
B
The
ability
to
begin
an
exit
in
which
they
sort
of
describe
these
intervals
in
like
a
compress
useful
way.
So,
like
the
simplest
way,
might
be
that
the
coffee
owner
says
well.
My
coffees
are
all
$5,
so
I'm
exiting
a
bunch
of
coffee
payments
and
they're
each
five
dollars
long.
So,
instead
of
giving
you
the
start
in
the
end,
I'm
just
going
to
give
you
the
start
right,
and
so
then
they
just
give
this
start.
B
And
this
start-
and
this
start-
and
this
start
right
and
buy
the
thing
about
a
boom
they've,
they
cut
it
in
half
because
it
just
starts
and
one
length
instead
of
start
and
start
and
start
and
start
in
it's
like
already
that's
an
improvement
right
and
in
general.
What
we're
talking
about
here
is
like
compression
right
and
there's,
like
massive
amounts
of
you
know
like
it's
lossless
compression,
specifically
right,
but.
A
A
What
my
exit
transaction
is
tiny
now
in
what
I've
just
described,
I'm
suggesting
so
then
your
turns
are
in
what
you
just
wrapped
you
effectively
reducing
the
size
by
a
factor
of
two
right,
yeah,
well,
I'm,
saying
what,
if
I,
just
because
for
each
of
those
tokens
right,
the
owner
is
known
like
the
public
key
of
the
owner
is
known
right.
That.
B
Is
true
for
like
for
like
people
with
availability
on
the
plasma
chain
from
the
cart
smart,
conscious,
respected,
the
smart
contract
has
no
idea
so
when
use
whenever
you
submit
an
exit
to
the
smart
contract,
you
need
to
specify
this
is
the
exact
set
of
coins
that
are
owned
right
now
and
like
you
need
to
accept
challenges
if
they
disprove
that
this
is
the
coins
that
are
owned
by
whom
right.
So
it's
not
just
a
simplest
thing:
I'm
gonna
exit
all
the
coins
that
are
owned
by
me.
B
It's
my
contract
needs
to
know
how
many
coins
those
are
and
and
very
importantly,
which
coins
they're
like
very,
very
critically.
Okay,
so
I
just
subscribed
one
weird
like
sort
of
compression
thing
and,
like
you
know,
to
the
extent
that
we
can
do
on
chained
compression
like
we're
gonna
strive
to
have
things
like
that,
and
this
is
like
a
general
class
of
what
what
has
been
previously
called
like
mass
exits.
You
can
do
all
sort
of
fun
stuff
here
you
can
like
do
true
bits
over
these
numbers.
B
We
want
to
take
all
these
squiggles
right,
take
all
these
squiggles
and
make
them
one
big
long,
squiggle
right,
and
then
we
want
to
like
shift
all
this.
You
know
this
dark
section
and
this
skinny
section
and
these
cross
hashes
and
these
dots
we
want
to
shift
them
all
so
that
they're
all
pressed
up
against
each
other
as
well.
Okay,
so
we're
calling
that
defragmentation
and
like
there's
like
several
III
search
posts
on
this
for
all
listeners,
the
III
sir
dot
CH
III
search,
is
an
awesome
form.
You
guys
should
all
check
out.
B
Vitalik
has
some
defragmentation
posts
on
there,
but
the
one
that
seems
most
promising
is
atomic
swaps.
So
basically
the
idea
like,
without
rewriting
another
example
which
I
will
do
in
a
second,
basically
the
idea
out
loud
though
you
simply
have
this
guy,
swap
his
dark
section
over
to
here
and
move
this
section
over
here.
So
it's
like
I'm
exchanging
coin
one
with
your
coin
five,
and
even
though
the
coins
are
both
worth
the
same
amount.
So
it's
not
like
we're
actually
transacting
in
terms
of
value.
B
It
should
be
very
clear
what
we
want
to
do
here.
What
we
want
to
do
is
switch
these
two
guys
back
right,
so
instead,
what
we
want
to
end
up
with
is
like
a
you
know.
This
is
a
high
down
and
then
at
high
n
plus
one.
We
want
to
have
suddenly
this
right
right,
and
so
what
has
been
done
here?
It's
an
atomic
swap
on
these
two
things
right
and
we
want
to
insure
for
Alice
and
Bob
sake.
B
Well,
obviously,
you
know
if
we're
assuming
these
are
all
equal
quarters
and
let
should
all
be
right.
The
the
thing
that
we
want
to
ensure
is
for
both
Alice
and
Bob
that
they
are
like
safe.
In
the
event,
this
happens,
in
other
words,
Bob
can't
somehow
be
tricked
to
sending
these
coins
to
Alice
without
receiving
Alice's
coins.
B
Right,
okay
and
one
very
important
thing
here-
and
this
is
like
this-
is
in
general-
I-
think
something
that
people
very
much
struggle
with
intuitively
in,
like
the
cash
flow
interpretation,
because
we
think
of
these
ranges
as
like,
we
think
of
like
the
things
in
the
Merkel
tree
or
like
the
transactions
as
being
coins.
Really
they
are
like
updates
to
the
underlying
coins.
So,
when
I
draw
these
arrow
here,
arrows
here,
I
actually
think
that
this
is
maybe
a
little
misleading,
because
it
almost
looks
like
you're
taking
these
coins
and
you're
swapping
places
with
them.
B
So
actually
I
think
that's
probably
a
bad
way
to
draw
it
and
probably
is
like
badly
reinforcing
what
you're
really
doing
is
you're
keeping
these
coins,
like
here
like
they're,
the
same
coins
but
you're,
swapping
the
owners
you're
swapping
the
owners.
So
that's
really
what
you
want
to
do
you
want
to
take.
You
know
you
want
to
take
continuous
ranges
and
maximize
look
like
continuous
range,
miss
at
each
owner,
and
so
you
need
atomic
swaps
to
enable
that
it's
pretty
easy
to
do
an
atomic
swap.
Well,
it's
it's!
B
It's
non-trivial,
but
it's
relatively
easy
to
do
an
atomic
swap
basically
like
two
atomic
swap
this
range
with
this
range.
You
need
inclusion
groups
on
both
and
like
if
both
inclusion
groups
are
present,
that's
good.
So
now,
instead
of
just
checking
the
triangle,
like
the
transaction
says,
you
got
to
check
the
triangle
and
the
square
for
this
guy
and
you
check
both
the
triangle
and
the
square
and
they
swap
so.
B
Our
contracts,
for
example,
currently
support
this
point.
This
atomic
swap
functionality,
but
like
the
strategies
as
to
how
we're
going
to
convince
people
to
do
this,
because
people
have
to
be
online
and
like
sign
off,
to
agree
to
do
it
in
this
case,
like
we
think
it's
incentive
compatible,
because
both
Alice
and
Bob
like
are
helped
by
this
right,
like
their
exits
go
down,
but.
A
Like
if
we,
if
we
replicated
here
right
so
this
is
my
coffee
shop
yeah,
that
is
definitely
soon
so
that's
the
coffee
shop
owner
is
the
rectangles
and
that's
like
one
guy-
and
this
is
my
the
co-efficient
of
owner
some
other
guy
and
the
coffee
shop
owner
and
some
third
guy
yeah.
So
here
the
first.
So
let's
assume
that
people
are
willing
to
help,
even
if
it
doesn't
benefit
them
much
so
here
the
first
guy
will
say
yeah.
You
know
I'm
going
to
be
willing
to
help
you
and
exchange
and
like.
A
B
And
so
these
problems
are
tough
and
in
general,
it
like
like.
We
can
hypothesize
a
lot
about
like
what
like
these
defragmentation,
like
structures
may
look
like
so
like
one
one
I
want
observation.
That
we've
made,
for
example,
is
that
it's
probably
going
to
be
a
role
of
the
operator
to
suggest
to
these
two
clients.
It's
like
what
we
want
is
will
abstract
all
that
away
like
we
don't
actually,
when
you're
buying
coffee,
you
don't
have
to
agree
with
the
coffee.
B
B
B
So
if
you
indeed
I'll
do
the
swap,
it
must
be
the
case
that
all
of
that
swap
data
is
put
on
the
main
chain.
So
it
doesn't
have
very
good
scalability.
But
if
you
don't,
the
operator
can
swap
you
and
like
withhold
that
he's
swapping
you
and
he
can
exit
the
things
that
he
swapped
you
to
and
like
you
don't
have
a
way
to
challenge
it
and
then
he
like
and
then
he
like,
you
know,
exits
the
things
that
he
swapped
you
from
and
he
can
like
steal.
You
know
like
he
effectively
like
you.
B
Imagine
that
Bob
is
the
operator
and
the
operator
exits
this
and
then
exits
this
right
and
like
takes
but
like
what
you
know
both
of
both
this
total
range
and
only
half
of
it
was
owned
by
him.
So
to
prevent
that
you
have
to
put
this.
Like
the
ranges
being
swapped
have
to
be
available
on
the
main
chain,
which
is
kind
of
bad
there's,
maybe
more
complex
things
you
do.
B
You
can
like
define
like
a
non
chain
permutation
and
like
compress
that
permutation
or
something
right,
but
in
general,
it
seems
like
atomic
swaps,
are
the
way
to
go,
because
one
of
the
things
that
we'll
probably
have
here
is
probably
in
reality,
there's
gonna
be
times
when
there's
just
a
big
long
range
of
coins.
That
is
like
a
whale
you
know.
B
I'm,
like
this
decks
or
whatever
and
like
it's
gonna,
be
an
extra
like
source
of
like
like
fee
revenue
if
they
use
their
liquidity
to
help
a
bunch
of
people
just
totally
like
migrate
atomic
swap
into
them
right.
You
know
and
just
like
totally
move
everything
over,
but
it's
definitely
an
active
area
of
research
and
like
one
that,
like
is
gonna,
be
explored
more
in
the
future
for
sure
cool.
B
B
B
We
have
a
node
a
an
operator
and
like
helper
libraries
like
it's
kind
of
like
an
SDK,
all
written
in
JavaScript,
so
github.com
slash
plasma
group
or
go
to
plasma
group
and
we'll
link
to
all
that
stuff,
and
we
would
absolutely
love
that,
like
we're
absolutely
trying
to
build
a
community
of
developers,
this
is
like
we're
a
nonprofit
organization
like
it's
just
our
goal,
to
help
promote
this
stuff
as
free
public,
good
stuff
yeah.
So
that's
fantastic!
B
B
B
If
you
just
want
to
like
try
it
out
and
transact
and
like
learn
about
depositing
stuff,
you
can
also
go
to
a
burner
cause
plasmon
group
and
we've
integrated,
like
the
amazing
Austin
Griffith
Springer
wallet
4x
die
right
on
plasma,
so
those
are
all
things
you
can
try
and
we,
like
super,
encourage
you
to
check
that
out.
Yeah,
okay,.