►
Description
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.
In this episode, NEAR Co-Founder Illia Polosukhin teams up with Juan Benet, founder of Protocol Labs, IPFS, and Filecoin. IPFS is a distributed system for storing and accessing files, websites, applications, and data and Filecoin is a decentralized data storage marketplace, protocol, and cryptocurrency.
~~~~~
⛓️ 🔗 Useful Links 🔗 ⛓️
Website: https://research.protocol.ai/authors/juan-benet/
Filecoin: https://filecoin.io/
IPFS: https://ipfs.io/
AMA on Filecoin: https://www.youtube.com/watch?v=p4GatFzE3pM
~~~~~
🌐 Join NEAR's community 🌐
Website: https://near.org/
Apps on NEAR: https://awesomenear.com/
Reddit: https://www.reddit.com/r/nearprotocol/
Discord: https://near.chat/
Create a wallet: https://wallet.near.org/create
Medium: https://medium.com/nearprotocol
Blog: https://near.org/blog/
Twitter: https://twitter.com/NEARProtocol
GitHub: https://github.com/near https://github.com/nearprotocol
Dev Docs: https://docs.near.org/
Learn to Build On NEAR: https://www.near.university/
Grants & Funding: https://near.org/grants/
#Blockchain #FutureisNEAR #NEAR #nearprotocol
#nft #dao
B
B
B
And
you
want
to
enable
this
to
happen
with
crypto
in
a
decentralized
network
with
you
know:
high
integrity
and
verifiability
of
the
storage
and
all
kinds
of
stuff
but
yeah.
So
how
do
we
get
there?
Liberty
first
and
won't
dive
into
too
much
detail,
but
liberty
is
a
modular
network
stack
that
lets.
You
connect
all
of
the
lets.
You
connect
lots
of
different
peers
using
peer-to-peer
protocols
use
using
cryptography
that
doesn't
rely
on
any
kind
of
central
authority
or
anything
like
that.
B
It's
all
self-certifying
crypto,
so
that
means
you're
using
mostly
public
key
crypto,
and
it
deals
with
a
bunch
of
important
self-description
constraints
to
enable
many
different
kinds
of
protocols
to
right
on
top
of
liverpool.
This
is
why
now
lipidpp
is
used
by
a
ton
of
different
blockchains
to
build
build
up
their
their
system.
B
Then
it
gives
you
things
like
pub
sub,
there's
a
lot
of
different
protocols
that
can
give
you
this
and
so
on.
There's
a
bunch
of
different
kinds
of
network
protocols
that
you
may
want
to
use
in
a
peer-to-peer
network
and
liberty,
just
kind
of
assembles
a
lot
of
different
interoperable
modules
that
you
can
kind
of
plug
in,
like
lego,
bricks
into
building
some
peer-to-peer
protocol
and
any
questions
so
far.
A
I
think,
like
I
mean
for
me.
Obviously,
I'm
always
interested
in
dht's
kind
of
and
specifics
of
like
when
they
applied
in
a
protocol
like
how,
because
of
economics
they
can
be
broken
right,
yep
and
because
there
is,
you
know,
there's
a
lot
of
attack
surface
on
this
layer,
yep
that
people
usually
don't
mention,
but
we
can
dive
in.
I
guess.
B
Yeah
progress,
yeah,
that's
a
great
point.
You
know
I
tend
to
think
that
most
blockchains
are
kind
of
broken
in
the
in
the
message
passing
layer
of
like
the
broadcasting
of
the
of
the,
but
I
guess
nope.
Nobody
has
quite
attacked
that
layer
very
much
yeah
one
thing
to
mention
with
a
lot
of
the
lippier
p
modules
out
there.
B
There
are
good
incentivized
analogs
that
have
that
that
are
good,
open
problems
to
build
right,
so
people
could
go
and
build
an
incentivized
dht
people
could
build
incentivized,
pub,
sub
and
so
on,
and
all
of
those
kind
of
are
like
really
good
primitives.
That
could
build
a
much
more
robust
web
3
in
blockchain
systems,
and
so
it's
one
of
these
things
where,
like
those
could
be
extremely
good
primitives
for
people
to
to
then
depend
on.
B
Yeah,
exactly
and
actually
many
right,
because
there
are
probably
probably
a
few
dozen
different
variations
in
the
hd's
that
give
you
different
kind
of
properties,
and
so
out
of
those
you
might
end
up
with
like
three
to
five
different
dhts
that
offer
you
those
different
properties
that-
and
you
know,
there's
like
five
instant
device
networks
here
or
five
instead
of
networks.
Here.
A
B
B
What
that
means
is
that
all
of
this
information,
whatever
mypic.jpg,
is,
is
not
defined
in
the
network
until
the
moment
you
you
fetch
it,
and
you
view
it
so
you
this
is
like
a
very
kind
of
weak
security
and
it's
tuned
for
mutability
and
so
on.
But
but
this
gives
you
like
an
extremely
shaky
foundation
where
everything
sort
of
depends
on
the
the
party
that
controls
this
domain
and
the
parties,
the
parties
that
control
these
servers
yeah.
So
what.
A
B
Yeah,
which
is
also
very
shaky,
super
super
problematic,
so
what
episode
does
is
like
instead
of
this,
you
want
to
map
this
into
a
hash
tree,
so
that
means
ideally,
you
want
to
resolve
this
into
something
like
this.
These
are
like
the
old
iphone,
sashes
kim
fu,
suppose
that
this
is
like
you
know
some
like
large
hash
that
identifies
what
my
picture.jpg
is
and
you
can
build.
B
I'm
gonna
describe
how
we
build
up
a
you
know
arbitrary
content
into
a
graph
like
this,
but
the
idea
is
that
from
here,
then,
you
can
ask
who,
in
the
network
has
this
content
and
from
there
you
might
get.
You
know
the
old
server
1.2.3.4
or
you
might
get
some
other
server
like
you
know,
5.6.7.8,
although
of
course
like
you
want
to
use,
cryptographic
addresses
not
just
ip
addresses,
so
this
is
kind
of
like
yeah.
B
A
C
B
To
this
hash-
and
this
idea
of
like
using
hash
links,
is
fundamental
to
most
data
structures
in
the
web3
world
and
and
and
so
on.
It's
like
the
fundamental
thing
that
makes
bittorrent
work,
the
fundamental
thing
that
makes
git
work
and
all
of
the
blockchains,
so
the
idea
of
ipfs
is
like
let's
take
that
fundamental,
primitive
and
and
address
all
content
on
the
web.
This
way,
and
so
this
is
what's
called
content
addressing.
B
B
B
And-
and
these
might
give
you
like
some
like
block
level
storage,
which
you
know
sort
of
splits
up
this
disk
in
a
bunch
of
regions
that
you
can
address-
and
this
gives
you
usually
some
kind
of
like
either
relational
or
key
value
store
model,
but
either
either
way
in.
In
this
case,
you
end
up
building
a
file
system
hierarchy
which
you
know
ends
up
being
like
it.
B
B
B
We're
just
hash
links,
secure,
hash
links
that
give
you
integrity
and
verifiability
and
so
on,
and
so
you
can
take
all
the
data
inside
of
disks
of
all
the
data
inside
databases
and
then
expose
it
to
the
world.
Through
this
interface
of
of
hash
links,
we
call
our
hash
links,
content,
identifiers
and
there's
a
bunch
of
details
as
to
why,
what's
kind
of
in
the
cid
format,
it
gives
you,
cds,
decorate
a
hash
with
some
other
information.
B
So
you
know
how
to
interpret
this
hash
because
hash
functions
might
break
hash
functions,
might
change.
They
have
different
computational
requirements.
You
might
want
to
change
which
function
you
use
here,
and
so
you
should
just
sort
of
describe
the
the
function
that
you're
going
to
use,
and
you
also
describe
the
encoding
of
the
data.
This
is
pointing
to
this.
B
At
the
end
of
the
day,
is
a
pointer
it's
pointing
to
some
data
structure
over
here
and
also
there's
like
a
a
versioning
identifier
to
know
like
how
to
read
this
and
there's
a
a
base.
So
I
won't
go
super
into
detail
here,
but
the
idea
is
like
the
core
pointer
in
in
any
ipfs
system.
Is
these
cids
that
give
you
effectively
a
memory
pointer
like
in
any
operating
system
or
any
programming
language,
or
anything
like
that?
B
But
it's
a
pointer,
that's
secure
and
that
works
across
distributed
systems
and
that
works
out
of
cryptography
so
get
so
a
way
to
kind
of
the
way
we
think
about
it.
Is
it
gives
you
kind
of
access
to
this
sort
of
like
universal
memory,
that
you
can
store
any
information
in
and
retrieve
it
later,
just
by
knowing
the
cid
of
it,
and
that
could
be
a
single
little?
C
B
A
B
C
C
B
B
B
So,
for
example,
we
tend
to
think
of
it
as
the
internet
of
data
structures,
where
you
might
have
a
network
like
git
and
a
network
like
bitcoin,
and
a
network
like
unix
fs,
which
is
the
default
ipfs
one
and
get
files
sort
of
like
all
point
to
each
other
and
so
on,
and
they
kind
of
have
local
references.
So
it
get
it's
hard
for
again.
B
C
B
B
B
C
B
Is
kind
of
like
the
this
point
like
the
v
table
in
serious
equals
plus
world,
where
you
have
like
the
functions
and
the
date,
the
you
know
the
program
in
one
that's
going
to
decode
the
rest
of
the
thing.
So
this
lets
you
build
this
kind
of
like
a
distributed
programming
language
on
top
of
all
the
stuff,
but
we
sort
of
like
built
it
up
out
of
underlying
primitives.
B
So
so
out
of
this,
like
kind
of
the
option
of
this
is
that
we
have
a
way
of
addressing
all
kinds
of
content,
whether
it's
like
in
legacy
file
systems
or
in
legacy
databases
or
in
any
of
the
new
web3
hash
link
things
by
just
decorating
all
the
links
along
the
way
with
the
cids
and
then
out
of
that
we
get
verifiability
integrity.
Checking
we
get
the
ability
that
anybody
can
service
this
content.
C
C
B
B
Set-
and
so
you
can,
you
can
just
absorb
all
all
the
data
generated
by
any
hash
link
system
you
can
just
plug
in
and
you
can
move
it
around.
So
we
have
like
examples
of
like
moving
around
raw
get
repos
or
like
different
blockchains
and
whatnot,
okay,
cool,
so
and,
and
maybe
another
component
of
ipfs
is
that
so
that
gives
you
content
addressing
and
it
gives
you
the
the
peer-to-peer
networking
of
liberty
p.
B
So
it
brings
all
of
that
in
to
give
you
this
kind
of
secure
web
based
on
content
addressing,
and
it
also
solves
a
lot
of
you
know
very
pragmatic
problems
of
how
do
you
make
this
work
in
os's?
How
do
you
make
this
work
in
browsers?
How
do
you
make
this
work
in
mobile?
So
just
a
bunch
of
implementations.
B
You
know
the
abifas
link
right,
so
dot
com
or
dot,
eth
or
whatever
or
dot
whatever
you
want,
and
then
some
some
other
content
and
one
component
I'm
missing
here-
is
this
padding?
So
if
we
do,
you
know
a
b,
c
and
so
on.
This
is
just
resolution
through
this
graph,
so
we
can
do
something
like
you
know:
food.com
or
food.eth,
get
a
cid
and
then
traverse
this
graph
by
following
the
links
here
described
here,.
B
B
A
B
If
you
use
the
hash,
then
you're
set,
but
it's
all
kind
of
you
don't
have
the
immutable
references.
If
you
have
mutable
references,
then
you
need
something
that
can
resolve
those
mutable
references
and
that
traditionally
is
a
name
system.
So
you
know
you
can
use
dns,
but
you
can
use
any
anything
else.
B
There's
a
sub
protocol
here
called
dns
link
that
lets
you
do
that,
so
you
can
take
a
traditional
dns
name
put
in
a
hash
link
as
a
text
record,
and
this
works
today
and
it's
sort
of
already
in
brave
and
opera
and
other
browsers,
and
if
you
don't
have,
if
your
browser
cannot
speak
ffas
yet,
then
you
can
use
either
an
extension
to
enable
it
or
you
can
use
a
gateway,
the
gateway.
Is
there
only
to
kind
of
enable
browsers
that
don't
yet
speak
ipfs
natively.
C
B
B
So,
for
example,
if
you
and
I
are
working
together
on
a
computer
or
different
computers
and
I'm
trying
to
look
for
some
content
that
you
have
and
our
computers
can
talk
to
each
other
over
the
local
area
network,
I
should
be
able
to
get
the
content
from
you
and
that
doesn't
mean
like
we
could
form
a
local
dht,
but
that's
kind
of
expensive
in
a
local
area
network,
because
the
latencies
are
so
much
lower.
I
can
just
ask
my
nearby
peers.
C
B
So
in
braves
case,
if
you're
connected
to
the
internet,
I
think
it
will
primarily
use
the
there
is
one
big
public
dht
that
the
iphone's
network
uses
and,
for
the
most
part
it
will
use
that
large
dhc,
but
there's
other
protocols
that
are
we're
calling
indexers
that
are
serve
sort
of
the
same
role
of
dht's
but
have
a
different,
different
topology.
The
problem
with
dhc
is
that
they're
they're
very
slow.
You
end
up
with
you
know
long.
B
Yeah
yeah:
we
should
do
like
a
whole
whiteboard
session
on
each
season,
like
what's
good
about
them
and
and
bad
about
them,
and
so
on.
Hi
cool,
I'm
gonna
erase.
All
of
this
that's
what
we
got
out
of
ipfs,
so
the
platform
sort
of
assumes.
You
have
already
a
whole
bunch
of
content
in
this
hash,
linked
setting
right
so
that
you
have
what
we
call
ipld
content.
B
And
it
brings
in
all
the
networking
from
from
lipidp
and
so
on.
So
you
have
like
peer-to-peer
protocols
the
the
goal
of
my
professors
to
again
make
this
market
work
between
source
providers
and
clients
that
want
to
hire
the
storage
from
source
providers
and
the
way
we're
going
to
do
it
is
we're
going
to
build
what
we
described
as
a
decentralized
storage
network.
So
a
dsn
and
usually
like
this
is
a
very
simple
structure
where
you
want
to.
A
C
B
But
what
we
want
to
do
is
we
want
to
use
a
set
of
incentive
structures
to
enable
this
to
happen
with
certain
guarantees
like
we
want
to.
We
want
verifiability
that
the
storage
is
there
and
for
the
long
term,
and
you
want
sort
of
an
economic
guarantee
that
that
your
deal
will
be
honored
and
you
want
some
guarantees
around
retroability.
B
B
There's
a
lot
of
like
complexity
embedded
in
each
of
these,
but
I'll,
maybe
I
think
it's
probably
best
to
start
with
the
proof
system,
because
that's
kind
of
like
a
really
important
sort
of
foundational
block.
So
this
for
us
divides
into
at
least
two
proofs
pour
up,
which
is
a
proof
of
replication
and
post,
which
is
a
proof
of
space
time
and
the
idea
of
these
two
proofs,
the
proof
of
replication.
B
B
So
so
the
economic
guarantees
that
there's
some
price,
where
you
can
hire
the
network
for
that
price
and
your
data
with
very
high
probability,
will
stay
in
the
network
for
the
for
the
amount
of
money
that
you're
specifying
and
that's
kind
of
where
the
market
comes
in.
We
describe
this
in
terms
of
deals
and
each
deal
is
kind
of
a
little
data
structure
that
has
a
the
client,
the
storage
provider
and
then
the
price
and
the
period
of
time.
A
B
And
if
you
want
replication,
so
this
is
really
flexible,
because
if
you
want
you,
you
can
build
any
reliability
model
on
top
of
something
like
this.
So
a
lot
of
other
networks,
kind
of
pick,
a
specific
erasure
coding
scheme
or
a
particular
replication
scheme,
and
so
on
and
those
replication
schemes
don't
fit
all
use
cases.
What
you
want
to
give
is
a
very
useful,
a
very
kind
of
simple
primitive
upon
which
you
can
build.
C
A
B
C
A
A
B
There's
collateral
so
yeah
we'll
get
to
we'll
build
up
like
the
the
the
way
we
sort
of
put
in
the
content
specified
by
these
deals
into
into
the
source
system
is
by
using
anything
we
call
sectors.
So
let
me
maybe
build
it
up.
I
was
going
to
sort
of
explain
the
the
component
to
the
component,
but
but
let's
maybe
go
this
way.
B
C
B
They're
doing
that,
for
the
block
reward
I'll
describe
later,
how
we're
using
the
block
reward
but
falcon
is
a
storage
power
consensus,
so
spec
that
uses
instead
of
hash
rate
like
in
bitcoin
or
ethereum,
or
something
else.
We
use
the
storage
power
that
people
are
accumulating
as
the
power
in
the
block
reward,
so
participants
are
intended
to
bring
more
and
more
and
more
storage
power
into
the
network
so
that
they
can
earn
larger
and
larger
fractions
of
the
blackboard.
B
B
C
B
Just
capacity
but
but
actually
useful,
useful
data,
so
this
on
its
own
think
of
the
the
bitcoin
network
as
using
a
a
function
very
similar
to
that
to
amass
an
enormous
amount
of
hash
rate
on
the
planet,
and
so
falcon
has
used
that
same
kind
of
structure.
With
that
kind
of
block
reward
auction
to
assemble
an
enormous
amount
of
capacity.
We
have
17
exabytes
of
capacity
right
now,
which
is
like
really
competitive
with
with
a
centralized
cloud
storage
network
right.
So
this
is
an
and.
C
C
B
B
B
B
C
B
A
A
C
B
B
All
of
these
kind
of
components
and
protocols
can
can
be
swapped
out
for
other
designs
later
later
on.
So
so
the
marketplace
here.
One
of
the
really
neat
things
about
about
this
is
that
you're
supporting
tons
of
different
source
providers
that
can
offer
very
different
prices
or
very
different
kind
of
other
services
alongside
like,
and
they
might
tune
their
operations
for
certain
kinds
of
data.
So
some
source
providers
might
be
storing
very
large
amounts
of
data.
A
B
B
A
B
C
C
B
Tune
for
that
ux,
but
that
all
are
aggregating
into
into
so
so
you
sort
of
build
on-ramps
by
vertical.
You
enable
source
clients
to
hire
that
on-ramp
to
then
get
storage
in
here.
So
nftw
storage
is
a
good
example
where
that's
a
product
specific
to
the
nft
market.
It
enables
anybody
who
wants
to
store
a
lot
of
nfts
to
use
a
product
and
an
interface
tuned
for
storing
nfts
and
on
the
background,
it's
archiving
and
storing
everything
with
falcon.
B
Exactly
yeah
exactly
there's
a
there's
another
on-ramp,
which
is
kind
of
like
the
connecting
which
right
now
is
just
kind
of
like
this.
This
team,
that's
just
connecting
prospective
clients
to
source
providers
that,
where
they
do
a
little
bit
of
diagnosis,
of
like
how
much
data
is
it.
Where
are
they?
Where
do
they
want
the
data
to.
C
B
Yes,
a
lot
of
times
the
energy
turns
out,
the
internet
is
not
does
not
have
enough
bandwidth
to
move
around
that
that
much
storage,
so
you
have
storage
clients
and
source
providers
meeting
each
other
and
source
products
will
go
to
the
clients,
facilities
with
hardware,
get
the
data
and
then
bring
it
back,
and
so
you
want
to
sort
of
enable
all
of
that
to
happen.
The
centralized
cloud
uses
has
similar
services,
so
amazon
snowball
is
an
example
of
that
azure
data
box
and
so
on.
B
B
A
B
Yes,
so
it
turns
out
like
this
is
a
large
scale
system.
Once
you
want
to
store
exabytes
worth
of
data,
you
end
up
with
all
kinds
of
like
interesting
large
scale
problems,
each
of
which
could
take
an
entire.
You
know
large
scale
decentralized
network
to
solve,
for
example,
this
indexing
layer.
Today
you
can,
we
have
several.
B
B
A
B
B
B
I
want
to
be
able
to
prove
that
these
two
replicas
are
independent
from
each
other,
even
if
it's
the
same
data,
why
do
I
need
to
prove
that?
Well
one
many
users
want
to
prove
that
that
multiple
copies
are
being
stored
in
multiple
places,
but
two.
It
is
critical
for
consensus
power
that
you
cannot
cheat
here
and.
B
C
B
A
lot
of
source
power
when
they
don't-
and
so
that's
where
you
know
the
river
replication
is
really
critical
and
what
this
enables
is
you
have
a
an
interactive
proof
system
here
that
lets
you
prove
that
these
two
are
are
different
and
the
intuition
here
is
very
simple,
which
is
like
you
have
these.
You
can
use
some
facet
of
the
world
to
make
the
encoding.
B
B
Or
something
like
that,
they
carry
a
special
signature,
so
there
are
many
different
kinds
of
protocols
that
you
could
make,
but,
for
example,
the
time
one
is
very
kind
of
intuitive
to
think
about
you
sort
of
commit
to
what
the
data
is
at
some
point
in
time
you
give
it
to
the
to
the
storage
provider
and
they
have
to
run
some
expensive
encoding
and
then
once
they
they
run
that
expensive
encoding.
They
communicate
the
the
proof
that
they've
done
so
and
then
some
point
later
in
the
future.
You
can
sort
of
challenge
them.
B
C
B
A
B
B
B
You
know
produce
proofs
at
any
point
in
time.
You
here
you
have
proofs
and
we
we
run
one
of
the,
I
think
the
largest
snark
proving
system
on
the
planet,
and
it's
it's
all.
You
know
large-scale
proofs
of
people
actually
storing
all
of
this
content,
and
here
you
you
same
thing
with
the
challenge
you
test.
You
know
this
is
there's
some
the
challenge
issues,
a
bunch
of
like
checks,
a
bunch
of
points
make
sure
that
the
content
is
there
and
you
produce
a
proof
that
can
normally
pass.
B
C
B
Like
what
what
is
it
takes
sort
of
like
what
we
call
an
unsealed
sector?
We
call
this
function
a
ceiling
operation,
so
this
encoding,
we
call
it
seal
and
it
seals
an
unsealed
sector
which
is
kind
of
just
plain
text
stuff.
It
could
be
plain
text
capacity
which
is
all
just
randomly
generated,
or
it
could
be
the
actual
content.
C
B
C
D
B
B
Yourself
or
pretend
to
add
capacity
that
is
just
all
generated,
yeah
from
scratch,
so
you
want
like
an
extremely
hard
constraint
that,
like
even
if
you,
the
data,
could
all
be
generated.
You
know
it's
just
randomly
generated
data.
You
want
to
prove
that,
like
the,
it
is
extremely
likely
that
the
the
data
is
actually
there
and
and
there's
a
very
good
economic
argument
here,
where,
like
the
cost
of
making,
this
computation
is
many
times
larger
than
just
storing
the
data.
C
B
C
C
C
B
If
you
want
to
be
stronger-
but
you
end
up
with
this,
like
super
expensive
process
to
go
from
data
to
replica
and
once
you're
here,
this
is
what
you
store,
and
this
is
what
you
prove.
We
kind
of
like
use
a
challenge
response
vertical
here,
because
it's
very
difficult
to
prove
that
you've
done
this
correctly.
C
A
A
A
B
B
You
the
facility
to
sort
of
call
the
poor
challenge
again.
A
post
just
uses
a
poor
app
to
then
you
know,
with
some
sample
with
some
frequency,
to
prove
that
you
have
like
have
been
storing
an
arrangement
of
bits
for
a
given
amount
of
time.
So
you
can
just
keep
iterating
this,
and
so
you
do
this
today
with
a
blockchain.
So
the
blockchain
issue
is
a
challenge.
The
random
you
derive
randomness
from
the
block.
B
B
So
you
know
this
is
like
some
number
of
sectors
and
so
in
this
window
of
time,
they're
going
to
be
challenged
for
all
these
sectors,
and
so
in
this
window
of
time
they
have
to
like
produce
this
at
the
very
beginning
of
the
time
period.
They
get
the
challenge
and
they
have
to
submit
the
proof
before
that.
C
B
B
32
gigabytes
or
64
gigabytes,
there's
like
two
settings
and
that's
specific
because
of
sdr,
it's
kind
of
specific
to
the
algorithm
and
the
available
hardware.
So
it's
one
of
these
interplays,
where
you
have
to
design
the
poor
app
and
your
implementations
of
the
poor,
app
based
on
what
the
available
hardware
is
and
when
then,
once
you
do
that
you're
going
to
put
an
optimization
pressure
on
the
hardware
to
get
better
in
certain
directions.
C
B
So
you
need
a
bunch
of
gpus,
so
in
addition
to
the
storage,
you
need
a
bunch
of
gpus
that
can
do
these
proofs,
but
they're
not
used
all
the
time,
which
is
neat
because
then
you
can
use
use
the
gpus
for
the
remaining
remaining
time
to
do
other
kinds
of
computation
like
competition
over
the
data.
So
once
you
have
all
this
data
in
falcoin,
you
can
then
start
doing
a
bunch
of
computation
over
it
and
that's
kind
of
like
what's
coming
ahead
next
year,
it's
bringing
online
decentralized
computational
networks.
B
B
C
A
B
B
C
C
B
So
over
time,
the
kind
of
once
or
the
next
networks
are
saturating
in
terms
of
the
the
available
capacity
and
and
the
usage
of
the
the
usages
of
the
network,
sort
of
reaches
the
amount
of
capacity
that
and
you
have
more
interest
in
putting
data
storage
than
you
have
capacity.
Then
at
that
point
the
prices
will
start
increasing
here.
A
B
C
C
B
C
B
B
A
B
B
So
you
know
sort
of
like
we
tend
to
think
of
it
as
like
three
steps.
One
is
like
a
mass
hardware,
then
a
mass
data
and
then
make
that
computation
useful
for
computation
so
step.
One
is
like
you
have
a
block
reward
incentive
structure
to
summon
massive
amounts
of
capacity,
and
so,
like
we
kind
of
have
that
done
now,
we're
onboarding
the
data,
so
this
is
kind
of
like
in
progress
now,
and
so
this
is
kind
of
like
filling
up
this
capacity
with
with
useful
data
and
then
once
that's
there.
C
B
B
That's
where
we're
headed
yeah
great
well
yeah,
thanks
for
having
me
happy
to
dive
into
detail
in
any
of
this
in
the
in
the
future,
but
yeah.
This
is
kind
of
like
the
model
of
today's
just
getting
tons
of
useful,
useful
data
into
into
this
extremely
cheap
storage.
There's
an
exchange
already,
that's
leveraging
this
kind
of
negative
negatively
pricing
thing
where
you
can
let,
if
you're
a
legit
user,
you
can
bring
your
data
to
the
exchange
and
sort
of
sell
the
the
right
to
store
your
data,
and
so.
A
A
B
It
turns
out
to
be
not
not
that
hard,
because
if
the
data
is
public,
that
becomes
a
much
easier
problem
so
for
for
a
whole
subset
of
the
data
where
the
data
is
like
publicly
visible.
That
ends
up
being
a
much
easier
problem.
You
can
just
see
what
the
data
is
and
then
sort
of
certify
that
that
it's
good
data
that
the
network
wants
and
because
it's
public
and
viewable
you
can
always
audit
that
in
the
future.
A
B
B
B
B
Is
you
have
to
deal
with
this
elastic
thing
where
the
blocker
were
in
the
pricing
of
the
token
changes,
the
economic
return
of
people
at
any
sort
of
like
moment
in
time,
and
so
in
bitcoin?
You
get
this
behavior
where,
like
the
hash
rate,
mirrors
the
price,
the
price
right
so
if
like,
if
bitcoin
is
going
up,
then
like
the
hash
rate,
is
going
to
go
up.
C
B
To
the
immediate
volatility-
and
so
that's
where
collaterals
play
a
huge
role
in
that
in
both
adding
security
to
the
network,
in
that
you
know
if
they,
if
a
large
chunk
of
storage
disappears.
That
weakens
the
security
of
the
consensus
protocol
and
you
also
don't
want
a
bunch
of
users,
valuable
data
to
disappear.
Yeah.
A
B
So
you
don't,
the
collaterals
are
burned.
Always
you
don't
flow
them
back
to
the
clients.
If
your
deal
stops
being
stored,
you
then
get
the
remainder
of
the
price
that
hasn't
been
spent,
but
you
don't
get
the
collateral
back
and
the
reason
is
otherwise.
You
have
this
like
behavior,
you,
where
you
can
sort
of
convince
a
bunch
of
stores.
You
can
have
like
malicious
clients
that
convince
a
bunch
of
source
products
to
store
data
and
then
and
then
you
go
and
like
attack
them
and
make
them
miss
their
windows.