►
From YouTube: Free Retrieval via IPFS
Description
A proof-of-concept showing a Lotus miner making deal data available over bitswap to IPFS.
A
B
Free
retrieval
via
ipfs
here
we
go
if
I
can
make
it
work,
it
all
starts
with
a
file,
a
file
that
is
stored
on
a
miner,
and
what
we're
interested
in
is
when
the
retrieval
cost
is
nothing.
It's
absolutely
free,
no,
no
phil
to
pay
to
retrieve
this
thing,
and
so,
when
things
are
available
for
free,
why
don't
we
just
make
them
available
by
ipfs?
Why
not?
This
is
because
they're
free,
because
the
lotus
node
is
it's
it's
kind
of
an
ipfs.
It's
definitely
a
lippy
to
be
node.
B
It
definitely
has
all
of
that
stuff
in
there
that
it's
already
using.
So
why
set
up
this
extra
infrastructure
to
to
do
this,
when
you
already
have
all
of
that
stuff
already
in
lotus?
Why
would
miners
want
to
do
this?
Why
would
they
allow
access
to
all
of
their
files
just
for
free
well,
a
few
reasons?
Maybe
they
want
to
make?
Maybe
they
make
enough
cash
from
their
storage
deals
like?
B
Maybe
they
maybe
they
will
charge
a
premium
for
for
storage
when
it's
made
available
on
ipfs,
maybe
they're
a
pinning
service
and
they're
running
a
miner,
and
they
they
might
want
this.
You
never
know.
Maybe
it's
maybe
it's
us,
maybe
maybe
it's
pl,
who
are
running
a
far
coin
node
and
want
to
make
a
data
available
to
ipfs
that
they're
storing
on
far
coin
for
free.
Maybe
it's
some
other
charity
or
yeah,
like
I
said
before.
B
Maybe
another
reason
is
because
of
this
whole
there's
not
there's
not
this
extra
infrastructure
that
you'd
have
to
set
up
you'd
not
have
to
set
up
a
lotus
as
well
as
an
ipfs
node,
because
they're
all
the
same
thing
kind
of
all
right.
So
what
what
the
demo?
What
is
the
demo?
Well,
it's
a
file,
and
what
we're
going
to
do
with
that
file
is
we're
going
to
import
this
into
a
we're
going
to
use
the
client
to
import
this
into
a
lotus
node?
B
That
is
not
a
miner
and
that
lotus
node
is
going
to
make
a
deal
with
with
a
miner
to
store
the
file
in
its
in
its
data
storage
area.
And
what
we'll
do
then
is
we
will
bit
swap
that
that
file
to
ipfs
directly
from
the
miner
we're
gonna
use
ground
to
do
this?
If
you
haven't
looked
at
test
ground
totally
recommend
it's
really
good.
I
I
I
know
I
know
of
test
ground.
B
I
have
not
known
about
it
for
a
long
time,
but
I've
not
I've,
not
actually
got
into
it
before,
and
I
had
a
really
good
experience.
The
doc
site
is
amazing.
Give
me
a
great
overview.
I
have.
I
got
things
set
up
and
working
really.
Well,
so
it's
super
powerful.
You
should
totally
use
it
if
you
haven't
already,
because
it's
rad
anyway
enough
enough
plugging
test
ground-
let's,
let's
do
the
demo.
B
Okay,
so
let's
head
over
here
so
first
of
all,
let's
set
up
the
the
file
that
we
want
to
store
on
the
miner.
I'm
just
going
to
write
like
hello,
hello,
ivfs,
hi,
and
what
I
want
is
somebody
in
the
audience
to
shout
out
an
emoji
just
to
prove
that
I
couldn't
know
I
couldn't
have
set
this
up
ahead
of
time.
This
is
pure
demo
shout
out
an
emoji
anybody,
the
light
bulb,
the
light
bulb
sure.
B
A
B
Okay,
so
that's
the
file,
and
what
we're
going
to
do
is
that
that
string
there
we're
just
going
to
repeat
it
a
whole
bunch
of
times
so
that
it's
it's
a
bigger
file.
It
gives
me
a
bit
more
time
to
talk
about,
what's
actually
going
on.
Okay
here
we
go
so.
First
of
all,
we
need
to
set
start
the
test
ground
test
ground
so
off.
That
goes.
That
starts
that
up
in
theory,.
A
B
A
B
All
right,
that's
never
taken
that
long.
So
this
is
gonna
be
fun,
I
think
so
all
right.
So
what
we're
gonna
tell
test
ground
to
do
is
run
our
composition.
I've
created
a
composition
just
for
this.
It's
based
on
another
one
for
which
is
which
is
working
for
deals,
and
we
just
tell
it
to
run
the
composition,
I'm
just
going
to
hit
enter
and
then
that
will
that
will
be
done,
that's
great
and
and
what
our
composition
is
in
test
ground.
B
Is
it
just
sort
of
tells
test
ground
what
what
what
is
going
on?
What
nodes
are
going
to
be
available
on
the
network?
What
tests
to
actually
run
and
then
test
ground
takes
that,
and
so,
if
we
head
on
back
to
test
ground
demon,
we
can
see
that
it's
starting
it's
starting
stuff
up
and
that
that
composition,
what
it?
B
What
it's
going
to
do,
is
it's
going
to
spin
up
two
two
lotus
nodes:
it's
going
to
spin
up
a
client
which
we're
going
to
use
to
make
a
deal
with
a
miner
and,
and
then
what
we'll
do
is
once
that
deal
has
completed.
We
will
log
into
one
of
these
these
containers
and
I
I've
got
ipfs
installed
on
them.
I'm
just
gonna
create
a
new
ipfs
node,
an
ipvs
daemon
and
then
try
and
cap
that
file
directly
from
the
miner.
B
So
that
would
be
that'll
be
fun
because
it
sort
of
represents
it's
kind
of
out
of
band
from
test
band
from
tespan
from
test
ground
and
it
should
sort
of
represent
like
real
world,
getting
what
it
would
be
like
to
cat
a
file
from
a
file
coin,
which
is
hopefully
very
similar
to
cutting
a
file
from
ipfs
all
right.
So
we
can
see
here
that
things
have
happened
there.
B
Oh
we
got
so
we've
got,
we've
got
a
we've,
got
a
client
he's
starting
up,
and
he
we've
got
a
miner
here
as
well:
the
yellow
guys
miners,
the
the
the
blue
ones,
the
client
and
what
the
mine
is
doing
because
we
started.
This
is
a
test
network.
We
started
from
genesis.
Mine
is
just
doing
some
initial
mining
to
get
some
power
on
the
network
so
that
it
can
continue
to
mine
blocks.
B
B
B
B
Swarm
connect
and
that's
the
minus
address.
Okay,
connect
success.
So,
okay,
it's
connected
to
the
miner
hooray,
that's
great,
but
nothing,
nothing
too
special
so
far,
but
if
we
have
a
look
back
over
here,
we
can
see
that
something
has
happened.
Storage
deal,
client
funding,
that's
great,
so
it
looks
like
what's
happened
here
is
the
the
store
the
the
client
has
started
a
storage
deal
with
the
miner
okay.
This
is
going
way
slower
than
I
expected,
probably
due
to
zoom
being
open
as
well
but
anyway.
B
B
B
So
what
we'll
do
now
is
we'll
take
this
cid
we'll
head
back
over
to
ipfs
and
if
I
try
to
ipfs
cat
this
cid,
I'm
expecting
this
to
just
hang,
because
nobody
in
the
world
has
this
particular
file
and
especially
not
r
miner.
Well,
they
kind
of
do,
but
it's
not
because
the
deal
hasn't
been
sealed
it's
been
completed,
yet
it's
not
been
made
available
to
ipfs
for
storing.
So
this
should
hang
it
does.
B
I'm
just
going
to
quit
that
and
so
now
all
we
need
to
do
is
wait
for
here's
the
ceiling.
It's
happening,
that's
great,
so
we
just
need
to
wait
for
ceiling
to
finish
and
once
the
ceiling
is
done,
then
the
deal
is
activated
cool,
and
so
what
happens
when
the
deal
is
activated?
Well,
the?
What
what
happens
is
the
data
for
the
deal
is
immediately.
Unsealed
probably
could
be
better.
B
A
B
It's
done
yeah
exactly
so.
The
deal
is
completed
and
in
this
test,
oh
interesting.
This
is
interesting.
This
has
not
happened
before
so
the
deal
was
completed
and
it
tried
to
retrieve
it.
I
don't
know
why
this
has
failed.
So
hopefully
this
might
still
work,
but
because
the
deal
has
has
completed
this
should
now
be
available
to
ipfs.
B
B
So
one
last
thing:
one
last
thing
here:
we
go
some
insights
so
far
in
in
in
whilst
whilst
doing
this,
whilst
building
it,
but
also
people
have
made
some
really
kind
comments
on
the
on
the
pr
for
for
this
for
the
proposal,
one
thing
that
we
we
know
is
that
there's
no
discovery
here.
This
is
just
this
is
just
bit
swapping.
There's
no
dht
involved
we're
not
advertising
the
peer
id
anywhere.
We're
not
advertising
the
cid.
B
B
I've
got
a
separate
block
store
which
I'm
putting
stuff
into,
and
actually,
if
you,
if
you
were
to
enable
fast
retrieval
fast
retrieval,
then
you'd
actually
get
a
triple
storage
problem,
because
you'd
have
it
in
you'd,
have
it
like
sealed
unsealed
and
in
this
free
block
store,
so
that
can
well.
I
don't
know
I
I
was
hoping
that
maybe
I'd
be
able
to
just
enable
free,
retrieval
and
somehow
extract
it
directly
from
the
unsealed
unsealed
stuff,
but
I
I
didn't
quite
get
around
to
that.
B
Well,
I
had
a
look,
but
I
I
haven't
spent
much
time
on
it.
It's
been
like
two
days,
there's
an
obvious
proof
of
retrievability
problem
where,
if,
if
a
miner
were
to
to
to
charge
a
premium
for
for
for
for
storing
their
data
and
making
it
available
to
fiber
to
ipfs,
there's
no
proof
that
they're
actually
doing
that.
Even
if
you
were
to
successfully
cap
that
cid
from
ipfs,
it
might
not
be
the
miner
who
gave
it
to
you,
so
you
just
don't
know
so.
B
We'd
need
to
solve
that.
There's
one
there's
there's
a
few
wins
here:
the
we're
hopefully
narrowing
the
ipfs
to
file
coin
gaps
like
it's.
It
feels
to
me
that
that
this
has
shown
that
that
gap
isn't
nearly
as
big
as
as
it
possibly
is,
looks,
and
you
know
like
it's
obvious.
It's
been
a
really
small
time.
Investment.
B
It's
like
100
lines
of
code
to
get
this
up
and
running,
there's,
obviously,
obviously
not
production
code,
but
hopefully
this
is
inspiring
in
some
way
and,
like
I
know,
I
know
that
there
is
already
a
proposal
for
the
other
other
side
of
this,
which
is
so.
This
proposal
is
kind
of
turning
a
file
coin
node
into
an
ipfs,
whereas
the
other
side
is
like
what,
if
you
turned
an
ipfs
node
into
a
filecoin,
and
that's
all
I
have
to
say
thank
you
very
much
for
listening.
Sorry
that
took
so
long.
A
B
It's
okay,
so
originally
so
I
I
had.
I
had
it
such
that
as
soon
as
the
so
I'm
just
listening
to
for
events
from
the
field
markets
code.
Originally,
I
had
it
such
that
when,
when
a
when
an
upload
was
fully
received
by
a
by
a
miner,
then
it
was
just
copied
straight
into
the
box
store
and
made
available
straight
away,
but
obviously
that,
if
a
deal
fails
for
whatever
reason
then
you've
just
put
it
in
a
block,
store
and
you're,
not
gonna,
ever
gonna
use
it.
B
So
it
didn't.
Do
it
like
that
and
once
the
deal
is
activated,
you
can't
just
get
it
out
of
the
where
grass
the
store
that
graph
sync
puts
it,
because
once
it's
activated,
the
falcon
markets
code
actually
cleans
up
that
that
temporary
block
store
storage.
So
I
can't
just
take
it
out,
so
I
actually
have
to
unseal
it.
To
put
it
in.
To
put
it
like,
I
don't
feel
this
code
is,
is
gonna,
be
make
it
as
the
the
the
final.
A
B
In
any
way,
if
if
it
were
to
be
taken
forward,
but
that
that's
the
reasons
behind
that
but
like
I
haven't
really
done
it
in
a
way,
I've
tried
to
refactor
things
to
make
it
to
make
it
work.
I've
just
done
it
so
that
it
it
can
be
shown
and
that
it's
possible,
and
but
there
are
there's,
there's
obvious
things
that
can
be
done
to
to
fix
up
that
like
it's
just
you
just
need
to
do
some
coding
and
do
some
refactoring.