►
Description
Every other week, the Retrieval Market Builders get together to share progress in their projects in a demo format. We want to sincerely thank all of our collaborators for demoing their developments and helping to improve the FIL Retrieval Markets one demo at a time.
April 13, 2022, Demo Day: In this video, you can find quick demos from -
• Myel
A
C
All
right
so
yeah,
we
just
made
a
first
release
of
js
graph
sync
and
it
implements
the
version
two
of
the
graphing
protocol,
which
is
kind
of
the
latest
and
should
be
out
on
lotus,
and
so
I'm
kind
of
going
to
demo
a
little
example.
So
it's
basically
end-to-end
graph
sync,
so
it
you
know,
features
a
provider
and
a
client,
and
so
I
have
a
little
example
that
runs
in
the
browser
that
can
kind
of
demo
the
whole
flow.
C
And
so
basically
I'm
gonna
run
this
again.
It's
a
very
simple
go
provider
that
is
just
to
to
demonstrate
the
compatibility
and
everything.
So
we
have
kind
of
a
go
provider
that
basically
all
it
does
is
it
runs
a
graph
sync
host
with
a
data
transfer
host
on
top
of
it.
The
data
transfer
allows
us
to
do
push
transfers,
meaning
that
instead
of
you
know
requesting
content,
you
can
request
to
send
content
to
the
to
this
node.
So
this
node,
all
it
does,
is
very
simple.
C
It
runs
only
p2p,
the
graph
sync
exchange
and
then
the
data
transfer
validation
with
a
very
simple
vouchers
and
we
have
a
blog
store,
and
so
it
just
listens
for
content
and
just
handles
requests.
Basically,
so
I'll
just
go
ahead
and
run
this
app,
so
we
have
our
app
here.
This
is
kind
of
like
a
very
simple
html
react
app.
That
has
a
few
forms
and
a
few
things,
and
that
runs
the
graph
sync
inside
of
the
browser
and
I'm
gonna
go
ahead
and
start
the.
C
Provider,
the
go
provider
just
and
copy
the
the
multi
address.
So
now
we
have
a
multi
address
here.
So
this
is
the
the
local
address
of
the
the
peer
the
go
peer.
I
was
just
kind
of
showing,
and
so
I
can
add
some
some
files,
so
we
upload
files
and
chunk
them
in
the
browser.
So
I'm
just
gonna
add
a
couple
images
for
example,
and
so
this
was
just
kind
of
chunked
by
the
js
unix
fs
importer,
and
so
now
we
can
kind
of
make
an
upload
request
to
the
go
node.
C
So
here
we
go
so
that
was
just
uploaded.
So
what
happened
is
basically
through
the
data
transfer
protocol,
I'm
sending
a
request
to
the
go
host
and
then
the
go
host
will
make
a
graph
sync
request
to
the
browser,
and
so
the
browser
in
this
case
acts
as
a
graphing
provider.
So
it
sends
back
the
content,
and
so
now
the
content
we
know
is
is
stored
on
on
the
go
node.
So
now
this
is
something.
C
C
I
can
just
add
this,
and
so
basically,
what
we'll
do
is
create
a
specific
selector
to
essentially
tell
the
graphing
host
to
use
a
specific
refire,
which
means
that
it
will
create.
It
will
have
a
special
node,
resolver
ipld
resolver
for
that
node.
That
will
be
able
to
kind
of
transform
that
node,
so
it
can
be
accessed
through
its
essentially
the
name
of
the
file
inside
of
it,
and
so
here
we
go
when
we
just
do
that.
C
I
should
be
able
to
just
request,
and
so
here
we
have-
I
just
requested
the
image
so
that
just
resolved
the
image
from
that
node,
and
so
we
it
only
got
the
blocks
that
we
were
interested
in,
which
means
that
we've
only
got
three
megabytes
of
content,
so
yeah.
So
based
on
that
everything
is
kind
of
ready
to
install
and
import.
C
C
C
So
that's
kind
of
convenient,
so
you
get
a
cid
and
a
selector,
and
then
you
can
run
the
request
against
it
and
basically
from
the
the
prd,
the
request
opens
up
and
all
the
store
the
the
blocks
are
stored
in
the
block
store,
and
so
on
top
of
it.
You
can
just
kind
of
save
all
the
blocks
in
the
blog
store
or
there's
also
convenience
methods
for
resolving
the
content
immediately,
and
so
what
it
does
is.
Basically,
you
use
the
you
can
pass
the
the
request,
which
basically
is
a
link
loader.
C
C
So
it's
a
transform
stream,
but
essentially
it's
just
the
readable
part
that
we're
interested
in,
and
so
when
we
return
a
kind
of
an
http
response,
it's
easier
to
consume,
so
you
can
kind
of
consume
it
as
a
blob
as
a
stream
as
a
whatever
your
use
case
might
be
in
inside
of
the
browser,
and
you
can
also
add
content
types.
So
there's
kind
of
a
basic
example
on
how
to
do
that,
and
so
that
also
adds
a
data
transfer
extension
on
top
of
it
to
kind
of
show
how
how
to
do
this.
C
It's
very
bare
bones,
meaning
that
there's
no
revalidation
or
anything
like
that,
but
it's
kind
of
a
good
starting
point
for
kind
of
understanding
how
to
extend
graph
sync
from
there
and
and
add
other
protocols
and
things
like
that,
and
then
there's
also
kind
of
the
the
convenience
method
for
push
which
we
used
as
well.
So
this
is
just
basically
adding
also
an
extension
and
creating
a
specific,
a
dial
over
the
data
transfer
protocol.
C
So
that's
a
protocol,
that's
separate
from
graphsync,
but
we
use
that
as
a
way
to
notify
the
other
peer
that
they
can
request
the
content
from
us.
Since
the
browser
cannot
be
dialed
as
a
listener,
we
doubt
we're
we're
the
one
dialing
and
then
we're
listening
to
to
requests
that
are
based
on
on
that
same
stream.
Basically,
and
so
we
just
wait
basically
for
the
for
the
content
and
the
the
response
to
come
back
once
all
the
content
has
been
received
by
the
host.
C
C
If
you
want
more
features
or
things
like
that,
because
there's
obviously
a
ton
of
other
features
that
exist
on
on
go
graph
sing,
for
example,
but
we
just
decided
to
add
them
based
on
need
not
to
you
know,
bloat
everything
right
away
with
a
ton
of
things
and
just
kind
of
actually
make
the
features
solve
like
real
use
cases
and
things
like
that.
So
definitely
let
us
know
and
yeah.
That's
that's.
It.
A
Awesome
thanks
thomas,
I
suppose
we
have
got
a
fair
amount
of
time,
so
I
think
we
can
probably
include
questions
on
the
recording,
if
that's
all
right
to
kick
us
off.
First
question:
just
like
a
clarification,
would
you
mind
just
kind
of
defining
what
ray
of
raiification
is
just
for
people
who
might
be
watching?
C
Yeah
I
mean
I
I'm
not
an
expert
on
on
the
ipld
definitions,
but
my
understanding
is,
it's
basically
a
function
they
take
that
takes
a
an
ipld
node
and
that
transforms
it
into
a
different
ipld
node.
Basically
so,
and
so
you
take
you,
give
it.
Essentially,
there
is
a
name,
so
you
can
you,
for
example,
it
could
be
unix
fs
or
it
could
be
any
type
of
advanced
data
layout.
A
A
C
So
you
could
basically,
we
can
create
different
types
of
iterators.
For
example,
you
could
have
an
right
now
we
have
a
pure
iterator
that
just
yields
the
bytes,
but
if
you
wanted
more
metadata
to
understand,
you
know
more
about
what
blocks
are
coming
in
and
and
the
size
of
these
blocks,
and
things
like
that,
you
can
also
do
that,
and
I
think
this
is
kind
of
things
that
we
use.
C
For
example,
if
you
have
a
more
complex
stateful
retrieval
protocol,
such
as
the
one
for
for
far
coins,
in
which
case
you're
interested
in
actually
knowing
how
many
bytes
you've
you've
received-
and
you
know
at
what
points
you
at
what
point
you
are
under
validation
and
the
messages
so
in
that's.
In
that
case,
you
would
want
a
different
type
of
iterator.
That
would
essentially
give
more
information
about
the
message
that
get
received
and
not
just
yield
the
bytes.
C
So
I
think
that
it's
really
plug
and
play,
which
is
really
nice.
You
just
kind
of
switch
around
what
kind
of
iterators
you
want
and
just
pipe
through
those.
So
you
you
regardless
you
will
have
an
iterator
that
will
just
pipe
the
messages
and
then
do
something
with
it.
So
it's
it's
like
it's
a
little
different
paradigm
from
from
the
go
implementation
in
that
sense,
but
it's
kind
of
very
similar
to
what's
already
kind
of
standard
with
jsc2p,
because
everything
is
async
iterator.
C
No
girly,
I've,
no
extensions,
I
mean
you
can
create
extensions
and
add
them
in
through
the
regular
interface,
but
there's
no
method
api
for
doing
it.
Basically,
it's
all
kind
of
it's
very
manual.
You
have
to
write
something
on
top
of
it
to
add
the
extension
there's
only
kind
of
the
the
metadata
right
now
it
only
kind
of
reads
the
metadata
and
things
like
that.
So
no
extensions
at
this
point.
E
C
Yeah,
it's
a
little
different
in
that
it
doesn't
transform
the
the
note
into
a
reader
in
that
sense,
so
it
does,
it
doesn't
have
the
the
full
byte
slice
kind
of
selector
implementation,
but
it
so
currently
only
does
it
it
does
the
the
padding
basically.
So
it's
a
refire
for
for
selecting
path
inside
the
the
directory.
C
I
mean
the
file
still
gets
resolved
in
that
you
just
have
to
have
a
different
type
of
selector,
so
instead
of
using
a
matcher,
you
can
kind
of
say,
select
everything
that's
after
it.
Basically,
so
that's
kind
of
how
I
implemented
it
is,
instead
of
because
in
the
go
currently,
you
just
use
a
matcher
and
then
that
will
be
considered
considered
as
a
single
node,
but
I
still
consider
all
the
nodes
from
the
file
as
different
as
a
separate
nodes.
Basically,
so
then
it's
like
a
regular
traversal
from
there
on.
F
C
Right
yeah,
it's
using
the
the
cache
storage
api,
but
essentially
all
there's
kind
of
a
limit.
So
you
can
kind
of
store
use
that
as
as
kind
of
a
you
know,
a
regular
block
store,
but
eventually
it
might
get.
You
might
reach
that
limit
and
and
content
will
get
evicted
but
yeah.
So
you
have
to
kind
of
in
this
demo.
For
example,
we
reset
the
cache
in
between
and
then
you
you
basically
load
it
again
from
from
the
provider.