►
From YouTube: Auspinner - @danieln - IPFS Implementations
Description
Auspinner - presented by @danieln at IPFS 2022 - IPFS Implementations - https://2022.ipfs-thing.io
A
It's
good
to
meet
and
see
all
of
these
great
implementations
of
ipfs
daniel,
I'm
pretty
new
to
pl
and
ibfs.
I
mean
I
worked
with
it
on
the
other
side
some
years
ago,
as
a
developer
and
now
sort
of
coming
onto
this
side.
A
As
a
developer
advocate,
I
have
a,
I
guess,
a
fresh
and
naive
perspective,
and
so
the
goal
with
ospina
was
to
really
learn
about
the
ipfs
stack,
the
protocols,
the
specs
bit,
swap
some
of
the
broader
specs
that
we
have
in
the
ecosystem,
like
the
pinning
api,
spec
and
the
go
libraries
and
to
explore
the
space
of
trade-offs.
A
A
And,
of
course,
I
wanted
to
build
something,
useful
and
explore
this
idea
of
like
a
short-lived
light,
ipfs
node,
so
something
that
sort
of
has
a
short
lifetime
and
so
to
sort
of
move
on
into
what
actually
or
spinner
is.
I
think
it's
a
good
starting
point
to
start
with
this
question
of
what
do
all
of
these
have
in
common?
Does
anyone
can
anyone
guess
maybe
yeah
something
a
bit
more
specific.
A
Yes,
pinning
api
server
spec,
so
yeah
we
have
this
great
pending
service,
api
spec,
and
the
great
thing
about
this
is
that
it
offers
great
interoperability
between
the
different
services.
So
you
know
they
might
actually
implement
a
slightly
different
http
api,
but
because
they
adhere
to
the
spec.
A
But
now
that
we
have
this
compliance
check
and
we
have
a
swagger
api,
we
can
build
all
of
these
great
tooling.
That
works
with
all
of
these
different
services
and
give
ipfs
users
more
options.
And
so
how
does
earth
spinner
work
and
what
does
it
actually
do?
Essentially,
it
allows
you
to
take
a
car
file
and
then
pin
that
onto
a
pinning
service,
so
it
takes
the
car
files.
Input
makes
an
http
request.
A
Hopefully
the
pinning
service
will
give
back
some
delegates
to
connect
to,
and
then
it
basically
starts
a
leap.
P2P
host
connects
to
those
delegates
and
makes
the
blocks
available
over
bitswap.
A
There's
a
little
demo
here,
it's
one
minute
so
I'll
just
just
to
get
a
feel
for
what
it's
like.
So
you
can
list
the
pins
that
you
have
and
here
I'm
actually
making
a
pin
request
that
made
the
http
request.
The
status
is
queued
it
connected
to
the
delegates
and
then
it
sort
of
tracked
the
state.
A
And
now
we
can
see
that
we
have
this
rocky
road
pin
and
then
now
I'm
just
getting
the
token
for
pinata
and
I'm
basically
doing
the
same
thing
with
pinata,
so
pinning
the
same
file
pinata
and
estuary
they're
both
returning
delegates
and
spoken
to
some
of
the
dot
storage
team-
and
I
know
you're
going
to
return
the
delegates
soon
so
and
there
we
have
it.
A
So
it's
waiting
for
the
blocks
to
be
transferred,
and
hopefully
that
will
complete
yeah
there
we
go,
and
so
that
was
it
and
you
can
obviously
also
delete
pins.
A
So
that
was
it
and
those
were
some
of
the
libraries
that
I
used
for
this.
And
finally,
I
so
this
was
obviously
a
learning
journey
for
me
and
you
know,
as
I
mentioned
you
know,
not
all
of
the
pinning
services
returns,
delegate
return
delegates
which
makes
it
tricky,
because
the
only
alternative
you
have
is
to
pass
origins
and
if
you
have
a
short-lived
ospina
instance
that
just
starts
a
new
lib
p2p
host,
it's
probably
behind
that
or
a
firewall.
So
that
means
it's
not
publicly
reachable.
A
So
you
have
to
do
upnp
or
you
have
to
do
hall
punching
with
circuit
relay,
and
so
I
got
upnp
working,
but
then
that
sort
of
breaks
this
idea
of
this
being
a
short-lived
instance,
because
well
you
have
to
wait
for
the
router
to
give
you
to
do
the
port
mapping.
Another
thing
that
was
a
bit
tricky
was
tracking
the
pinning
progress.
A
So,
basically,
you
have
a
status
that
you
get
from
the
http
api
and
you
can
just
pull
the
api
and
wait
to
see
that
the
status
changed
that
felt
a
bit
coarse,
but
that's
how
it's
doing
it
and
if
you're
obviously
doing
a
big
file,
then
you
know
that's
not
ideal,
because
you
can't
know
how
far
along
you
are,
and
so
I
did
an
experiment
using
the
bandwidth
counter
to
basically
measure
the
uploaded
bytes
over
the
basically
the
lib
p2p
host
and
yeah
there's
some
sort
of
different
ideas
about
how
to
sort
of
make
this
maybe
a
bit
more
versatile.
A
I
did
a
session
with
jaropo
on
basically
taking
a
file
and
then
unix
effects
signing
it.
I
guess
that's
the
word
yeah,
basically
chunking
it
and
turning
it
into
a
uxfs
representation
or
maybe
using
go
ipld,
prime
and,
as
I
mentioned,
better
progress
tracking
and
if
you
have
any
ideas
for
how
this
could
be
a
bit
more
versatile
and
usable
I'd
love
to
hear
your
ideas.
A
So
that's
pretty
much
it.
It's
been
a
great
learning
journey
and
thank
you
to
everyone
who
helped.
I
think
we
have
a
lot
of
different
ipfs
implementations
and
it's
really
like
cool
to
see
this
the
discussion
around
what
even
is
ipfs
kind
of
like
expanding
as
we
explore
this
space.
So
thank
you.