►
From YouTube: How Filecoin Actors Work
Description
This talk given by zenground0 in July of 2022 takes a deep dive into the actors that make up the computational model of the Filecoin protocol. Learn about why Filecoin uses actors, the different types of actors, and what the current eleven available Filecoin actors do. Understand the upgrades that have occurred since mainnet launch. As the Filecoin Virtual Machine (FVM) is developed, the capabilities of Filecoin actors will greatly expand along with the potential for the Filecoin Protocol, by decoupling adding functionality from protocol upgrades and allowing for independent user actors.
Resources
Learn more about the FVM & Roadmap: https://fvm.filecoin.io/
Join Protocol Labs Launchpad: https://pl-launchpad.io/
FIPs: https://github.com/filecoin-project/FIPs
Chapters
00:00 Smart Contracts for a Smart Network
01:00 What are Filecoin Actors?
01:45 Blockchain Consensus
02:55 State Consensus Example
04:26 State Machine Blocks
06:29 State Machine Messages
07:26 Actor 'Objects'
08:36 Block Message 'Methods'
09:15 Visualizing Actors
10:37 Actor Code Deep Dive
12:50 Actor Send Method
13:36 Actor Gas Model
14:11 Message Sending
19:07 Why Does Filecoin Have Actors?
20:22 Types of Actors
21:53 Overview of Actors Today
23:04 Diagram of Actors & Storage Cycle
24:20 Blockchain Security & Critical Path
26:08 Actors & the On Chain Storage Market
27:10 Storage Cycle & Market Diagram
28:00 Payment Actors
28:30 The Future of Filecoin Actors
28:53 Current Updates Since Mainnet Launch
29:45 Actor Upgrade Process & Governance
34:04 Upgrade Example – Snap Deals July 2021
34:13 The FVM – Impact
35:57 FVM User Actors
37:07 User Actor Verifiable Storage
38:00 Filecoin Staking & Lending
38:55 User Actor Interaction with System Actors
40:36 Rollup Actors & Unlimited Potential
41:30 Retrieval Pinning Service
00:42 Wild Speculation: Blockchain Sharding
A
Welcome
everybody,
thanks
for
showing
up
I'm
going
to
talk
a
little
bit
about
filecoin
actors
for
the
next
hour,
so
yeah
five
coin
actors
are
they're
an
interesting
piece
of
the
system
to
try
to
understand
in
some
way
they're
kind
of
at
the
heart
of
file.
Coin
they're,
also
something
that's
going
to
change
a
lot
in
the
coming
year
or
two
there's
a
pretty
big
tectonic
shift,
which
I'm
going
to
try
to
cover
here
so
hopefully,
you'll
be
kind
of
ahead
in
thinking
about
not
just
what
the
network
is,
but
where
the
network's
going.
A
A
Okay.
So
we're
going
to
answer
three
questions
in
the
talk.
What
are
falcon
actors?
Why
do
they
exist?
And
what
are
they
going
to
look
like
in
the
future?
And
the
first
question?
The
answer
is
pretty
simple:
they're
hard-coded
programs
that
run
on
the
filepoint
blockchain.
So
if
you
understand
ethereum
style,
smart
contracts,
you
more
or
less
understand
filecoin
actors.
A
So
you
see
a
bunch
of
blocks,
some
forks
where
we're
not
exactly
sure
you
know.
What's
what's
real,
if
we
don't
have
a
consensus
protocol,
because
there's
a
bunch
of
different
possible
heads
but
the
way
the
blockchain
consensus
works,
is
it
finds
the
best
path
through
a
tree
of
possible
blocks
like
that?
A
A
Well,
you
have
a
state
defined
at
each
block
and
we're
going
to
keep
a
simple
example
in
mind.
So
all
blockchains
share
the
the
problem
of
dealing
with
with
payments
and
and
fund
allocation.
So,
let's
assume
a
simple
state
here,
where
we
have
three
addresses
at
the
thousand
at
42
at
900,
each
with
different
allocations
of
file
point.
A
A
So
that's
like
that
makes
sense
it's
working
well,
and
this
is
this-
is
like
how
blockchain
payments
work,
and
so
we
have
these
state
transitions
which
are
associated
with
a
block
and
we
have
a
starting
state
and
we
have
an
ending
state.
So
final
coin
actors
are
how
we
organize
these
state
transitions.
There's
an
internal
state
machine
to
file
coin
and
the
entry
point
comes
through
the
blocks
so
yeah
to
just
dive
a
little
bit
into
the
details
of
how
the
state
machine
is
connected
to
the
box
in
the
blockchain.
A
We
need
to
look
a
little
bit
at
what
blocks
look
like
so
blocks
are
made
up
of
really
two
things
so
there's
some
inline
data,
for
example
like
the
the
current
height
of
the
block.
It's
like
it's!
It's
count
in
the
total
history
of
blocks
and
some
other
things,
but
the
things
the
two
things
that
we're
most
interested
in
today
are
hash
pointers
or
cids,
so
you're,
probably
all
pretty
familiar
with
the
concept
of
a
hash
pointer,
but
a
pretty
quick
redux.
A
So
if
you
look
at
state
tree
pointer,
it
points
to
basically
a
giant
global
map
of
every
actor
in
the
system,
and
so
this
is
where
we
start
to
get
into
what
an
actor
is.
So
if
we
go
back
to
the
payments
example,
so
f,
1000,
f,
42
and
f
900
would
all
be
actors
they're
all
entities
on
the
blockchain
associated
with
some
amount
of
funds
yeah.
A
Now
the
messages
which
you
see
on
the
right
are
state
transitions.
So
there
are
logical
changes
from
the
state
and
every
block
contains
some
amount
of
messages
which
which
transition
the
state
from
the
state
before
the
block
to
the
state
after
the
block,
and
that
if
we
go
back
to
the
state
to
the
the
payments
thing,
each
message
is
what
is
actually
causing
the
transition
of
like.
Let's
send
one
file
coin
here
less
than
one
file
point
here
and
at
the
end
the
state
will
be
encoded.
A
The
new
state
is
encoded
somewhere
in
the
state
tree
pointer
among
the
actors.
So
let's
dive
a
little
bit
more
into
the
individual
things
we
see
at
the
bottom
of
the
trees.
So
you
see
the
triangles
I'm
trying
to
represent
that
we
have
some
some
merkle
tree,
which
is
making
some
kind
of
efficient
map
over
these
things
as
when
it's
all
like
hash
pointed.
A
But
let's
look
at
these.
These
leaf,
like
leaf
level
objects
inside
of
these
two
things,
so
the
actor
is
kind
of
the
focus
of
today's
talk.
These
are
objects
in
the
state
machine
and
I
can
actually
very
quickly
and
succinctly
describe
like
the
exact
bytes
for
you
right
here.
There's
like
only
four
things
in
the
top
level:
actor
in
the
file
coin,
state
machine
model
and
that's
there's
a
file
coin
balance,
which
is
something
that
we
kind
of
recognize
from
the
payments
example.
A
There's
also
a
nonce
which
is
like
this
typical
thing.
You
do
for
replay
attacks
across
the
board
in
all
blockchains
and
then
there
are
these
two
things
which
really
get
to
the
heart
of
the
actor
being
a
program
which
is
running
on
the
filecoin
blockchain.
So
there's
a
cid
pointer
to
actor
code.
So
the
code
that's
actually
executing
because
the
actor
is
a
program
and
there's
also
a
civ
pointer
to
actor
state.
A
An
actor
state
is
defined
by
the
actor
itself,
so
you
can
write
whatever
you
want
in
there
as
an
actor
and
you
get
control
over
what
bytes
you
write
and
at
the
end
of
the
day,
everything
is
compressed
into
the
cid
point
yeah
and
then
the
block
message
a
little
bit
less
important
for
our
talk
today.
But
it's
important
to
understand
how
these
things
change.
A
So
there's
like
a
two
and
a
from
addressing
actors
that
the
message
is
going
to
be
sent
from
and
sent
to
and
then
there's
a
target
method
to
call
on
the
actor,
because
actor
code
as
we'll
get
into
is
organized
into
methods,
because
it's
a
nice
modular
state,
machine
design
and
then
the
block
message
also
because
coming
from
outside
the
system
has
a
cryptographic,
signature
and
it
has
field
value,
transfer,
yeah,
that's
about
all
I'll,
say
about
messages,
so
yeah,
here's
just
a
little
blow
up.
So
I
like
to
visualize.
A
What's
going
on
so
the
in
terms
of
like
the
the
fully
reachable
graph
underneath
each
each
each
pointer
in
the
in
the
actor
states,
the
actor
is
just
these
four
fields,
two
of
them
just
totally
stop
right.
There
there's
a
nonce
and
then
there's
the
file
coin
inside
of
the
actor
and
the
code
pointer
is
fairly
simple.
A
A
The
state
pointer
contains
the
state,
as
I've
kind
of
gotten
onto,
and
I'm
trying
to
demonstrate
with
the
picture
here
that
you
can
kind
of
put
whatever
weird
shape
in
there
and
in
fact
you
do
see
like
just
kind
of
emergingly,
not
chaotic,
but
like
it's.
It's
not.
It's
there's
not
a
one
particular
shape
of
state
actors,
because
their
programs
they
make
their
state
look
the
way
that
is
best
for
them
to
use.
A
A
Yeah
actor
code,
leading
on
ethereum
smart
contracts
to
understand,
like
you,
have
code,
which
runs
everyone
who's
validating
a
block
is
running
these
state
transitions
started
by
these
messages
and
from
the
perspective
of
an
actor
it
has
code
which
is
separated
into
a
bunch
of
different
methods
in
a
kind
of
classic
state,
machine
style
and
actor
code
is
thinking
about
it
from
a
high
level.
It's
there's
a
pretty
simple
paradigm,
so
it
takes
in
every
method
and
an
actor
takes
in
parameters
passed
to
it
from
a
caller.
A
So,
there's
like
general
blockchain
state
that
it
can,
it
can
get.
There's
no
rights,
just
reads
like
okay:
what's
the
current
epic,
what's
the
like
random
beacon
at
this
epic?
What's
my
balance,
these
sort
of
things
that
are
not
directly
under
the
the
actor's
state,
there's
also
methods
for
reading
and
writing
the
state
underneath
the
actor's
state
cid,
which
is
pretty
important
for
persisting
changes
and
there's
also
cryptographic
verifying
signatures
and
a
variety
of
storage
proofs
which
is
pretty
important,
but
also
pretty
simple,
it's
kind
of
like
a
boolean.
A
Yes,
no
is
this
proof
valid
and
then
the
one
that
we'll
dive
into
a
little
bit
more
is
sending,
which
is
how
actors
interact
with
each
other.
So
this
again
models
the
ethereum
sends
thing
pretty
closely,
not
an
expert
in
ethereum.
So
I'm
not
sure
if
it's
exactly
the
same,
but
it's
the
same.
Definitely
the
same
in
spirit.
You
say
this
is
an
actor
I
want
to
send
to.
A
This
is
the
method
I
want
to
call
on
it,
and
these
are
the
parameters
to
pass
in
and
here's
some
funds
and
then
that
will
kick
off
a
a
series
of
calls.
Maybe
maybe
it'll
just
end
with
that
actors.
Writing
its
method,
that
actor
might
send
more
messages
to
more
actors.
Eventually,
at
the
end
of
the
day,
everything
will
run
and
you'll
get
an
exit
code
and
a
return
value
back.
If
there's
a
failure,
then
things
propagate
in
a
certain
way,
but
we
won't
get
too
much
into
that.
A
A
These
messages
and
state
transitions
are
happening
inside
a
block,
so
there's
a
gas
model
which
charges
and
that
is
again
just
classic
blockchain
smart
contract,
nothing
surprising
in
the
file
coin,
gas
model
yeah,
so
that's
actor
code
and
let
me
see
on
to
yeah
so
just
a
little
bit
more
about
about
message
sending
so
there's
like
a
I'm
trying
to
represent
a
little
call
graph
here.
All
these
day
transitions.
They
start
when
a
a
message
is
processed
in
a
block.
A
That's
that's
something:
we've
covered
a
bit
and
yeah
any
any
change
to
the
act.
To
the
the
file
point
state
happens
by
some
cascading
of
messages
calling
to
actors,
actors
changing
their
state,
saving
their
state,
maybe
calling
other
actors
and
so
on.
Yeah
messages
are
sent
to
a
method,
that's
kind
of
where
the
methods
show
up
when
you're
trying
to
understand
the
system-
and
I
guess
it's
important
to
reiterate
that
actors
are
responsible
for
their
own
state.
So
we
have
a
nice
segregation
between
different
actors.
A
A
Maybe
they
get
a
bit
complicated,
I
guess
when
you
send,
like
a
like
a
proof,
commit
message
to
to
prove
a
sector.
You
have
to
go
off
to
the
market
actor
to
tell
the
market,
hey,
I'm
proving
a
sector
with
like
this
deal,
id
yadda,
yadda,
yeah,
no,
no
obvious
yeah.
I
think
we
should
maybe
focus
on
the
specificate,
like
the
specific
part
of
the
system
in
the
next
section,
yeah
and
so
here's
our
second
question
to
answer
today.
So
great,
we
talked
yeah
totally.
B
A
Okay,
beautiful
so
when
you
say
multiple
actors
within
the
same
minor,
that's
I
think
where
our
first
point
of
confusion
might
be
so
yeah,
so
so
that
there
is
only
one
so
each
I'm.
Actually
I'm
actually
curious.
What
what
do
you
mean
by
that
like
when
you
say
one
minor?
Are
you
talking
about
like
a
minor
actor
or
you're
talking
about
like
a
mining
operation
with
multiple
actors
around
it.
B
My
understanding
was
like
more
so
the
latter,
maybe
I'm
incur-
maybe
I'm
incorrect
to
my
understanding.
So
I
always
thought
that
you
mentioned
that
an
actor
is
basically
like
an
object
which
goes
through
certain
state
transitions
or
via
some
messages
and
then
can
send
messages
to
other
actors
who
then
go
through
more
state
transitions
totally.
Yes,
and
so,
if
you
have
like
a
markets
actor
and
then
like,
I
guess,
a
proofs
act
or
the
minor
actor.
A
Yes,
yes,
and
I
think
your
question
was
what
are
the
implications
of
having
separate
file
coin
balances
per
actor
right
right,
yeah?
I
guess
so,
and
maybe
are
you
like
in
particular
thinking
of
like
I
run
a
mining
operation,
I
have
like
several
different
actors
on
chain
and
I
need
to
like
manage
the
funds
for
those
different
actors.
B
A
A
So
that's
like,
I
guess
one
answer
like
we
have
so
actors.
We
have
actors
which
are
around
for
fund
management.
There
is,
I
guess,
some
complexity
in
making
sure
that
you
have
the
right
amount
of
funds
at
the
right
times
that
you
can
process
transactions,
process
messages
which
do
important
things,
and
this
is,
I
think,
a
big
part
of
like,
like
the
the
difficulty
of
engineering
lotus,
there's
like
some
complexity
and
that's
like
one
piece
of
complexity,
yeah.
A
A
Oh
yeah,
great,
so
that
that
was
maybe
I'll
try
to
try
to
force
the
segways.
That
was
maybe
an
example
of
of
how
filecoin
is
complicated.
But
the
answer
to
why
does
filecoin
have
actors
is
because
filecoin
is
complicated.
So,
like
we
saw
our
first
example
of
payments,
where
you
just
send
funds
from
one
actor
to
another,
and
you
might
think
like.
A
Why
do
we
need
a
like
whole
state
machine
model
with
like
different
methods
and
many
different,
like
sorts
of
actors
potentially
in
order
to
enable
that,
like
you,
could
just
do
something
a
lot
simpler
like
you,
don't
need
a
full
state
machine,
you
could
just
do
you
know
bitcoin,
utxo
or
like
maybe
something
even
nicer,
simpler
and
the
other
thing
is
like
hey.
Well,
users
aren't
even
programming
these
things
like
this
is
just
these
are
all
hard-coded,
as
we
described
in
the
last
example.
A
All
the
code
is
fixed,
or
it's
like
changed
like
during
protocol
upgrades
so
like
why?
Why
have
all
these
actors
and
yeah?
The
answer
is
because
filecoin
is
complicated,
so
it
turns
out
like
a
shared
shared
set
of
state
shared
set
of
state
transitions
and,
like
these
shared
programs
running,
are
actually
required
for
the
network
security
which
we'll
get
into
yeah.
So
there
are
11
types
of
actors.
A
Then,
on
the
left,
we
have
the
system
actor
singletons,
which
are
really
in
the
mix
for
storage
and
there's
a
storage
market.
There's
a
storage
power
actor
keeping
track
of
these.
These
stored
bytes
of
every
storage
provider
on
the
network,
there's
a
fill
plus
actor,
which
deals
with
sending
around
the
data
cap
and
providing
storage
providers
with
more
power
if
they
have
less
data
in
their
sectors
and
then
there's
a
reward
actor
which
deals
with
a
somewhat
complicated
schedule
for
releasing
file
coin.
A
As
part
of
the
block
reward
and
then
there's
yeah,
I'm
just
throwing
out
f099
is
a
is
yeah.
It's
a
kind
of
special
account
actor
yeah.
So
the
there
are
three
which
I
won't
really
get
into
chronic
and
system,
which
are
more
about
like
the
next
level
of
like
kind
of
supporting
this,
the
abstractions
for
supporting
the
main,
the
main
application
on
the
filecoin
blockchain
of
like
enabling
verifiable
storage
they're
important.
But
that's
about
all
I'll
say
about
that:
yeah
cool.
A
A
The
two
main
things
that
they're,
that
the
current
system
of
actors
of
these
11
actors
is
doing
is
providing
payment
to
storage
providers
for
verifiable
storage,
and
so
that's
like
from
network
the
storage
provider
and
there's
also
a
important
but
secondary
flow,
which
provides
payment
to
providers
from
user
clients
who
actually
store
their
useful
data.
Inside
of
the
verifiable
shell
of
storage
provider
sectors,
so
I'm
using
these
little
stars
to
represent
these.
A
These
protected
assets
on
the
falcon
blockchain,
basically
like
special
state,
which
is
which
kind
of
gets
passed
around
and
the
flows
of
these
different
states
are
kind
of
nice
for
understanding
the
system
at
a
very
high
level,
and
there
is
some
interaction
with
the
external
protocol.
So
I
can
call
that
out
there.
A
They
get
storage
power,
the
power
actor
accounts
for
it.
During
the
block
validation
process,
the
power
actors
state
is
read,
and
this
allows
the
election
like
the
consensus
mechanism
to
give
blocks
randomly
to
the
providers
with
the
most
power
or
in
proportion
of
their
power
they
get
blocks
and
then,
as
part
of
block
validation.
These
miners
are
rewarded.
So
there's
like
this
implicit
call
from
block
validation
to
the
reward
actor,
which
then
sends
filecoin
to
the
storage
provider.
Actor,
and
you
know
the
cycle
kind
of
continues
so
yeah.
That's.
A
That
is
the
flow
of
of
file
coin.
You
know
you
can
see,
storage
comes
in
and
then
filecoin
is
transferred
from
reward
to
storage
provider
and
that's
more
or
less
what
filecoin
is
doing.
It's
trying
to
incentivize
people
to
store
yeah.
So
I'm
going
to
talk
a
little
bit
about
why
actors
are
kind
of
hard.
A
So
the
provider
could
get,
you
know
basically
drain
the
reward
actor
with
unearned
storage
and
it
would
get,
I
guess,
unearned
coin
and
then
there's
also
a
problem
with
the
protocol,
because
now
that,
because
this
is
all
connected
together
in
this
virtuous
cycle,
it's
become
like
an
unvirtuous
cycle
and
now
the
attacker
can
produce
more
blocks
than
it
should.
And
then
we
have
like
fork
problems.
A
We
have
double
spend
problems
like
classic
consensus,
failure
problems,
and
I
guess
similarly,
if
we
made
a
mistake
in
the
storage
provider
actor,
because
it's
trusted
code,
this
isn't
the
case,
but
if
an
attacker
could
do
arbitrary
things
in
their
storage
provider
actor
they
could,
for
example,
you
know,
ignore
their
proof
of
storage
or
I
don't
know,
send
they
could
add
an
extra
send
to
the
power
actor.
You
could
imagine.
If
someone
could
exploit
the
actor,
then
they
could
do
the
same
sort
of
thing.
They
could
get
fake
power.
A
The
system
would
read
it
and
the
same
sort
of
thing
would
happen
with
consensus,
failure
and
funds
draining
unfairly.
So
this
is
going
to
show
up
a
little
bit
later,
but
yeah.
It's
kind
of
important
to
remember
that
these
actors,
as
they
are
today,
are
on
the
critical
path
for
blockchain
security
yeah,
so
the
other
place.
The
other
thing
that's
worth
thinking
about
is
the
the
storage
market.
A
So
this
is
a
way
to
facilitate
client
and
provider.
Interaction
for
actual
useful
storage
of
data,
and
so
clients
will
provide
deals
and
those
deals
will
get
associated
with
a
storage,
provider's
sector
and
clients
have
flows
from
a
file
coin
through
the
market
to
the
storage
provider,
assuming
that
they
like
store
correctly
again,
this
is
very
simplified.
A
If
you
have
a
sector
that
is
packed
full
of
deals
which
have
been
verified
by
the
phil
plus
system,
then
you
actually
get
10
times
the
power
for
that
sector
than
if
you
just
had
regular
deals
or
if
you
had
nothing
at
all-
and
this
is
a
nice
again
simplified
schematic
of
how
these
things
interact
and
what
the
system
looks
like
and
just
quickly
again.
You
know
if
there's
a
problem
somewhere,
unlike
the
market
actor
or
the
fill
plus
actor,
you
have
potentially
a
like
massive
problem.
A
So
this
again
is
on
the
critical
path
for
blockchain
security,
and
then
payments
are
kind
of
simple
they're,
not
really
involved
with
like
this
critical
path.
They're,
just
able
to
send
funds
between
anybody
like
they
are
quite
important,
like
a
lot
of
users,
rely
on
their
multi-sigs
to
be
secure.
To
do
things
like
exchanges
would
be
very
unhappy
if
multi-sigs
were
were
no
good,
but
they
have
a
different
property.
They're,
like
kind
of
more
free-floating,
which
is
somewhat
of
a
transition
to
the
next
and
final
question.
A
So
what
are
these
actors
going
to
look
like
in
the
future,
and
the
answer
I
have
for
that
is
so
this
is
definitely
less
like
decided,
it's
not
real.
Yet
it's
still
the
future,
but
the
way
that
it
seems
like
this
is
going
to
shake
out
is.
We
will
have
two
layers:
we're
going
to
have
system
actors
which
more
or
less
correspond
to
what
I've
been
talking
about
so
far,
and
then
there's
also
going
to
be
user
space
actors
which
are
new
and
exciting.
A
So
in
order
to
motivate
at
least
from
the
actor
perspective,
the
transition
that's
happening
and
how
nice
it's
going
to
be.
I
want
to
talk
a
little
bit
about
how
actors
have
changed
since
mainnet,
so
there
have
been.
You
know
a
decent
amount
of
things.
So
we've
done
this
thing
called
snark
pack
optimistic
window
post
snap
deals
as
well
as
a
bunch
of
security
fixes
and
small
improvements.
A
Optimizations
and
that's
been
like
good
and
we've
gotten.
You
know,
I
think,
a
pretty
decent
amount
of
value
added
to
the
protocol
by
making
these
changes,
lots
of
like
cost
reduction
and
some
new
pretty
great
features.
But
it's
been,
you
know
like
almost
two
years
and
a
year
and
a
half
so
like.
Why
haven't
we
done
more?
And
so
this
is
where
we
kind
of
get
back
to
that
that
critical
security
path.
A
It's
a
you
know
a
file
coin
improvement
proposal
and
it
requires
a
lot
of
work
to
you
know,
get
this
idea
out,
gather
some
sort
of
consensus
and
and
think
things
through
part
of
the
reason
it
takes
so
long
and
we
want
this
sort
of
slowdown
is
because
of
the
security
constraints
like
right.
Like
we
saw
there's,
you
know
potentially
really
bad
things
that
happen.
If
we
make
an
error
in
the
in
the
the
main
system
actors,
so
yeah-
that's
that's
like
that's
part
of
it.
A
A
It's
just
inherently
slow.
So
these
things
together
bring
down
the
the
velocity
of
actors,
changes
and
then,
of
course,
there's
the
added
maintenance
costs.
Any
new
act
or
any
new
code
needs
to
be
maintained,
which
is
you
know,
potentially
non-trivial,
and
the
result
is
that
it's
hard
to
become
a
contributor.
A
You
have
to
have
a
lot
of
context.
You
have
to
understand
the
protocol
very
well,
it's
hard
to
decouple
changes
because
everything
is
kind
of
tied
together
and
you
don't
want
to
mess
up
something
in
a
far-reaching
part
of
the
system
by
changing
something
close
by.
So
even
if
you
have
a
good
plan
and
a
good
team,
it's
always
going
to
take
time
and
that's
more
or
less
the
way
it
has
to
be
so.
Here's
an
example.
A
I
won't
go
into
the
details
too
much
but
yeah
and
we
started
snapdeals,
which
is
a
way
to
quickly
add
in
data
to
a
sector
which
doesn't
have
data,
which
is
a
pretty
great
idea
and
there's
some
very
clever
construction.
I
we
started
thinking
about
it
in
july
and
took
to
march
until
we
actually
got
this
in
the
network
live
for
people
to
use,
which
is
you
know,
I
think,
was
pretty
good.
A
You
know
slow
enough
to
try
to
be
safe.
We
actually
introduced
the
bug
into
actors
on
the
upgrade
which
we
only
found
the
day
after
we
threw
it
in.
It
turned
out
that
wasn't
a
big
deal,
but
it
pretty
easily
could
have
been
a
big
deal.
So
even
when
we're
working
as
robustly
as
we
can
like
mistakes
still
slip
through
and
that's
like
the
maintenance
cost,
we
have
to
potentially
re-upgrade
something
like
that.
A
If,
if
something
really
bad
happens
and
yeah,
you
no
need
to
understand
the
details
here.
I
went
over
that
very
fast
or
even
like
how
it
connects,
but
basically
just
the
idea
that,
like
the
critical
path
for
blockchain
security
is
part
of
the
reason
for
the
slowness
of
development,
that's
really
what
I'm
trying
to
get
across
okay,
sweet!
So
now
we're
going
to
talk
about
the
fem
everyone's
talking
about
the
fdm,
it's
new
and
exciting,
but
it's
also
potentially
very
valuable
and
yeah.
A
I
think
it's
it's
pretty
easy
to
see
that
as
someone
who's
been
writing
actor
code
for
the
past
couple
years,
so
like
what
the
fbm
means
is
basically
no
fips
and
no
network
upgrades.
So
users
can
write
new
actors
they're
going
to
be
separated
enough
from
the
core,
the
core,
like
system
actors,
that
it's
not
going
to
be
as
security
critical
to
develop
them.
A
So
they
should
be
assuming
that
we
do
things
right
decoupled
enough
that
this
whole,
like
awareness
of
the
entire
protocol,
is
not
a
requirement
for
for
writing
them
and
also
they
should
be
deployable
at
any
point,
just
like
in
say
theory
or
any
other
regular,
smart
contract
platform.
You
can
just
throw
up
a
new
contract,
so
you
can
throw
up
a
new
actor
without
a
network
upgrade,
which
also
means
you
know
big
slow
down
in
that
from
that
perspective.
A
So
this
all
results
in
a
lower
barrier
to
contribute
so
no
fit
process
open
network.
It
also
means
because
of
the
way
that
we're
doing
things
there's
familiar
technology
backing
this
stuff
up.
So
that's
pretty
nice
and
ideally,
though,
of
course,
some
contracts
for
going
to
some
actors
are
going
to
want
some
more
deep
knowledge
of
the
final
coin
protocol.
A
It
probably
won't
be
as
required,
and
it's
still
going
to
take
time
to
write,
robust
smart
contract
applications,
but
hey
it
can
be
paralyzed
because
hopefully
things
should
be
much
more
decoupled
than
actually
writing
them
with
the
whole
filecoin
protocol
in
your
head,
so
yeah
so
like.
I
guess
a
couple
visions
for
what
this
is
going
to
look
like,
and
this
is
the
part
of
the
talk
where
I
kind
of
go
off
the
rails,
getting
excited
about
the
future.
A
So
take
it
all
with
a
large
grain
of
salt,
so
you
see
below
the
like
system
actors
doing
their
crazy
thing.
Keeping
the
protocol
going
and
one
potential
thing
that
we
you
could
imagine
and
will
probably
happen-
is
that
there
will
be
user
actors
which
don't
care
too
much
about
the
filecoin
protocol
and
will
just
do
their
own
thing.
A
I
just
talked
to
themselves
more
or
less,
you
know
maybe
they'll
use
like
multi-cigs
or
accounts,
we'll
probably
use
accounts
for
sure,
but
basically
they
won't
interact
with
the
the
core
storage
functionality
of
filecoin.
Like
you
know,
maybe
it's
like
somebody
throws
a
cryptokitties
clone
on
there
or
something
that's
kind
of
the
idea.
You
could
have
any
of
these
any
of
these
things
which
are
running
on
these
other
smart
contract
blockchains
running
on
filecoin-
and
you
know-
maybe
that's
like
pretty
good,
because
final
coin
is
a
useful
proof
of
work
system.
A
So
you
have
some
pretty
interesting
security
properties
and
you
have
some
interesting
fairness
properties,
but
yeah.
I
don't
know.
I
think
that
at
least
from
my
perspective,
what
what
is
really
interesting
about
the
fvm
and
programming
filecoin
is
that
the
the
filecoin
network
has
a
totally
new
totally
new
functionality,
which
is
verifiable
storage
embedded
into
the
model.
A
So
one
thing
that
you
hear
people
talk
about
a
decent
amount
is
the
concept
of
a
data
dial,
so
basically
like
a
dao
as
in
the
usual
dao,
but
it
manages
the
preservation
of
data
inside
of
filecoin
sectors.
We
don't
really
have
time
to
dig
into
how
that
works,
but
more
or
less
you
could.
You
can
kind
of
figure
out
like
it's
going
to
need
to
interact
with
storage
providers,
somehow
maybe
interact
with
like
the
power
actor,
maybe
interact
with,
like
the
field
plus
actor
the
market
actor.
A
Probably,
but
there's
going
to
be
some
interaction
with
the
rest
of
the
system
and
the
same
thing
goes
for
other
applications
which
seem
to
make
a
lot
of
sense.
So,
like
storage
providers,
you
know
need
capital
because,
because,
as
file
coin
is
complicated,
it
turns
out
you
need
to
stake
some
funds
in
order
to
get
certain
security
gains
for
the
core
protocol.
So
one
thing
which
people
have
been
working
on
is
like
actually
like
creating
legal
frameworks
and
like
business
agreements
for
lending.
A
It
could
be
quite
interesting
to
do
some
basic
d5
stuff
and
pull
user
funds
automatically
into
lending
actors
which
talk
to
storage
providers,
and
you
know,
deal
with
defaults
and
things
like
this
so
yeah
that
also
is
going
to
need
to
talk
to
storage
providers.
So
this
kind
of
the
error,
arrow,
pointing
between
the
system
actors
and
the
user
actors,
is
definitely
what
I'm
really
interested
in.
A
There's
also
a
lot
of
work
about
to
kick
off,
which
refactors
the
system
actors
in
a
way
that
it
might
be
easier
for
user
actors
to
call
into
them
and
get
the
right
sort
of
functionalities.
Yeah
yeah.
Basically
this
is
this
is
like
yeah.
This
is
this
is
what
I'm
thinking
it
will
look
like,
and
I
guess
a
key
thing
I'm
bringing
up
here
is
that
yet
the
user
actor
is
always
going
to
kick
off
the
interaction,
because
the
system
actor
needs
to
not
know
about
or
care
about
them.
A
A
So
like.
I
think
that
there's
a
lot
of
things
that
can
be
done,
and
it's
not
just
me
like
a
lot
of
people
at
protocol
labs
and
you
know
outside
of
protocol
labs,
are
excited
about
the
stuff.
You
can
do
and
there's
a
lot
of
different
things
I
could
have
thrown
up
here,
but
this
is
just
like
one
potential
synergy.
A
So
there's
this
group
of
protocol
labs
called
consensus,
lab
and
they're,
basically
working
on
like
charting
with
a
particular
sort
of
like
roll-up
actor
actor
roll
up
actor,
as
I'm
trying
to
demonstrate
here
it
has
as
a
state
pointer
a
whole.
Other
state
tree
has
like
a
whole
other
network,
and
the
idea
is
that
all
of
the
message-
validation,
stuff,
happens,
off-chain
and
then
like
there's
some
sort
of
delegation
of
disputes
to
the
the
main
chain.
So
that's
like
something
with
an
fbm.
A
A
I
don't
claim
to
have
any
idea
how
it
works,
but
definitely
an
interesting
idea
and
I'm
pretty
sure
their
plan
is
to
use
a
series
of
user-defined
actors
interacting
with
the
system
to
achieve
this
goal,
and
then
you
know
just
like
it's
just
like
a
few
like
I,
I
don't
know
a
few
hours
of
thought
you
can.
You
can
start
to
like
put
things
together.
It's
like,
while
a
wild
speculation
when
it
comes
to
blockchain
charting
like
the
data
availability
problem.
A
So,
like
big
question
mark
like
maybe
you
could
like
throw
these
two
things
together
and
maybe
we
could
have
like
a
really
good
answer
to
or
like
a
starting
good
answer
to
a
major
problem
which
is
like
blockchain,
sharding
yeah.
So
that's
like,
and
I
I
guess
like
there's
many
other
paths
you
can
take,
which
is
why
I'm
excited
about
the
fvm.
I'm
excited
about
actors
going
into
the
future,
and
I
think
you
should
be
too.