►
From YouTube: Smart Contracts on Plasma - Christian Reitwiessner
Description
Plasma is a system of blockchains proposed by Joseph Poon and Vitalik Buterin as a solution to the scalability problem. This talk shows how smart contracts can be implemented on such a system and explains why not all contracts are suitable as is. Primitives for the programming language Solidity are suggested that could ease cross-chain communications in such systems.
Slides: https://github.com/chriseth/notes/tree/gh-pages/talks/smart_contracts_on_plasma
Text version: https://medium.com/@chriseth/token-contracts-on-plasma-or-a-tale-about-local-and-global-invariants-e37fadba150
A
A
Will
start
at
the
very
beginning
and
explain
what
block
chains
are
and
what
I
mean
when
I
say
state
and
when
I
say
transactions,
and
we
will
see
that
block
chains
are
a
bad
idea,
because
they
can
only
process
a
limited
amount
of
transactions
per
time
for
a
second.
And
then
we
will
see
that
payment
channels
are
one
way
to
take
some
load
off
a
blockchain.
And
we
will
see
that
the
block
chains
only
act
as
verifies
and
not
as
processing
nodes.
A
And
this
is
already
a
good
start
and
yeah
then
we'll
see
how
payment
channels
can
be
extended
to
be
child
block
chains
and
how
this
can
be
reiterated
to
create
trays
of
block
chains.
And
that's
what
the
plasma
system
is
about
and
then
we'll
see
how
we
can
implement
or
that
the
key
to
implementing
scalable
smart
contracts
on
plasma
is
to
transform
global
invariance
we
want
to
have,
but
which
we
cannot
check
in
such
a
smart
contract
into
local
invariance,
which
we
can
check
and
we'll
see
examples
of
the
source
code
of
an
example.
A
A
Ok
blockchains.
We
start
with
the
first
part
of
the
word
blockchain,
which
is
block
and
let's
just
view
it
as
a
bunch
of
data.
But
and
then
here
comes
the
chain
part
in
the
blockchain.
Each
block
references,
its
predecessor
using
a
hash
pointer.
So
a
block
contains
a
cryptographic
hash,
so
a
fingerprint
of
its
direct
predecessor
and
that's
how
blocks
form
a
chain.
They
can
also
form
trees.
But
we
know
that
for
now
and
I.
A
Said
blocks
are
just
a
just
a
bunch
of
data
and
more
exactly
they
contain
transactions
and
in
order
to
explain
what
transactions
are,
I
have
to
tell
you
what
stages
and
in
the
example
of
a
blockchain
that
is
used
as
a
currency.
The
state
is
usually
just
a
list
of
participants,
a
list
of
accounts
and
their
respective
balance
at
a
certain
point
in
time.
A
A
Yes,
since
only
Bob
can
create
such
a
signature,
we
know
that
Bob
sent
the
transactions,
so
Bob
is
the
assumed
sender
of
the
transaction,
and
the
transaction
has
yeah
basically
calls
a
function,
it
runs
an
operation
and
this
operation
is
transferred
to
to
Ellis.
So
Bob
wants
to
transfer
two
tokens
to
Alice
and
when
this
transaction
is
included
in
a
block,
then
its
effect
on
the
state
is
calculated,
and
the
effect
is
that
Alice,
the
the.
A
Plasma
requires
a
smart
contract
in
a
block
chain
so
and
it
doesn't
work
on
a
special-purpose
block
chain
like
Bitcoin,
and
because
of
that
we
will
always
view
these.
So
this
this
transfer
function
is
a
function.
That's
actually
implemented
in
a
smart
contract
on
this
blockchain
smart
contactor,
just
programs
running
on
the
blockchain,
and
here
an.
A
A
That
is
performed
in
the
transfer
function
example,
so
it
checks
that
the
balance
of
the
sender
is
at
least
the
amount
the
sender
wants
to
send
and
if
the
check
works
out,
then
we
have
the
effect.
The
amount
is
reduced
from
the
balance
of
the
sender
removed
from
the
spell
of
the
sender
and
it's
added
to
the
balance
of
the
recipe.
A
A
B
A
For
participated
this
thing
and
of
course
the
the
underlying
smart
contract
would
check
that
Alice's
balance
on
the
main
chain
is
at
least
10,
otherwise
she
wouldn't
be
able
to
have
this
issue
a
balance
on
there
on
the
payment,
Channel,
okay
and
what
happens
now.
So
we
get
this
payment
channel
and
now
we
can
send
transactions
inside
this
payment
do
not
reach
the
blockchain,
so
they
only.
B
A
A
And
they
actually
blocking
the
screen
for
some
of
you
all
the
time,
I'm.
Sorry
about
that
when,
as
also
does
she
denotes
the
the
state
of
the
payment
channel
that
yeah
it's
as
soon
after
the
transfer
as
part
of
the
transaction,
so
Alice's
initial
balance
was
10
and
she
sent
three
tokens
to
Bob.
So
now
she
has
seven
and
Bob
has
degree
and
Alice
decides
it
so
transactions
that
this
whole
transaction,
which
means
she
confirms
that
in
her.
A
In
her
opinion,
this
is
the
current
state
of
the
payment
she'll,
and
she
also
adds
a
number
to
the
to
this
transaction.
The
payment
channel,
which
is
a
sequence
number
that
is
incremented
every
transaction
now
Bob,
can
send
a
similar
transaction
where
he
transfers
two
tokens
to
Alice.
The
increment
sequence,
number
updates
the
state
and
also
science,
a
transaction.
A
Okay.
Perhaps
you
might
ask
that
this
is
a
quite
stupid
example.
If
I
have
two
people
who
send
money
back
and
forth
all
the
time,
why
can't
they
just
agree
on
how
much
everyone
gets
and
that's
about
it?
The
idea
is
that,
of
course,
these
transactions.
Here
they
don't
appear
in
isolation.
There's
always
something
happening
in
the
real
world
or
in
the
real
digital
world
that
triggers
such
as
act,
for
example,
Alice
and
Bob
both
have
data
storage
and
they
just
store
data
for
other
people,
for
example,
for
Bob
or
Sohail.
A
It
stores
something
for
Bob
or
Bob
stores,
some
data
for
Alice,
and
they
request
data
from
each
other
and
each
time
and
this
requests,
50
megabytes
from
Bob
Bob
sends
one
token
to
Alice
and
then
at
some
later
time,
Bob
needs
dead
from
Ellis,
so
he
pays
for
the
data
and
so
on.
So
that's
one
of
the
purposes
of
such
a
payment
I'm.
Okay,
now
time
goes
on,
the
blockchain
continues
and
also
the
State
Journal
continues
and
at
the
transaction
number
80
Alice
has
four
tokens
about
the
six
tokens.
A
This
is
confirmed
by
Ellis
and
at
some
point
they
decide.
Okay,
let's,
let's
close
the
connection
and
close
the
channel
and
what
happens
now
is
that
Bob
creates
a
transaction
on
the
blockchain.
So
this
is
this
is
the
sec
transaction
that
happens
on
the
blockchain?
This
was
the
first,
and
this
is
a
second
and
Bob
calls
the
closed
channel
function.
A
Appends
the
current
state
of
the
state
of
the
channel,
as
noted
here,
and
also
the
signature
of
alice
from
this
transaction.
So
this
signature
here
is
the
signature
of
that
transaction
and
he
also
signs
the
the
full
blockchain
transaction.
So,
and
this
means
we
have
a
confirmation
from
Alice
that
this
is
this-
is
the
current
state
of
the
of
the
channel
and
confirmation
from
Bob
that
he
wants
to
close
the
channel,
and
he
also
confirms
this
state
of
data.
A
So
there's
one
thing
that
could
go
wrong
now
and
so
Bob
does
have
a
signature
from
Alice,
but
the
blockchain
doesn't
really
know
whether
this
is
the
most
recent
signature
of
Elsa.
Well,
that's
the
most
recent
state
of
the
state
channel
of
the
payment
channel,
for
example,
pop,
could
have
taken
that
this
signature
here
I
mean
that
wasn't
really
wouldn't
really
be
beneficial
for
Bob,
because
here
we
get
six
here
he
gets
only
brief,
but
yeah
you
get
the
idea,
I
guess
and.
A
C
A
F
A
Should
close
the
channel
before
going
offline
and
sure,
but
someone
is
usually
offline
that
could
close
the
channel
for
you.
So
if
you
have
I
mean
this
also
depending
the
Alice
loses
at
most
ten
tokens
when
she
doesn't
close
the
when
she
doesn't
watch
the
blockchain
and
depending
on
how
money
is
involved,
how
much
money
is
involved?
You
can
run
different
servers
in
different
continents.
If
you
want
to
be
extra,
secure
and
so
I
think
that
that
should
work
on
the
question.
A
G
A
Okay,
we
we
saw
that
some
of
the
protections
here
in
the
main
chain
were
removed.
That's
why
they
are
so
they
they
removed
here.
But
the
blocks
are
still
quite
full
here
and
the
reason
for
that
is.
We
can
use
payment
channel
pennants
only
between
two
people
and
if
we
want
to
allow
an
arbitrary
number
of
participants,
we
have
to
go
to
something
called
yeah
sight,
trains
or
child
trains.
Or
what
have
you.
A
Here,
so
these
child
trains
are
very
similar
to
payment
channels.
The
difference
is
that
they
run
a
full
block.
Chaining
block
chain
protocol
instead
of
just
this
single
payment
channel,
and
you
usually
do
not
close
them,
but
instead
at
regular
intervals,
you
just
post
the
current
state
of
the
chain
into
the
main
chain.
Okay,
let's
take
a
look
at
that.
A
A
Call
this
new
child
function
on
the
main
chain,
and
then
they
start
creating
their
child
chain
and
the
the
first
block
here
refers
to
this
creation
transaction
the
main
chain
and
after
that
the
blocks
just
referred
to
their
parents
in
a
regular
blockchain
and
they
contain
for
transactions.
They
contain
smart
contracts,
whatever
you
would
like,
okay
and
now
yeah.
A
So
as
I
said,
it's
a
full
blockchain,
so
it
it
also
has
state
and
the
the
way
this
reduces
load
from
the
main
chain
is
that
the
state
is
only
stored,
the
child
chain
and
not
in
the
main
chain
yeah.
This
is
due
to
limited
screen
size.
That's,
of
course,
a
bad
example,
because
usually
the
balances
would
start
with
zero,
but
yeah.
Let's,
let's
assume
that's
the
current
state
of
the
child
chain.
We
have
four
accounts
there,
it's
open
to
everyone,
so
people
can
just
go
there
and
create
new
accounts
I'm.
A
Currently
at
these
four
and
then
we
have
a
transaction
Cindy
transfers,
two
tokens
to
Bob
it's
the
same
times.
Actually,
we
had
in
the
previous
example
on
the
main
chain
and
the
effect
when
the
state
is
that
Cindy's
balance
is
reduced
by
two
and
Bob's
balance
increases
by
two
and
so
now.
The
interesting
part
is
that
we
also
have
these
special
transactions
on
the
main
chain,
which
call
a
function
called
store
hash.
A
These
these
functions
are
caught
by
the
people
responsible
for
managing
the
charge
chain
and
what
it
does
is
it
just
stores
the
hash
of
the
recent
Block
in
in
the
main
chain.
It
does
not
store
the
full
state,
just
the
hash
of
the
block,
which
also
includes
the
hash
of
the
state,
but
it's
yeah
very
little
information
and.
A
Since,
since
these,
the
people
that
are
responsible
for
the
charging
could
just
store
any
hash
here,
there
is
a
mechanism
where
any
user
can
object,
just
as
we
had
in
the
payment
channel.
So
when
Bob
wants
to
close
the
channel,
Ellis
can
object
and
then
a
process
decides
whose
faculty
was
wrong.
This
is
a
bit
more
complicated.
I
will
not
go
into
detail
here,
but
there
is
a
mechanism
to
object.
It
takes
some
time
and
you
have
to
also
have
to
yeah
provide
a
little
time
for
people
to
react.
A
This
can
be
used
by
participants
in
the
child
train
to
send
tokens
to
the
main
chain,
and
here
Cindy
wants
to
send
two
tokens
from
the
charge
onto
the
main
chain.
This
effectively
reduces
her
balance
and
it
looks
like
the
tokens
would
vanish,
but
that's
not
the
case
because
she
successfully
executed
exactly
the
transaction,
and
this
means
it's
stored
inside
the
history
of
the
child
chain
forever,
and
what
Cindy
can
now
do
she
waits
until
there's
in
the
next
store
hash
call
on
the
main
chain?
H
I
A
I
E
G
G
A
This
to
parent
transaction,
so
they
are
completely
gone
and
okay.
Let's
perhaps
that
that's
continued
here,
what
happens
in
the
main
train?
Then
I'll
finish
answering
the
question.
So
we
have
this
store
hash
function
here,
which
means
that
the
main
chain
can
look
into
the
history
of
the
child
chain
and
see
this
two
parent
transaction.
So
Cindy's
tokens
become
available
at
this
point,
and
this
allows
Cindy
to
actually
spend
these
tokens
so
and.
A
Yeah
perhaps
this
should
not
be
called
transfer
but
finished.
Sending
from
childÃs
I
think
that
so
at
this
point
the
tokens
reappear
here.
They
they
disappear,
and
here
they
reappear
in
the
main
chain.
So
you
and
in
a
similar
way,
if
you
send
tokens
from
the
main
chain
to
the
tire
chain,
they
completely
disappear
in
the
main
chain
and
it's
impossible
to
spend
them
because
they
are
just
gone.
A
No,
so
not
at
all,
I
mean
actually,
so
this
is
again
due
to
lack
of
space.
In
reality,
Cindy
has
to
wait
for
some
blocks
to
be
added
here,
because
she
has
to
wait
that
someone
could
object
to
this
store.
Hopper
store
hash
operation
here
and
only
after
some
time
our
passes
nobody
objected,
then
this
is
assumed
to
be
the
current
state
of
the
type
chain
and
people
can
use
this.
A
F
A
A
F
A
Yeah
sure,
it's
always
afraid
of
you,
don't
get
our
choice
to
get
a
bit
of
scalability
for
free,
but
so
the
question
is
already
pointed
into
that
direction.
How
can
we
increase
the
number
of
charge
chains
here
and
the
way
you
would
do
it?
Is
you
create
a
tree
of
block
chains
so
in
this
diagram?
There's
no
there's
no
component
of
time.
A
We
have
a
main
chain
which
would
continue
somewhere
here
and
then
this
main
chain
has
three
charge
chains.
Each
of
them
would
continue
somewhere
here
and
then
these
three
child
chains
again
have
three
child
chains
and
again,
of
course,
if
you
want
to
move
tokens
around
here,
this
involves
quite
some
jumps
between
chains.
I
took
at
your
point,
yes,
but
you
could
also.
Let
me
think
you
can
also
create
a
payment
channel
between
this
chain
and
that
chain
you're
only
so
you
don't
have
to
move
up
and
down
again.
A
You
only
have
to
wait
until
the
the
state
of
this
chain
got
committed
here
and
there
and
then
into
the
main
chain
and
nobody
objects.
Then
this
image,
2
Chainz,
is
established.
Okay,
before
I
get
worldly
to
do
so.
What
happens
here
is
that
so
we
have
this
main
chain,
and
we
know
that
through
child
chains-
and
this
means
that
this
child
chain
regular
regularly
commits
its
current
state
into
the
main
chain
and
and
then
we
know
this
child
chain
we
have.
J
A
So
there
is
a
kind
of
incentive
to
move
common
parts
into
the
same
child
chain.
Yes
and
I.
Guess
that
is
something
that
could
be
done.
I
mean,
of
course,
a
smart
contract.
Blockchain
always
has
special-purpose
small
contracts,
and
then
it
also
has
general
or
then
it
has
contracts
which
provide
the
glue
between
some
special-purpose
contracts
and
these
glue.
A
Are,
for
example,
token
contracts?
If
you
have
a
token,
then
you
want
to
use
it
with
all
kinds
of
different
smart
contracts
in
different
different
chains
and
these
tokens
you
have
to
move
between
the
chains,
but
there's
special
purpose
contracts,
eternally
okay,
and
how
am
I,
how
well
does
it
state?
So,
let's
assume
the
main
chain
and
also
each
child
chain-
has
ten
transactions
per.
Second
is
roughly
the
bandwidth
of
etherium
and
Bitcoin.
A
We
already
told
about
the
over
hat
that
comes
in
comes
with
moving
tokens
around
and
also
committing
the
state
hash,
and
probably
also
objections
and
resolving
these
objections
and
so
on.
But
since
these
child
chains
are
special-purpose
and
since
they
are
probably
not
proof
of
work,
we
I
think
it's
reasonable
to
have
something
like
100
sections
per
second,
including
this
overhead
and
so
I.
Think
ten
transactions
per
second
is
good,
so
we
we
have
four
levels
in
this
tree
on
the
left
in
the
diagram.
B
A
G
E
E
A
A
I
I
A
A
A
A
If
someone
creates
an
invalid
block
in
in
some
of
the
trains
on
the
way
from
Alice's
chain
to
the
to
the
main
chain,
then
this
also
destroys
the
state
in
all
of
the
chains
below
that,
because
that
is
the
point
where
you
could
object.
So
if
you
destroy
the
state
here
and
someone
attacks
that
chain
here,
then
you
can
object
here
anymore,
because
this
is
kind
of
this
change.
E
A
Okay,
of
course
it's
not
always
you
have
to
watch.
You
can
also
ask
others
to
vote
for
you,
and
so,
for
example,
Bob
has
talked
it's
in
these
two
sub
chains
and
he
has
to
watch
these
chains,
and
here
we
already
see
the
closer
the
chain
is
to
the
main
chain,
the
more
likely
it
is
that
others
are
also
watching
actually.
So
this
in
turn
means
the
closer
you
are
to
the
root
chain,
the
safer
it
should
be
because
more
people
are
watching.
So
if.
A
A
A
B
A
Thing
that
is
perhaps
not
so
obvious
is
actually
more
complicated
to
ensure-
and
this
is
nobody
should
be
able
to
create
tokens
out
of
thin
air,
because
if
I
have
ten
tokens
and
someone
is,
is
able
to
create
1
million
tokens,
then
my
tokens
are
basically
worthless
and
also
that
too,
that
that
person
can
buy
stuff
from
you
actually
paper.
So,
but
this
is
a
problem
you,
so
we
assume
that
this
token
smart
contract
is
deployed
in
all
of
these
chains
here
and
let's
see
what
the
next
thing
is.
Yes,
charlie.
A
Uses
this
chain
here
and
we
assume
that
he's
the
only
one
using
that
chain,
so
he
can
try
to
create
arbitrary
amount
of
tokens
and
if
nobody
watches,
then
he
will
actually
have
these
tokens
inside
that
chain
and
the
only
way
to
prevent
that
is
again,
everybody
watching
all
chains.
But
that's
exactly
what
we
wanted
to
avoid
right.
A
Okay,
there
is
a
yeah
kind
of
solution
that
does
not
solve
this
problem,
but
it
solves
a
similar
problem
and
the
idea
is
okay
right.
The
idea
is
that
okay,
Charlie
can
create
tokens
here,
but
we
can't
really
use
them
because
he
has
to
move
them
to
a
chain
where
someone
else
is,
or
he
has
to
convince
other
people
to
come
to
his
chain
and
that's
the
key
to
the
to
this
problem
to
the
key
to
the
solution,
because.
A
Yeah
moving
these
tokens
will
be
difficult
if
we
do
an
additional
thing
if
we
track
the
balances
of
each
direct
sub
chain.
So
let's
see
how
that
works.
So
in
the
token
contract
of
the
main
chain,
we
store
that
inside
this
left
branch
we
have
a
total
sum
of
nine
tokens,
and
this
middle
branch
may
have
a
token
sum
of
eight
tokens
and
this
right
branch.
We
have
a
total
sum
of
five
tokens
and
we
do
that
in
our
chains.
I
just
didn't
write
the
numbers
here,
because
the
front
would
have
been
too
small.
A
A
This
line
and
what
Charlie
can
do
now
is
he
can
try
to
move
his
1
million
tokens
up
to
the
main
chain
and
down
again
to
Ellis
or
box
chain,
but
the
problem
is,
he
won't
be
able
to
move
it
to
the
main
chain.
So,
let's
assume
he
controls
this
chain.
He
also
controls
that
chain
and
he
also
controls
that
trade.
He
doesn't
control
the
main
chain
and
he
has
to
invoke
this
transfer
to
a
parent
function
and
in
the
parent
chain.
A
Basically,
he
he
calls
it
and
says:
I
want
to
transfer
my
1
million
tokens
from
this
child
chain
to
the
parent
chain,
but
the
parent
chain
knows
that
the
total
sum
of
all
tokens
in
this
chargin
is
only
5,
so
it's
impossible
to
of
100
million
possible
to
move
1
million
tokens
into
the
main
chain,
because
there
are
somehow
only
5
tokens
in
this
charge
into
somewhere.
Something
must
have
gone
wrong.
D
D
A
D
A
A
And
so
even
that,
that's
also
something
you
have
to
realize
so
Charlie,
regardless
of
how
you
implement
this
mechanism
Charlie.
If
Charlie
can't
rank.
If
Charlie
controls
these
chains
here,
then
he
is
able
to
steal
these
five
tokens
from
all
the
other
persons,
because
we
assume
that
only
this
chain
only
the
main
chain
is
secure.
So
if
Charlie
tries
to
move
five
tokens
into
the
main
chain,
even
though
he
doesn't
really
legitimately
have
them,
he
will
be
able
to
do
that,
so
he
can't
steal
from
other
people.
A
E
E
G
G
A
G
A
A
A
Yes,
and
what
essentially
happened
here
is
that
we
had
these
two
conditions:
nobody
can
steal
from
you
and
nobody
can
arbitrarily
create
money
and
the
first
one
was
a
local
condition.
The
second
one
was
a
global
condition,
but
we
were
able
to
transform
it
into
a
condition
which
is
similar
but
which
is
fully
local
or
it's
locally
enforceable,
and
it's
similar
because
people
can't
steal
money
from
you.
They
only
can
steal
up
to
this
amount
and
they
only
can
steal
from
you.
If
you
don't
watch
the
chain
all
right
now.
A
A
A
This
is
how
you
could
implement
such
a
token
contract.
Very
specifically,
it's
specifically
in
the
plasma
system.
This
is
a
slight
variation
of
standard
solidity
and
we
have
we
have
a
token
contract
here.
It
has
a
mapping
of
balances,
and
it
also
has
this
special
three
integer
values
which
attract
the
sums
of
the
balances
in
the
charges
or
which
are
where
the
tokens
are
locked
and
so,
and
this
first
function
is
the
regular
transfer
function
that
is
present
for
all
regular
tokens.
A
So
this
can
be
used
to
transfer
a
token
from
one
account
to
another
account
in
the
same
chain.
You
specify
recipient
and
amount.
It
checks
that
you
have
the
required
balance
and
then
it
removes
the
balance
from
your
account
and
adds
it
to
the
recipients
account.
Okay.
Now
so,
and
then
we
have
these
two
functions:
transfer
to
child
and
transfer
to
parent.
These
are
special
because
they
are
marked
with
the
edge
keyword
and
when
functions
are
marked
with
an
edge
keyword.
A
They
are
kind
of
executed
on
an
edge
inside
this
tree
graph,
and
this
means
they
are
executed
both
on
the
parent
and
on
the
child
and
on
so
this.
This
transfer
function.
When
you
run
that
in
such
a
complex
multi
blockchain
system,
you
would
specify
which
blockchain
you
send
it
to,
that
has
to
be
part
of
the
actions.
Otherwise,
people
could
just
grab
your
transactions,
send
it
to
another
object.
You
want
to
avoid
it.
So
every
blockchain
has
a
unique
identifier,
and
this
has
to
be
part
of
the
time
transaction
and
for
an
edge
function.
A
You
send
it
to
a
relative
parent
and
to
a
relative
child
at
the
same
time,
and
what
happens
here
is
we
have
a
a
section
marked
parent
in
this
code,
and
this
is
the
section
that
will
be
run
on
the
parent
and
we
have
a
section
marked
with
child
and
that's
the
section
that
will
be
run
on
the
child
and
they
will
run
in
sequence,
so
they
will
not
run
in
parallel
and
what
happens
on.
The
parent
part
is
that
we
again
check
that
the
balance
of
the
sender
is
at
least
the
amount.
A
We
remove
the
balance,
the
amount
from
the
sender's
balance,
and
we
add
it
to
the
sum
of
the
balances
in
the
child
and
that's
where
it
stops
for
the
parent
and
the
parent
will
using
using
events
in
the
register
that
this
happened
on
the
parent.
And
then
the
system
has
to
wait
for
the
child
to
acknowledge
the
block
where
this
transaction
is
present
in
the
parent.
So
it
has
to
wait
from
a
transfer
of
the
state
from
the
parent
to
the
child,
and
then
this
part
can
be
executed
on
the
child.
A
The
the
client
will
send
exactly
the
same
transaction
that
it
sent
to
the
parent
it
will
Center
the
child
and
because
the
child
locks
in
knows
that
it
is
the
relative
child.
It
will
skip
this
parent
part,
but
instead
it
will
verify
that
the
parent
part
execution
happened.
So
it
will
look
into
the
into
the
state
root
of
the
parent
blockchain
and
will
request
a
local
proof
to
verify
the
this
that
to
verify
this
implicit
event.
A
So
if
you,
if
the
child
blockchain,
would
not
verify
the
event
in
the
parent
blockchain,
you
could
increase
your
bands
arbitrarily
because
it
just
said
the
transaction.
The
parent
part
is
skipped,
and
this
adds
something
to
your
balance,
but
because
it
actually
checks
that
the
parent
part
was
executed
and
the
amount
was
reduced
from
your
balance.
Here
this
this
is
safe
and
we
have
a
similar
function
that
has
transferred
to
parent
here.
The
child
part
executes
first,
it
checks
that
we
have
the
balance.
It
removes
our
balance.
A
H
H
A
A
Yeah
I
mean
yeah
the
YouTube
child.
The
proposed
specification
I
mean
the
number
of
children
that
doesn't
really
matter.
You
just
have
to
know
the
topology
of
the
of
the
system
and
then
I
mean
if
he
sends
it
to
so.
A
parent
has
to
know
who
are
its
child.
Children
and
the
children
have
to
know
who
is
the
parent,
but
you.
G
B
A
So
this
this
check
that
happens
between
these
two
sections,
that
that
should
also
include
the
waiting
time
for
the
section
I,
don't
know
so.
Yes,
that's
abstracted
away
when
we,
we
assume
that
we
have
a
blockchain
system
that
works
within
with
objections
and
transfer
of
information
using
these
hashes,
and
perhaps
we
have
to
wait
for
the
time
or
perhaps
there's
a
faster
way.