►
From YouTube: Filecoin Dev Demo 01 - Storage Market Basics
Description
Storage Market Basics
A
In
this
demo,
we'll
show
the
basics
of
the
storage
market.
The
commands
and
interfaces
shown
here
will
change
significantly
as
we
implement
a
protocol
and
flesh
out
features.
First,
let's
start
a
local
test
net
with
a
few
notes,
will
disable
client
market
actions
so
that
we
can
see
just
our
activity.
The
miners
in
the
network
are
mining
blocks
and
adding
storage
market
asks.
We
can
see
the
network
in
the
visualization,
including
the
storage
market,
starting
to
fill
with
asks
in
the
top
terminal,
we'll
start
sending
commands
to
one
of
the
miners
through
its
API.
A
Let's
add
an
ask
to
the
market,
which
tells
the
market
that
this
miner
is
willing
to
store
data
at
a
particular
price
asks
also
include
a
duration
of
time,
but
this
is
not
ready
to
demo.
Yet,
let's
set
a
price
lower
than
everybody
else
in
the
market.
This
way
we'll
get
the
business
our
ask
will
show
once
the
next
block
is
mined
there.
It
is
now,
let's
make
a
client
store,
some
files.
A
A
Once
the
bait
is
in
the
chain,
it
locks
funds
from
the
client.
Now,
let's
hire
the
miner
to
propose
a
deal,
we
need
the
IDS
of
the
asks
and
bids
we
can
inspect
the
live,
asks
and
bids
with
the
order
book
command
here
the
asks
and
here's
a
single
bit
in
the
market.
Of
course,
there
are
no
deals,
yet
we
import
the
file.
We
want
to
store.
A
A
The
minor
receives
the
deal
and
considers
it
the
minor
can
reject
the
deal
if
the
asks
and
bids
don't
match.
If
the
minors
asking
price
has
changed
or
if
the
minor
simply
wants
to
refuse
this
client
or
this
deal
in
particular,
it's
an
open
market
and
the
client
should
go
find
some
other
minor.
If
the
minor
accepts
the
deal
it
lets,
the
client
know
and
the
client
schedules
the
transfer
of
the
relevant
data
if
the
data
is
small
and
can
be
easily
sent
over
the
internet,
10
gigabytes
scale
or
less.
A
The
client
just
sends
the
data
over
the
protocol.
If
the
data
is
too
big
to
send
over
the
internet,
easily
think
many
terabytes,
petabytes
or
higher,
the
Minor
and
client
can
arrange
a
separate
data
transport
over
much
higher
bandwidth
links
such
as
package,
switching
shipping
containers
or
station
wagons
loaded
with
tapes.
Speeding
down
highways.
Note
that
the
transfer
of
data
is
completely
verifiable
and
the
minor
will
only
accept
data
that
matches
the
deal
once
the
minor
has
received
all
the
data.
A
It
signs
the
deal
and
returns
it
to
the
client,
the
minor
or
the
client
can
post
the
deal
to
the
blockchain
to
finalize
the
transaction
by
default.
The
minor
does
it,
but
the
client
is
able
to
do
it
as
well.
This
covers
an
important
protocol
edge
case.
Once
the
deal
is
on
the
blockchain.
The
minor
is
responsible
for
storing
the
data
and
will
be
tested
on
it
periodically.
A
This
sounds
like
a
lot,
but
in
the
general
good
behavior
case,
it
happens
very
quickly
in
this
demo,
the
minor
will
accept
the
deal
automatically
and
the
data
transfers
immediately
watch
the
visualization
when
I
press
ENTER
the
deal
will
trigger
and
the
file
transfer
will
happen
all
right
at
this
point,
the
miner
and
client
have
struck
a
deal
which
is
logged
in
the
storage
market
order
book.
We
can
see
it
both
in
the
visualization
and
in
the
command
line.
A
Finally,
let's
see
another
client
retrieving
the
file:
let's
grab
a
node
we
haven't
used.
Yet,
let's
find
the
data
reference
in
the
deal
and
let's
download
the
file
using
the
client
cat
command.
This
finds
and
retrieves
the
file
from
the
storage
miner
week
and
if
the
new
file
against
the
original
to
show
they
have
the
exact
same
contents.
A
Some
final
notes:
the
retrieval
market-
is
not
in
this
demo,
as
it
is
still
a
work
in
progress,
but
conceptually
it
will
function
similarly
to
the
storage
market
in
the
future
market.
Orders
asks
bids
and
deals,
don't
have
to
happen
through
the
blockchain.
We
have
working
designs
for
running
markets,
entirely
off
trained
using
payment
channels.