►
From YouTube: IPFS Fetcher
Description
Hannah Howard demos a brand new tool for fetching IPFS data that uses the new IPLD prime library.
https://github.com/ipfs/go-fetcher
A
A
So
we
built
this
concept
of
a
of
a,
I
believe
it's
of
a
universal
node
which
so
oh
by
the
way.
Who
knows
that
I
have
no
idea
who
how
many
people
know
what
I
feel
the
prime
is
old.
Ipld
there's
two
different
libraries
ipld
prime,
is
like
a
super
awesome
library
that
does
like
all
the
parts
of
the
ipld
spec,
including
like
selectors,
including
schemas.
A
It's
like
an
awesome
data
model
for
like
all
of
our
stuff,
and
then
I,
the
old
ipld,
is
like
a
thing
that
is,
does
some
things,
but
not
most
of
the
ipld
spec
and
it
unlocks
like
all
these
cool
data
thing
like
data
operations
that
we
could
be
doing
in
our
in
all
of
our
applications.
If
we
can
get
it
all
the
way
to
the
edges
of
go
ipfs.
A
So
we
built
this
thing
that
basically,
like,
like
we
started
off
by
building
this
sort
of
hack,
which
effect
effectively
takes
like
the
the
new
ipld
prime
and
wraps
it
in
something
that
makes
it
look
like
the
old
idea,
which
is
fine.
That's
like
often
like
the
easiest
way
to
do
a
transition
is
to
just
like
put
in
something
that
gets
you
to
a
baseline
of
not
having
to
move
over
all
your
stuff
at
once
and
then,
like
you
can
work
from
there.
A
So
we
built
this
thing
called
the
universal
node.
That's
the
basic
unit
of
of
both
libraries
is
the
notion
of
a
node,
though
they
mean
different
things,
but
we
built
one
that
like
does
both
of
them,
and
then
we
and
then
we
went
and
there's
a
service.
That
sort
of
is
like
your
universal
entry
point
for
working
with
ipld
in
ipfs.
Currently,
and
that's
this
library
called
go
merkle
dag.
This
is
the
thing
that
allows
you
to
essentially.
A
This
is
a
thing
that
essentially
allows
you
to,
for
example,
read
in
ipld
data,
write,
ipld
data
delete
stuff
and
when
and
when
I
say
read,
that
means
like
get
a
load
in
ipld
data,
from
like
a
block
store
or
potentially
from
from
the
from
the
ipfs
network,
it's
sort
of
a
transparent
layer,
and
it
also
it
does.
It
does
a
whole
lot
of
things.
A
It
also
includes
the
dag
protobuf
implementation
of
ipld
of
the
the
old
ipld
for
the
old
form
of
like
ld,
so
we
so
we
built
this
like
whole,
like
pr
to
like
basically
make
that
use
ipld,
prime
under
the
hood
and
that's
all
fine.
This
gets
us
to
the
point
where
we
have
basically
the
old
interfaces
for
working
with
ipld
in
ipfs
that
use
ipld
prime
under
the
hood
and
that's
great.
However,
all
those
old
interfaces
are
not
really
well
designed
for
working
with
ipld
prime.
A
This
enables
us
to
get
it
into
the
system
without
having
to
convert
everything
at
once,
but
it
does
not
build
new
interfaces
that
are
tailor-made
for
ipld,
prime,
so
we've
now
we
so
now
we're
working
on
some
of
that
and
the
thing
that
I
want
to
just
demonstrate
today.
I'm
sorry
for
this
super
long.
Intro
is
the
first
thing
that
we
built,
which
is
what
we're
calling
the
ipfs
fetcher.
A
This
may
be
getting
super
technical.
I
apologize
and
now
and
now
like
and-
and
you
basically
always
wanted
sessions,
but
it
was
a
late
bolted
on
feature.
So
we
had
all
this
code
that
sometimes
wasn't
use
it
yet
and
in
the
new
version,
like
the
only
way
you
can
work
with
stuff
is
through
sessions.
So
that's
great
because
it
forces
you
to
do
that
and
make
sure
that
you're
you're
setting
things
up
properly,
but
you
can
see
we
have
some
fetching
functions.
You
can
fetch
blocks.
A
You
can
fetch
a
block
that
match.
You
can
fetch
a
set
of
blocks
that
match
a
selector
which
is
really
great,
because
that
means
that
we
can
do
traversals
of
dags
that
are
not
the
whole
dag,
but
rather
a
selection
of
the
dad,
but
we
also
have
like
interfaces
that
will
allow
you
to
fetch.
You
know
a
whole
graph
at
once,
and
what
else
do
we
have
in
here?
We
are
building
some
stuff
like
we
are
allowing
you
to
start.
A
A
Sorry,
we
are
allowing
you
to
do
especially
we're
allowing
you
to
do
fetches
with
specialized
node
types.
This
is
a
really
cool
feature
of
ipld
prime,
which
allows
you
to
basically
define
a
type
ahead
of
time
for
your
for
the
nodes,
you're
gonna
be
working
with,
like
let's
say,
I'm
working
with
some
kind
of
specialized
data
structure
that
I
want
to
only
look
a
certain
type
of
way,
so
we're
adding
that
as
well
again.
A
This
may
not
make
sense
to
those
of
you
who
aren't
in
the
weeds
with
code
happy
to
like
do
a
longer
longer
primer
on
ipld
some
other
times,
it's
probably
useful
anyway,
so
yeah,
so
we're
building
these
up
the
current
version
of
this
under
the
hood.
If
you
actually
dig
into
it
all
the
way
down
to
the
bottom,
what
we
are
ultimately
doing
is
just
using
the
block
service
to
get
individual
blocks
when
we
load
them.
A
The
block
service
is
a
is
a
way
to
fetch
blocks,
one
by
one
it
either
loads
locally
or
calls
out
to
bit
swap,
but
in
the
future
we
may
actually
replace
some
of
this
with
graph
sync
or
a
combination
of
graph
sync
and
bit
swap
but
yeah.
That's
that's
our
that's
our
interface
and
now
this
is
going
to
be
like
slowly
filtering
up
the
tree
into
xfs
and
whatnot.