►
Description
We had Tom Close (https://twitter.com/tomclse) from Magmo (https://twitter.com/magmoHQ) speak about State Channels with our Co-Founder, Alex Skidanov (https://twitter.com/AlexSkidanov)
Learn more about Magmo here: https://magmo.com/
Location: NEAR Protocol HQ, San Francisco, CA
Download the video here: https://near.ai/e33dc
------- 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.
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 #Blockchain #FutureIsNEAR
A
B
B
Oh,
how
about
I
start
by
giving
a
I
guess
like
a
toy
example
of
a
state
channel
interaction
so
as
you
probably
we're
like
state
channels
or
an
interplay
between
like
unchain
stuff
and
off
train
behavior?
So,
let's
start,
let's
suppose
we
have
Alice
and
Bob
now
we're
gonna,
suppose
Alice
and
Bob
want
to
do
a
lot
of
transactions
with
each
other,
and
these
transactions
are
going
to
be
done
very
quickly
and
maybe
they're
going
to
be
very
small
in
value.
So
basically
it
wouldn't
make
sense
to
put
all
of
these
transactions
on
the
blockchain.
B
B
Let
me
explain
what
this
means
in
a
second
Alice
sends
that
to
Bob
and
it's
signed
by
Alice
I'm,
just
gonna
say
anything
that
Alice
sends
to
Bob
is
signed
by
Alice
and
anything
Bob
signs
to
Alice
is
signed
by
Bob
okay.
So
this
is
like
an
opening
statement.
So
what
this
is
saying
is
we
are
going
to
start
a
state
channel
alice
is
going
to
put
in
5,
Bob
is
going
to
put
in
5,
and
then
Bob
will
echo
that
back.
B
So
at
this
point,
they're
in
a
safe
state
to
deposit
some
money
on
chain
and
I'll
go
through
that
a
little
bit
more.
Why
that's
a
safe
state
later
so
there's
this
contract
on
chain.
We
call
it
the
adjudicator,
so
this
contract
is
going
to
hold
their
funds
for
the
duration
in
the
state
Channel,
and
it's
also
going
to
I
guess
implement
the
rules,
the
protocol
about
how
those
funds
can
be
released.
B
So
in
this
situation
what
happens?
First
is
Alice
deposits.
Five,
the
other
thing
is
I'm
just
going
to
talk
in
terms
of
like
abstract
coins
throughout
the
whole
of
this.
So
we
can
do
this
with
like
different
ERC
20
tokens,
eath
or
whatever,
but
for
the
whole
of
this
discussion,
we'll
just
talk
in
terms
of
coins,
because
that's
right
so
Alice
puts
in
five
and
then
Bob
can
also
put
in
five.
B
So
there's
now
ten
coins
in
the
adjudicator
and
it's
going
to
be
split
according
to
the
outcome
of
their
state
Channel.
So
now,
Alice
and
Bob
can
get
going
like
with
their
interaction.
So
say:
Alice
wants
to
send
one
coin
to
Bob.
She
doesn't
update
she
decrements
her
balance,
increases
Bob's
balance
and
then
Bob
sends
something
back.
B
A
B
Probably
good
to
get
into
that
later,
because
you'll
see
exactly
how
that
works
when
I
explain
like
so
what
this
I
guess,
to
give
a
little
bit
of
sneak
peek
of
that
now.
What
this
actually
means
is
of
the
money
in
the
contract.
First
Alice
gets
five.
Then
Bob
gets
five.
So
this
this
this
list
here
this
like
thing
here
actually
encodes
a
precedence
order,
this
I
guess
the
other
thing
is
like
I
should
probably
say
is
some
of
this
is,
like
general
state
channel
stuff.
B
Some
of
this
is
specific
to
nitro
protocol,
which
is
our
protocol
for
doing
state
channel
networks.
So
not
all
not
all
networks
have
this
precedence
thing.
The
reason
we
have
it
is
allow.
It
allows
you
to
just
store
10
here
in
other
state
channel
frameworks,
you'll
see
in
the
adjudicator
things
like.
B
So
they'll
track
the
actual
balances
and
stuff
I'm.
Just
gonna
stick
with
doing
it.
This
way
it
has
a
couple
of
other
nice
properties
we
should
get
into
so
yeah,
so
Alice
has
to
deposit.
First
Bob
can
only
deposit
when
he
sees
Alice's
deposited.
Otherwise,
it's
not
safe,
Alice
could
steal
his
money
and.
C
B
D
B
This
is
like
a
pending
thing.
The
reason
this
is
pending
is
because
it
gives
the
other
person
a
chance
to
challenge
with
a
higher
state.
It's
like
you
think
about
it
like
this
state
is
not
favorable
to
Bob.
Bob
would
prefer
this
state
so
like
Bob,
could
try
and
put
this
state
in
there.
If
you
did,
Alice
would
have
some
time
to
present
the
98
and
they.
B
I'm,
let
me
let
me
get
back
on
track,
I'm
jumping
ahead.
So
in
the
happy
case-
and
this
is-
you
can
also
optimize
this-
which
I'll
talk
about
later
Alice
puts
this
up
here.
There
is
no
higher
state,
and
so
at
some
point
it
will
time
out
when
it
times
out,
then
the
adjudicator
sends
the
money
back,
so
it
sends
nine
LS
1
Bob.
This
becomes
zero
and
this
is
like
done
so
that's
the
happy
case.
B
The
reason,
the
time
out
there
as
I've
seen
before,
is
to
protect
against
one
person
cheating.
It's
obviously
the
chain
doesn't
know
how
many
states
there
are
off
chain.
How
many
like
of
these
commitments,
they've
sent
back
and
forwards
so
like
Bob
here
could
be
like
our
I've
only
got
one
coin
here,
but
I've
got
six
here,
so
maybe
I
could
try
and
check
out
in
this
state.
B
B
Probably
not
you
can
you
can
we're
now
into
like
optimization
details.
So
do
you
store?
Do
you
store
the
highest
number?
That's
been
challenged
or,
like
the
highest
number,
you've
seen
an
adjudicator.
Probably
yes,
because
it
allows
you
to
get
rid
of
some
states
and
avoid
some
griefing,
but
then
that
yeah,
you
don't
have
to
like
I
mean
you
could
you
could
live
in
a
world
where
the
adjudicator
doesn't
do
that
and
every
time
Bob
presents
this
Alex
presents
that
and
they're
just
locked
in
this
game.
So
you
probably
would
want
that
optimization.
B
It's
not
part
of
the
protocol,
so
this
is
like
this
is
the
basic
pattern
that
you
see
with
state
channels
and
with
payment
channels.
You
lock
up
some
funds
on
chain,
you
send
new
exchanges
and
signed
agreements
off
chain
and
then
at
the
end,
there's
some
challenge
period
and
after
the
challenge
period
you
split
the
funds
according
to,
according
to
the
final
outcome
of
the
channel
and.
A
B
B
C
B
And
separate,
at
least
in
my
tree
protocol,
we
try
and
separate
the
funding
step.
You
know
everything
up
to
do
with
like
depositing
money
and
claiming
money
from
the
operation
step
they
get
into
an
outcome
and
the
reason
we
do
that
is
because
that
allows
us
you
swap
out
the
funding.
So
a
weakness
of
the
thing
I
presented
here
so
far
is
that
this
operation
started.
B
Yeah
yeah
the
weakness,
so
the
weakness
of
this
obviously
is
okay.
Alison
Bob
got
to
do
a
hundred
transactions
off
chain,
but
they
had
to
start
this
operation
with
each
doing
an
on
chain
transaction
and
they
have
to
finish
it
with
an
untrained
transaction.
So
like
this-
and
this
is
actually
kind
of
quite
an
unusual
use
case.
If
you
think
about
the
transactions
you
do
every
day
like
you,
do
a
couple
of
transactions
with
a
wide
number
of
people,
rather
than
hundreds
run
transactions
with
one
person
and
so
like.
B
This,
currently
has
a
big
limitation
in
terms
of
like
a
scalability
solution,
but
as
I'll
show
you
later,
we
can
actually
fund
some
channels
with
other
channels.
If
we
separate
out
the
funding
step
from
the
operation
step,
but
I
wanted
to
probably
go
over
the
operation
step
first
and
on
to
some
of
your
questions
about,
like
you
know,
do
they
always
have
to
apply
to
each
other?
Does
Bob
always
have
to
confirm
that
stuff?
If
you
happy
starting
sure
yeah
isn't
that
okay
cool.
A
B
There
are
a
couple
of
ways
around
that.
Let
me
let
me
first
go
into
the
state
format
and
then
you
can
kind
of
begin
to
see
how
some
of
this
stuff
works
yourself,
because
the
that
question
of
like
I
mean
I
guess
to
answer
that
question
a
little
bit
now
in
some
sense.
Is
it
doesn't
matter
if
Bob
wants
to
send
money
to
Alice?
B
This
is
like
off
chain
collaborative
behavior,
so
Bob
wants
to
money
to
Alice
he's
like
hey
Alice
M,
your
message,
so
it's
my
turn
and
I
can
send
money
to
you,
so
you
could
do
things
like
that.
They're
also
actually
other
ways
you
can
optimize
that
as
well
within
the
rules.
So
let
me
start
by
digging
into
this
state
format,
because
this
is
a
cartoon
version.
You
can't
see
everything
that's
happening
from
this
version,
so
the
state
format
is
like
pretty
simple
in
some
ways.
So
let
me
just
write
it
out,
so
you
have
participants.
B
C
A
C
B
B
Come
up
with
the
nonce
and
it's
in
their
interest,
like
obviously
they
could
open
a
new
channel
with
the
same
nonce,
but
then
states
from
the
previous
channel
will
apply
to
the
new
channel
and
nobody's
going
to
know
what
the
hell's
going
on.
So
it's
in
their
interest
to
jointly
choose
this
number
and
each
of
them
can
like
say
I'm
not
using
that
number.
Nobody
can
be
forced
into
using
a
number.
They
don't
want
got
the
nonce.
Then
we've
got
the
next
thing,
which
is
the
turn
number.
B
A
B
False,
so
this
is
something
I
haven't
spoken
about,
yet
the
as
you'll
see
later.
The
purpose
of
this
is
to
allow
collaborative
closes
without
the
timeout.
So
this
means
that,
like
you
know,
I
said
here
that
they
go
here.
They
have
to
wait.
This
is
a
way
that
they
can
both
sign
off
and
avoid
waiting.
You.
C
B
Outcome-
and
this
thing
is
weird-
we're
going
to
start
off
with
this
being
just
like
a
mapping
of
addresses
to
you
int
and
it's
like
an
array
of
those.
Basically,
this
is
what
this
default
outcome
says
and
I
guess
this
is
going
to
be
like
a
5v5
know.
Example.
So
this
is
like
saying
like.
If
the
channel
was
a
stop
at
this
point,
he
would
get
what
and
this
format.
B
This
is
the
format
for
a
certain
type
of
channel.
When
you
come
to
building
state
channel
networks,
as
far
as
I
can
tell
you
need
a
different
format,
you
need
to
add
one
more
format
and
a
new
set
of
rules
and
I'm
not
entirely
sure,
that's
true,
but
it
seems
to
be
true
from
everything
I've
done.
This
isn't
quite
enough
to
do
everything
default
outcome.
B
Okay,
then,
we've
got
an
app
definition
which
is
an
address,
and
then
we
have
app
data
which
is
bytes
and
then
finish
off
with
signature,
which
is
whatever
signatures
are
like
you,
int
8,
bytes
32.
This
is
a
bi,
it's
32,
so
this
is
the
classic
VRS
started
playing,
and
this
is
the
signature.
The
person
who's
signing
it
and.
B
They
could
the
way
we
do.
It
is
they're
not
so
like
for
a
payment
channel.
There
are
different
ways:
you
can
code
up
a
payment
channel,
which
is
what
I
was
coming
to
here
a
little
bit,
so
one
rule
for
a
payment
channel
might
be
on
my
turn.
I
can
only
decrease
my
balance
and
increase
your
balance,
so
I
can't
like
and
that
when
that
would
mean
I
can
send
you
stuff.
B
Without
you
confirming
back
to
me,
they
would
mean
I,
can't
unilaterally
steal
your
money,
so
that
would
be
a
sensible
that
would
be
a
sensible,
like
definition
for
payment
channel.
Another
thing
would
be
a
satellite
consensus.
There's
this
thing
which
will
come
on
to
later,
which
is
that
the
consensus
game,
where,
like
I,
proposed
a
new
outcome
and
you
accept
the
new
outcome
and
then
the
outcome
moves
into
this
slot.
So
there
are,
there
is
a
little
bit
of
logic
there.
B
So
this
one
of
the
things
about
payment
channels
is
and
state
channels
it's
a
little
bit
risky
right
that
you've
looked
up
some
funds
up
here
and
the
way
you
unlock
those
funds
is
by
doing
some
stuff
off
chain
with
an
opponent
or
a
partner.
Maybe
maybe
an
opponent
I,
don't
let's
talk
about
it
as
an
opponent
is
a
slightly
adversarial
relationship.
So
at
any
point
my
opponent
could
stop.
B
B
Maybe
Bob
died,
I,
don't
know
what
perfect
for
every
reason
like
some
of
them,
some
of
them
malicious,
some
of
them
not
malicious
Bob,
might
not
be
able
to
sign
another
update,
and
at
that
point
there
has
to
be
a
way
to
get
this
money
back
and
the
way
that
we've
seen
the
way
that
that
works
is
exactly
how
it's
seen
already
so.
Alice
can
launch
a
challenge
and
then
they
can
split
the
funds.
But
that
means
that
each
state
needs
to
have
a
concept
of
like
if
we
stopped
at
this
point
in
time.
A
B
A
B
Yeah
I
mean
like
this.
This
is
the
only
state.
The
only
thing
that
happens
on
chain
is
these.
Things
are
stored
on
there
and
I.
Guess.
I
ought
to
say
that
this
I'm
not
convinced
whether
this
this
restriction,
that
a
state
channel
always
involves
a
fixed
set
of
assets
and
the
outcome
is
always
letting
those
assets
is
generally
true.
I
know
there
are
some
tricks
you
can
play
where,
like
you
can
I
know,
you
can
trade
off
chain
the
ability
to
set
a
value
in
a
contract
on
chain
or
something
and
it
might
trip
rhotuka.
D
B
Be
able
to
do
these
more
general
things
to
be
able
to
yeah,
basically
off
chain
trade,
the
right
to
change
the
chain
in
some
arbitrary
ways
that
yeah
we
just
decided
to
like,
simplify
that
down
and
notice.
I'm
also
kind
of
I.
Think
there's
a
like
wider
philosophical
question
there
about
whether
those
things
actually
make
sense,
which
I
haven't
been
able
to
convince
myself
of
like
one
way
or
the
other
anyway
back
to
this
state
format.
So
this
is
the
state.
B
So
let
me,
let's
suppose,
instead
of
this-
that's
that's
actually
looking
at
example
of
tic-tac-toe,
so
this
here
I'm
gonna
have
so.
This
represents
the
address
of
some
contract
unchain,
the
this
library
that
defines
the
rules
for
tic-tac-toe.
We
can
talk
about
that
in
a
minute
and
then
this
app
data
is
gonna,
be
the
format
that
you
need
for
tic-tac-toe.
B
C
A
B
B
Yes
and
no,
so
anyone
could
provide
any
of
these
messages.
If
I
exit
with
my
message,
then
there's
always
a
chance
that
you
will
provide
another
message
like
you:
have
the
power
to
do
the
next
message,
but
like
there
are
interesting
games,
you
can
play
with
like
providing
other
people's
messages
and
stuff,
so
yeah
I
mean-
and
it
also
depends
how
you
kind
of
think
about
these
challenges
as
well,
and
so
the
this
thing
that
I'm,
just
explaining
here
with
nitro
Protocol
nitro,
is
an
extension
of
for
smooth,
which
is
basically
this.
B
This
framework
for
building
these
little
games,
like
the
set
of
rules
I'm
about
to
describe
you're,
basically
forced
move
rules
and
enforce
move.
You
think
about
the
challenge.
As
forcing
someone
to
move,
it's
sort
of
saying
that
the
only
thing
that
can
happen
in
this
chant
in
these
channels
that
can
go
wrong
is
that
you
fail
to
move,
and
then
the
idea
is
like
I
launched
this
challenge
on
chain
I'm,
forcing
you
to
move.
B
If
you
don't
move,
the
game
is
over
with
the
default
outcome
and
that's
how
all
these
games
kind
of
work
and
I
think
so.
The
specific
mechanics
here
are
specific
to
nitro
protocol
and
force
move,
but
like
the
overall
pattern
is
the
same
in
any
state.
Channel
application
I
think
has
to
be
the
same
in
any
state
channel
on
location.
You
always
need
a
now.
If
someone
stops
responding,
you
always
need
that
out
really
needs
to
provide
the
data
you
need
as
well.
B
A
B
A
B
You
know
say
the
way
that
would
work
is
so
you're
getting
into
the
grieving
scenario
now
I
think
so.
The
way
this
could
work
is
Bob
puts
this
unchain
either
Alice
responds
or
she
doesn't.
If
she
doesn't
respond.
The
game's
over
and
Bob
gets
the
default
outcome
at
that
point,
which
hopefully
the
game
designer
has
designed
so
that
Bob
doesn't
lose
out
if
Alice
goes
away.
B
If
Alice
does
respond,
Alice
responds
by
putting
the
next
move
on
chain.
So
then
Alice
and
Bob
can
continue
off
chain.
So
by
responding
on
chain,
Alice
has
given
Bob
the
exact
information
they
need
to
continue
collaborative
chain
if
they
want.
Of
course,
Alice
can
continue
to
be
an
and
challenge
Bob
every
single
time,
and
we
can
like
deal
with
that
scenario
later.
B
A
B
Yeah
we
can,
we
can
write
what
would
be
the
best
thing.
So
let
me
answer
your
question
quickly,
so
in
tic-tac-toe
one
way
you
could
design
it
is
so
that
failing
to
move
is
like
default
in
the
game
resigning
from
the
game.
The
other
person
gets
the
entire
stake.
That
would
be
like
one
deeper
outcome
and
so
that
what
that
would
look
like
is
as
Alice
and
Bob
are
sending
them
across
like
Alice
sets
the
default
outcome
to
be
four
six.
B
Sorry
64
so
like
she
wins.
If
Bob
doesn't
respond,
Bob
sets
it
to
be
46
when
he
responds
and
these
hobbies
change
as
specified
by
the
rules
of
the
game.
So
maybe
I
should
go
into
that
a
bit
and
now
because,
like
obviously
a
lot
of
this
is
about
like
what
are
the
valid
updates
between
here
and
here,
and
then
that
bit
all
feeds
into
like
yeah,
how
you
can
update
things
on
one
chain
and
like
the
Unchained
methods
you
can
call
and
how
that
all
sort
of
works.
B
D
B
B
D
B
B
B
We
need
that
a
dot
müber
equals
a
dot
signer
okay.
So
what
does
that
mean?
So
it
has
to
be
signed
by
the
person
who's
making
the
move.
How
do
you
calculate
the
person?
That's
making
the
move
so
for
that
we
specify
that
people
must
take
turns
so
that
a
dot
mover
is
equal
to
a
dot
participants
and-
and
we
take
the
index
of
the
turn
and
the
mod
and
we're-
and
it's
the
number
of
people
in
the
channel.
So
this
says
that
Alice
signs,
all
the
or
even
ones,
Bob
signs
all
the
odd
ones.
B
B
B
B
B
B
I'll
talk
about
why
it's
2n,
but
basically
like
the
first
two
steps
of
the
channel
I
set
up
and
that's
weird
because
in
that
cartoon
version,
I
didn't
show
you
to
n
I
only
talked
showed
you
one
in
but
like
we
actually
need
an
echoing
back
after
that
I
think
so
a
dot
default
outcome
equals
V
dot.
You
fold
outcome
a
dot.
B
B
B
So
so
yeah
we've
got
three
stages.
This
is
like
the
end.
This
is
like
setup,
and
this
is
like
the
running
step
and
in
the
running
step,
most
of
what
we
do
like.
Obviously,
these
things
have
to
hold
whatever.
Then
you
know
in
the
running
step.
Most
of
what
we
do
is
we
delegate
valid
transition
to
the
app
definition
which
in
this
case
would
be
the
rock
sorry,
the
tic-tac-toe
contract
with.
B
So
this
is
interesting,
we're
not
quite
sure
at
the
moment
we
just
passed
in
the
whole
state,
so
it
could
actually,
which
means
you
could
write
games
that
have
different
rules
depending
on
what
turn
them
you're
on
and
I'm,
not
sure,
if
that's
a
good
thing
or
a
bad
thing.
We
also
thought
about
like
housing,
some
of
this
off,
so
that
this
only
looks
at
the
default
outcome
and
the
updater.
B
C
B
B
Balance,
I
guess
the
number
of
coins,
it
will
store
an
outcome
and
then
it
will
have
some
way
of
doing
a
challenge
like
the
challenge,
time
out
and
stuff.
So
here
we
might
have
like
tic-tac-toe
number
1,
no
balance,
no
outcome
at
the
moment,
so
this
is
what
was
I
trying
to
get
to
I
was
trying
to
get
to
the
setup.
B
A
B
B
Why
do
we
need
this
initial
set
up?
So
you
need
this
initial
set
up,
because
at
this
point
this
point
is
like
a
special
point,
so
like
I
guess,
the
way
this
looks
is
that
you
have
two
states
special
point:
two
states
more
states,
and
these
things
here
we
call
a
pre-fund
setup
and
these
things
here
the
post
fund
set
up
as.
B
B
Yeah
I
mean
okay,
so
there
are
a
couple
of
things
interacting
here.
They
need
these
ones
before
anyone
puts
any
money
in
because
this
is
exactly
what
you
need
to
launch
a
challenge
so
like
before.
You've
got
two
states:
you're
not
safe,
to
put
any
money
in
the
contract,
because
if
your
person
doesn't
give
you
the
other
state,
then
you've
lost
your
money.
All.
B
Upstate
and
the
reason
Alice
goes
first,
is
because,
if
the
outcome
stopped
here,
she
will
get
the
money
back
first,
so
it's
like
slightly
different,
like
I,
think
we
always
do
it.
This
way
around
I
think
maybe
works
it
around
I'm,
not
exactly
sure,
but
like
pretty
much
like
this
is
the
way
to
do
it
and
then
the
nice.
B
So
the
actual
thing
about
this
state
here
is
that
you
have
we're
now
beginning
to
get
into
the
theory
of
like
why
this
works,
and
one
of
the
things
that's
important
is
knowing
what
the
states
hold
to
hold
you're
holding
mean
and
really
what
that
means
is
from
this
state.
What
outcome
can
I
get
on
chain
like
what
what
outcomes
were?
What
outcome
is
finalized
well,
based
on
what
I
hold?
B
Bob
can
have
the
same
like
the
same
logic,
and
this
is
actually
like
really
important
when
you
start
building
up
state
channel
networks,
the
logic
of
like
at
what
point
can
I
guarantee
that
the
things
I'm
holding
allow
me
to
put
something
particular
on
chain
so
like
Bob,
can
also
Bob
knows
that
by
withholding
his
signature
at
this
point,
the
this
outcome,
no
other
outcome
than
this
outcome
is
possible.
So
this,
like
funding
point-
and
these
like
set
up
things
here,
make
this
funding
point
a
universally
finalized
for
outcome.
B
The
other
point
you
have
that
is
is
when
you've
got
a
finalized
state.
Again,
I
haven't
told
you
how
that
works
yet,
but
like
if
you
hold
a
final
state
and
I
hold
in
this
final
state,
so
I'm
by
the
other
person,
then
we
also
have
a
universally
finalized
for
outcome.
The
reasons
under
some
assumptions
but
like
that
can't
go
wrong,
but
if
you
follow
the
protocol
account
so.
A
A
B
A
B
B
C
B
I
said:
I:
guess:
yes,
so
they
do
these
messages,
then
Alice
pits
in
money
when
Bob
sees
that's,
definitely
gone
through.
Bob
can
put
in
money
and
actually
probably
what
you'd
want
to
do
is
make
Bob's
Bob's
transfer
in
conditional
on
there
being
a
certain
amount
of
money
from
Alice
in
there,
so
that
you
can't
get
like
real
problems
where,
like
Bob,
because
if
you
end
up
with
five
in
the
contract,
which
is
Bob's,
then
Bob
is
screwed
and
like
Alice
can
just
take
his
money
because
Alice
gets
the
money
first.
B
So
it's
in
it's
important
for
Bob
yeah.
So
when
they're
holding
these
things
and
the
reason
it's
safe,
when
they're
holding
these
things
is
they
can
challenge
either
than
can
challenge.
They
know
that,
like
both
of
them
by
withholding
this
message
and
because
of
these
rules,
they
can
tell
that
the
default
outcome,
never
changes,
but.
B
B
B
Probably
not,
but
what
if
the
first
rule
of
the
game
was
for
Bob
to
take
all
the
money
like
you
know,
Alice
could
be
forced
into
that
and,
like
I,
don't
know,
I
mean
I'm
I.
Think
it's
important
to
have
these,
because
you
don't
know
what
the
game
developer,
what
the
application
rules
are
going
to
be
right.
A
B
C
A
Guess
so,
if
I
go,
if
a
plane
kicked
octo
and
the
game
is
over,
yeah
I
will,
if
I'm
a
good
actor.
I
will
sign
this
final,
yes
yeah
and
then
it
settles
makes
it
so.
Another
question
I
have
is:
when
a
challenge
does
much.
Does
my
challenge
have
to
have
a
higher
turn
number
or
it
could
be
the
same
to
a
number.
B
A
B
Okay,
so
you
come
right
into
these
other
things
there's
another
method,
so
this
is
a
general
problem
like
what
happens
with
alternative
moves
and
any
protocol
any
state
general
protocol
has
to
handle
that
you
know
I
could
always
like
send
you
turn
number
three
and
then
send
your
alternative.
Ten
number
three
and
the
way
that
works
in
this
protocol
is
that
you
get
to
choose.
So
you
can
choose
whether
you
go
from
three
or
from
alternative
three,
and
this
is
actually
pretty
useful
in
a
payment
channel
say
like
say
in
this.
B
Exactly
this
very
example:
Alice
send
I
mean
this
is
not
the
payment
channel
anymore
but
like
if
I
send
you
six
six
four
and
then
I
send
you
seven
three
and
I
send
you.
Eight
I
can
rely
on
you,
achiely
picking
eight
out
of
that.
So,
like
you
can
get
like
you
can
actually
use
this
alternative
turn
number
stuff
to
your
advantage
when
designing
protocols
so
yeah.
So
if
I
give
you
multiple
turns
you
get
to
choose,
we
have
to
have
that
here
as
well,
so
like
there's,
actually
another
method
which
is
respond
with
alternative.
B
And
here
you
have
to
provide
so
like
say
you
challenged
with
say
this
was
like
number
four
I'm,
even
if
all
it's
not
a
good
number,
because
that's
too
low
but
like
say
this
was
number
seven,
and
this
was
number
eight.
So
how
do
I
respond
with
an
alternative?
Well,
I'm,
like
okay,
I
was
I.
Think
what
you
do
is
you
do
be
primed
C,
so
I
give
something
else.
B
This
is
like
a
little
bit
hazy
we're
getting
into
like
that's
it.
But
basically
you
need
something
like
this,
and
so
this
has
number
eight,
and
this
has
number
nine.
So
it's
like
so
this
is
you
saying
you
were
at
seven
I
moved
to
eight
now.
I
want
you
to
move
tonight,
and
this
is
me
saying,
but
you
also
gave
me
this
other
eight
and
I
want
to
move
on
from
that.
So.
A
B
A
A
No
I
think
it
should
be
fine,
so
what
I'm
trying
to
see
if
I
can
get
screwed
if
I'm
exiting
B,
which
was
a
state
on
which
I
acted
upon
already
someone
else
yeah
someone
else
can
wait,
create
an
alternative
state
and
something
on
top
of
that.
But
then
that
got
it
then
she
should
be
someone
who's.
Not
me,
yes,
but
then,
if
she
sounds
something,
that's
not
me,
then
why?
Why
did
they
act
upon
the
state
which
was
not
yeah.
A
B
This
is,
this
is
kind
of
interesting
I.
Think
it
works,
but,
like
I
mean
say,
say
we're
like
in
I
mean
say:
you're
in
a
in
a
channel
challenge
in
a
channel
with
both
like
Allison
Carroll
and
you
went
then
Alice
went
now,
Carol
hasn't
gone.
You
have
to
be
able
to
challenge
with
the
like
Carol's
previous
state,
your
state
and
analysis
state,
because
otherwise
Alice
could
grief
you
by
not
launching
that
challenge.
A
So
if
Carol
sent
me
some
message,
yeah
and
so
let's
say
we
also
doing
some
other
actions,
so
let's
hit
the
payment,
Channel
and
Carol
sent
me
money.
Yeah
I
gave
her
her
Lottie.
Yes
right,
then
I
know
that
that
money
is
mine,
yeah,
because
I
can
exit.
What
what
I
should
not
be
doing
is
imagine
that
some
action
by
Bob
so
Bob
sends
message
to
Carol.
It's
a
message
from
Bob
to
Carol
yeah,
which
in
some
way
tells
me
that
I'm,
that
that
is
good
for
me
now
to
provide
the
service
Yeah.
B
A
B
B
You
have
a
finalized,
Abul
state
exactly
before
you
send
out
your
next
state,
because
at
that
point
you
could
not
sign
anything
else
and
you
could
ensure
that
the
channel
finish
and
that's
also
where
the
and
because
that's
always
a
possibility
that
you
can
always
exit
in
your
state.
That's
why
we
allow
this
transition
to
its
final,
any
state
so
like,
instead
of
just
you
know,
if
you
can
achieve
an
outcome
by
just
like
stopping
and
griefing
everyone
until
the
timeout
goes,
we
let
you
do
that
outcome
without
doing
that.
B
A
A
B
B
A
B
B
So
you
can
get
that
property
if
you
want
to,
but
you
have
to
like
design
that
into
the
game
in
most
games
like
you,
don't
really
want
that,
and
that's
one
of
the
strengths
of
having
this
like
flexibility
to
design
your
transition
function
and
like
not
have
to
have
everyone
double
sign.
Anything.
What's.
A
B
You
hold
a
finalized
for
outcome
if
you
have
a
strategy
for
getting
that
outcome
into
the
judicata,
and
no
one
can
stop
you
so
like
if
it's
your
turn,
if
it
and
you
haven't,
signed
anything
and
send
it
to
anyone,
yet
your
one
strategy
to
finalizing
that
outcome
would
be
to
challenge
yourself
and
not
respond
to
that
challenge.
Another
strategy
would
be
to
sign
a
conclude
state
and
then
release
that
to
the
world,
because
after
you've
signed
a
seclude
state,
everyone
should
not
collude
conclude
state
or
its
final
state.
B
B
I'm
like,
if
you
think
about
like
the
definition
so
like
this
unbeatable
strategy
bit
you're
in
one
of
two
situations,
either
like
one
person
holds
multiple
one
or
more
fine
lines.
Will
outcomes
so
like
it's
possible
for
you
to
have
to
finalize
outcomes
if
I've?
Given
you
multiple
moves,
all
of
those
outcomes
to
you
are
finalized,
but
at
that
point
in
time
it
might
also
be
that
you're,
the
last
person
basically
having
multiple
final
answer
outcomes,
is
like
having
an
option.
B
You
know
like
I've,
given
you
this
thing
and
you
can
like
you
can
do
it
yeah
so
like
you
can
have
multiple
finalized
poor
outcomes
but
or
everyone
can
hold
the
same
finalized
outcome.
It's
impossible
to
have
two
different
people
holding
to
finalize
of
outcomes
because
it
a
is
finalized
ball
for
Bob
and
if
a
and
B,
if
I
might
say,
Bob
and
a
and
B,
if
ionizable
for
Alice,
then
either
of
them
can
choose
either
at
them
and
they
could.
A
B
Sense,
yeah
so
yeah
that
and
I
think
that
is
like
in
some
ways:
that's
the
key
logic
underneath
state
channels
what
outcomes
are
finalized
well,
given
the
states
you
hold
and
that's
the
bit
that
we
like
developed
a
lot
in
the
Nitra
protocol
paper
like
how
do
you
reason
about
when
you
can
finalize
an
outcome?
One
chain
which
is
obviously
like
yeah
important.
B
And
multiple
participants
isn't
really
that
much
different,
so
I
guess
what
we've
done
here
so
I
said
there
are
two
parts.
The
first
bit
is
how
these
things
trying
to
transition
off
chain
and
that's
the
bit
that
I
guess
we've
just
done
here
like
the
one
bit
that
we
haven't
looked
into.
Is
this
app
definition,
but,
like
you,
can
you
can
probably
like
figure
out
what
the
app
definition
is
for
something
like
this?
B
B
You
start
you
have
like
a
starting
state
that,
like
that's
what
you
would
put
in
like
initial
things,
you
would
start
with
like
the
empty
board.
Here
has
a
stake,
so
you
can
you
can?
Basically
you
basically
have
the
way
you
write
these
apps
is
you
think
of
these
different
states?
You
have
to
figure
out
how
to
encode
those
in
your
like
arbitrary
bytes
up
to
you
to
pick
how
to
do
that.
B
Then
you
have
to
enforce
these
things.
You
have
to
say
that,
like
from
oz
turn
to
exes
turn,
you
have
to
change
the
balances
according
to
this
rule,
so
that,
like
the
person
who
stops
forfeits,
if
you
want
to
encode
that
rule
you
might,
you
might
actually
want
to
make
this
dependent
like
you
might
want
to
say
that,
like
at
the
beginning
of
the
game,
stopping
isn't
too
bad
like.
B
The
problem
here
is
like:
if
I
don't
respond
to
you
on
chain,
it's
like
I've
lost
everything,
whereas
if
you
get
to
a
point
like
with
tic-tac-toe,
this
isn't
such
of
a
problem.
Because,
like
it's,
it's
where,
like
the
value
of
the
game,
it's
where
my
perceived
value
of
the
game
is
different
from
these
outcomes
that
I'm
compelled
to
continue,
and
you
can
like
almost
grief
me
infinitely
unchain
it
like
it,
get
you
into
bad
situations.
But
if
you
can
get
two
points
where
everyone
agrees.
A
D
B
B
Of
course,
that's
a
problem
if
you
like
into
one
of
those
situations
where
you
actually
get
checked
mate
in
the
feel,
like
first
three
moves
and
then
so
it's
kind
of
complicated
designing
these,
but
for
these
long-running
games
it's
pretty
complicated,
figuring
out
what
the
what
they
like
default
outcomes
should
be.
But
a
lot
of
games
don't
have
this
anything.
You
do
multiple
rounds
on
like
tic-tac-toe.
We
want
to
pay
ten
rounds
of
tic-tac-toe
after
any
round.
There's
a
fair
stopping
thing,
so
you
can't
be
grief
that
much
you're
limited
like
for
most
little
applications.
B
B
When
can
you
stop
when
you
get
an
out?
If
not
how
long
it
is
it
to
that
point,
because
that's
not
your
like
griefing
danger,
I
said
well
anyway.
So
I
think
that's
probably
enough
about
these
games,
because
I
guess
you
can
probably
like
figure
out
how
these
things
work
in
their
examples,
and
so
we've
actually
we've
actually
got
this
tic
tac
toe
game
working,
so
you
can
actually
play
it
in
the
browser
and
look
at
the
contracts
and
stuff
right
and
is
doing
anything
else.
We
want
to
cover
so
we.
B
A
B
Do
you
so
let
me
see
so
what
I
was
going
to
talk
about
next
was
how
we
can
go
from
these,
like
off
chains,
rules
to
know
to
state
channel
networks,
so
breaking
the
link
between
like
one
deposit
to
one
state
channel
interaction.
So
it's
actually
a
lot
to
do
with
how
this
on
chain
stuff
works.
So
say:
I've
got
this
tic
tac
toe
game
here
and
it's
got
ten
in
it.
You
know
like
alice,
deposit
and
deposited
and
somehow
I've
got.
This
outcome,
which
is
like
Alice
gets
to.
Bob
gets
eight
okay.
B
B
B
B
A
B
Yeah
anyone
can
call
the
transfer
function.
It
just
moves
around
balances
in
this
like
thing
here,
so
that's
how
that
works.
Obviously,
like
Anna's,
can
do
the
same
thing.
We
end
up
with
zero
Alice
to
zero
and
then
Alice
and
Bob
can
we
draw
these.
These
addresses
are
interesting
because,
like
these
addresses
is
different
to
that
address,
and
the
difference
is
that
someone
knows
the
private
key
to
this
address,
which
means
that
somebody
can
we
draw
from
this
address
through
this
address.
B
B
Yes,
yeah
exactly
yeah
and
that's
kind
of
interesting
that
we
all
kind
of
recreate,
really
creating
if
there
him
in
a
theorem
in
some
way,
but
like
so.
The
question
now
is
like
what,
if
these
weren't
participants
like
there's
nothing
that
says
these
have
to
be
participants
like
what.
If,
for
example,
this
had
been,
you
know
like
10,
Alice
gets
to
and
no
rock-paper-scissors
gets
eight
where
rock-paper-scissors
is
another
channel.
B
So
then,
like
rock-paper-scissors
could
get.
Eight
could
get
eight
out
of
this
and
then,
like
maybe
at
some
point
in
the
future.
This
becomes
a
to
be
six
or
something
so
like
the
key
I
guess.
This
is
the
key
insight
that,
like
the
outcome
of
channel,
can
allocate
to
another
channel
and
that
can
allow
you
to
build
up
state
all
networks,
but.
A
B
The
initial
outcome
remember
is
not
on
chain,
and
if
this
allocates
to
to
RPS
eight,
then
you
better
hope
that
Alice
and
Bob
hold
the
initialization
for
that
RPS
contract
and
so
like
you're,
beginning
to
see
how
this
might
work
so
like
if
I
can
I
get
another
different
color
so
got
a
way
of
drawing
diagrams
for
this.
This
is
the
adjudicator.
This
would
be
like
tic-tac-toe,
and
then
this
would
allocate.
So
this
would
be
a
2.
A
B
So
this
is
a
stupid
example.
In
actual
fact,
this
wouldn't
be
rope,
a
tic-tac-toe.
This
would
be
something
called
ledger
channel
and
a
ledger
channel.
It's
just
one
of
these
things
looks
exactly
the
same,
but
its
default
outcome
allocates
default
balances
to
Alice
and
Bob,
and
then
things
to
other
channels.
So
imagine
if
at
this
point
so
think
the
whole
thing
we're
trying
to
get
away
from
is
having
to
do
an
on
chain
transaction
to
fund
this
channel.
So
imagine
that
imagine
that
Alice
and
let
me
just
but.
B
B
C
B
Alice
and
Bob
set
this
up
like
at
the
beginning
the
month,
whatever
they
now
want
to
play
tic-tac-toe,
so
they
a
tic-tac-toe
Channel,
and
these
are
actually
diagrams
for
outcomes,
so
this
is
like
tic-tac-toe
and
the
initial
state
is
5
to
Alice
and
5
to
Bob.
Okay,
so
they've
set
this
up
there
at
the
I'm
just
just
there
at
their
funding.
B
Point,
though,
this
is
two
things
in
this
is
a
university
finalizing
outcome
for
them,
we'll
assume
that
this
is
also
University
finalized
out,
because
these
ledger
channels
are
going
to
use
the
consensus
game
they
talked
about
earlier,
which
moves
you
from
one
University
financed
finalized
without
coming
to
another
one.
So
what
can
they
do
now?
So
we
want
to
fund
this
off
chain.
So
this
is
just
like
one
of
these
things,
so
I
can
sign
an
update
to
that
which
takes
it
to
five
to
Alice
five
to
Bob
and
ten
to
tic-tac-toe.
B
Okay,
so
this
is
like
the
outcome
thing
at
any
point
here
that
the
due
to
the
rules
of
how
state
channels
work
at
any
point
here
like
if
I
challenge
on
tic-tac-toe.
That
would
look
like
this.
You
could
end
up
with
all
these
things
work
independently,
so
to
tighters
balance
of
zero,
but
it
could
still
have
a
challenge
and
it
could
still
have
an
outcome
of
a
a
for
b6
which,
when
I
at
some
point
in
the
future
challenge
with
this
one,
would
like
and
then
I
feel.
B
Fact
that
there's
a
threat
of
this
happening
means
you
don't
have
to
do
it
all
the
time
so
like.
Let
me
just
quickly
show
you
how
that
works.
So
like
we're
in
this
situation,
where
we've
got
a
ledger
channel,
a
is
still
got
a
balance
held
there.
B
has
still
got
a
balance
of
five.
We've
got
this
tic
tac
toe
thing
here.
B
This
is
now
look.
This
is
like,
while
we're
playing
the
game,
this
is
no
longer
in
a
university
final
outcome
like
it's.
It's
oscillating
between
arts
and
Bob,
and
then
imagine
it
comes
to
an
outcome.
So,
like
I've
been
got
this
just
and
then
tic-tac-toe
is
now.
It
finished
like
H
to
Alice
to
to
Bob
five
five
I
can
then
close
this
channel
off
chain
by
defunding
it
and.
D
B
Like
absorbing
those
into
the
to
the
getting
off
to
the
rails,
here
so
and
then
so,
Alice
gets
five
plus
eight,
which
is
13.
It
looks
like
a
B
and
then
Bob
gets
two
plus
seven.
So
what
I've
done
here
is
I've
got
two
state
channels.
One
running
the
ledger
channel
one
running
tic-tac-toe:
we
had
the
money
in
the
ledger:
channel
I've
managed
to
open
this
tic-tac-toe
game
fund
it
off
chain.
Do
everything
close
it
off
chain
as
well,
and
why
and
come
to
your
other
question
like?
Why
do
you
even
need
to
do
this?
B
A
B
B
Yes,
so
basically,
this
thing
is
the
job
that
this
is
playing
is
deciding
of
this
money.
That's
held
up
on
chain.
How
should
it
be
split
up
and
we
can
like
change
that
off
chain
and
then
the
really
interesting
bit?
It's
like
this
still
has
a
weakness
like
if
I
want
to
translate
with
you,
I
still
need
and
on
ten
deposit
with
you,
but
you
can
play
this
same
game
with
virtual
channels.
So,
like
I
have
a
connection
to
a
hub,
you
have
a
connection
to
hub.
We
can
create
a
tic-tac-toe
game.
B
A
B
B
A
B
B
The
thing
that
I
haven't
shown
you,
which
I
won't
show
you
is
the
fact
that
you
actually
need
something
a
little
bit
different
than
just
these
allocation
outcomes.
You
need
something
called
a
guarantee
outcome
to
be
able
to
open
and
close
these
safely
with
the
hub
under
some
well
to
open
and
close
virtual
channels.
You
need
this
extra
sort
of
outcome
which
goes
beyond
this,
but
like
that.
That
really
does
begin
to
get
a
little
bit
subtle
to
see
why
this
at
first.
You
might
think
that
this
is
enough,
but
it's
not
I
think
well.
A
B
A
B
B
B
So
the
way
this
is
work
of
it.
I
haven't
said
this,
but
they
would
each
put
in
five,
and
if
this
came
out
as
eight
then
the
hub
would
be
balanced,
eight
to
eight,
so
the
hub
still
has
their
ten.
But
it's
like
moved
around
and
Alice
and
Bob
we've
got
their
eight
so
like
the
hub,
the
danger
for
the
hub
is
that,
like
it's
forced
to
resolve
that
and
it
doesn't
maintain
its
ten.
So
that's
the
safety
property.
D
B
D
B
A
B
B
B
We're
really
just
developing
a
protocol
and
the
other
people
can
use
for
this
various
stuff,
like
you,
can
already
write
these
games
like
tic-tac-toe
on
it
there'll
be
like
direct
channels.
They
will
need
to
do.
It
doesn't
support
this
legend
all
stuff
yet,
but
they
soon
will
do
the
stuff
that
we're
actually
building
is
a
wallet.
So
your
wallet
will
run
in
the
browser
to.
B
D
B
Thing
that
wallet
does
for
you
is
it
stores
the
states
it
does
the
signing
in
the
future.
It
will
check
that
the
valid
transition
function
is
true,
so
it
can
like
emulate
some
solidity
code
that
it
pulls
down
and
checks
that
your
wallet
is
not
signing
things.
It
responds
to
challenges.
It
allows
you
to
launch
challenges.
It
does
like,
basically
the
protocol
part
of
it,
so
that
you
can
just
focus
on
like
this,
the
the
game
part
of
it
and
that
wallet
and
then
the
other
thing
that
we're
building
is
like.
B
We
already
have
some
bots
that
support
that
protocol,
but,
like
the
other
thing
we'll
be
building,
is
the
hub,
the
intermediary
that
talks
that
wallet
so
like
from
you
as
an
application
developer,
you
won't
notice
whether
your
app
is
running
in
a
virtual
channel
or
in
a
ledger
tablet
or
channel
or
in
a
direct
channel,
and
the
way
you
code,
your
app.
You
know
at
some
point
in
the
future.
You
imagine
you
get
an
upgrade
where
your
your
state,
channel
application
will
run
completely
off
chain
without
you
making
any
changes
to
it.