►
From YouTube: 2023-02-20 Helia (IPFS JS) Demo
Description
The 2nd demo of Helia, a new IPFS implementation written in JS.
Information and source code for Helia: https://github.com/ipfs/helia
Sign up for future sessions: https://lu.ma/helia
A
Hi,
everyone
welcome
to
the
Helia
demo
day
for
the
20th
of
February
2023.
I'm.
Making
brain
I
will
be
your
host,
we're
going
to
go
through
what's
new
since
the
last
the
last
demo
day.
Well,
a
brief
overview
of
what
Helia
is
what's
new.
What's
coming
next
and
then
we'll
have
some
time
for
Q
a
yeah,
so
I
am
going
to
start
sharing
my
screen.
A
Okay,
this
is
me
I'm,
making
playing
on
the
internet
I'm
on
the
open
stewards,
team,
I'm,
the
maintainer
of
Chester,
P2P,
Chase,
ipfs
and
now
Helia.
A
So
as
we're
going
to
cover
well
here,
it
is
some
demos
and
there's
some
point
for
Q
a
what
is
it
I
went
through
this
last
time,
so
I'm
gonna
go
somewhere
a
lot
quick
more
quickly,
this
time
and
in
essence,
as
a
replacement
for
JS
ipfs,
it's
smaller
faster,
and
it
is
more
more
sympathetic
to
the
environment
that
you
are
working
in,
like
the
web,
more
lightweight
with
fewer
apis,
fewer
ways
to
do
the
same
thing,
just
hopefully
a
better
implementation
in
general.
A
So
the
API
is
very
simple:
it
tries
to
be
agnostic
about
as
many
things
as
possible.
So
all
it
is
is
a
block
store
which
is
a
place
for
you
to
put
blocks
I
mean
surprisingly,
which
is
backed
by
bit
swap
so
if
you
try
to
get
something
from
the
bits
from
the
blog
store-
and
you
don't
have
a
given
block
for
the
CID,
it
will
go
to
the
network
and
it
will
fetch
it.
A
It
has
a
data
store
which
lets
you
store
application,
specific
data,
so
things
like
DHT
records,
ipns
records
and
anything
really
that
your
application
needs
to
store.
This
can
be
backed
by
a
level
database
or
stored
on
a
file
system
or
some
other
implementation.
It
supports
pinning.
So
if
you
have
dags
that
are
important
to
you,
you
can
pin
the
rear
of
the
dags
and
then
it
will.
You
can
run
garbage
collection
and
it
will
delete
blocks,
are
not
part
of
those
tags
under
P2P.
A
So
the
networking
layer
is
the
P2P
exactly
the
same,
with
Json
PFS
with
the
same
features
and
limitations,
but
it
does
not
try
to
re-implement
or
you
know,
mirror
any
of
the
apis
in
the
P2P.
The
entire.
A
The
P2P
node
is
exposed,
which
takes
care
of
things
like
Pub
sub
and
the
DHT
and
and
all
that
kind
of
low
level
stuff
that
you
generally
don't
think
about
when
you're
dealing
with
file
systems,
so
it
tries
to
favor
composition
rather
than
trying
to
add
functions
and
methods
for
every
possible
opportunity
and
every
possible
bit
of
functionality.
So
you
will
typically
see
components
except
a
helium
node
and
extend
its
functionality
by
adding
code.
That
then
calls
methods
on
the
Block
store
on
the
data
store
so
new
from
this
time.
A
Last
from
the
last
demo
day
example,
so
we
now
have
a
Helia
examples:
repo,
it's
in
the
ipfest
examples,
org,
there's
a
few
simple
examples
in
it:
101
how
to
use
heliers
from
common
JS.
Yes,
perennial
issue
that
never
seems
to
go
away.
I
can't
use
Helia
in
CDs.
Yes,
you
can.
A
You
totally
can
but
there's
an
example
in
everything
you
can
copy
and
paste
the
code
and
just
become
productive
immediately
and
then
I
demo
of
how
to
use
it
with
webpack,
which
is
just
the
first
of
many
examples
of
how
to
use
these
things
with
common
tools.
A
You'll
notice
that
this
is
actually
part
of
a
lot
of
these.
These
examples
are
similar
to
ones
in
the
JSI
FS
repo.
That's
because
they've
imported
over
to
use
the
new
API.
So
just
a
very
quick
demo,
it's
not
really
a
demo
I'm,
just
gonna
show
you
the
repo
the.
B
A
Yeah,
so
this
is
the
repo,
so
you've
got
a
list
of
examples
you
can
go
in
and
have
a
look
at
them.
So
let's
see
the
S1,
for
example.
It
just
has
the
example.
Code
runs
a
simple,
not
a
simple
program
using
Helio
that
demonstrates
the
bit
of
functionality
that
it's
trying
to
show
you
and
there's
a
test
to
ensure
that
we
don't
break
these
things.
A
Okay,
what
else
unixfest
so
the
first
version
of
Helios
Unix?
So
that's
implementation
is
shipped.
What
is
it?
Well,
it's
a
way
of
doing
file
system
operations.
It's
probably
what
you
came
here
for
it's
a
way
it
tries
to
differentiate
yourself
from
materials.
Like
you,
first,
like
the
learnings
that
we've
applied
are
there.
You
want
operations
that
you
recognize.
You
don't
want
to
use
esoteric
API
to
do
really
simple
things
like
add
a
file
to
the
directory,
so,
for
example,
in
JSI
profess
well
in
Cuba
and
change.
Something
there's
by
extension.
A
The
most
ergonomic
way
to
use
Unix
FS
is
basically
MFS,
so
the
MFS
is
a
a
set
of
commands
that
you
can
use
to
operate
on
a
single,
dag
and
do
things
like
add
directories
and
add
files
of
those
directories
and
that
kind
of
thing
which
then
all
trickles
up
to
a
root.
Cid,
that's
stored
in
a
known
location
in
the
data
store
and
change,
and
that
changes
all
the
time.
There's
like
way
more
information
than
you
need,
when
all
you
really
want
to
do
is
add
a
file
to
the
directory.
A
So
what
a
lot
of
people
end
up
doing
is
they
drop
down
to
the
object,
API
and
then
you're
in
your
deep
into
like
dag
nodes
and
daglings
and
all
this
kind
of
stuff,
which
has
got
nothing
to
do
with
adding
a
file
to
a
Direction?
So
the
API
of
Helios
Unix
versus
implementation,
very
much
tries
to
give
you
the
kind
of
Primitives
that
you
would
expect.
It's
also
it's
not
opinionated
about
how
to
import
a
tag
so
Cuba
and
Json
respite
extension.
A
Has
this
ad
method
that
accepts
all
kinds
of
input
and
transforms
it
into
a
stream
of
files
and
folders,
and
all
this
kind
of
thing
which
a
lot
of
people
find
a
little
hard
to
use
in
some
and
so
forth.
So.
A
Implementation
doesn't
really
try
too
hard
to
get
you
to
import
content
in
certain
ways,
so
you
can
use
the
Importer
Unix
importer
or
you
can
use
some
of
these
other
implementations
if
you
next
device
that
is
bringing
up
like
the
ipld
Unix
implementation,
which
is
a
different
implementation.
That
kind
of
focuses
on
web
streams
and
this
kind
of
thing
it
doesn't
have
all
the
features
that
the
ipfs
Unix
of
s
implementation
has.
It
doesn't
support
sharding,
for
example,
just
for
metadata.
A
A
A
A
So
you
pass
in
your
helium
node
and
you
get
a
file
system
object
back,
which
has
all
these
methods
that
you
can
call.
A
B
A
Going
to
turn
it
into
a
v
zero
CID,
because
for
some
reasons,
if
it
will
become
apparent
shortly,
so
if
I
just
run
my
my
code
and
see
oh
look,
it's
the
old
qm
models,
the
mtcod!
That's
great!
What
do
we
do
with
it?
A
So
now
I
have
DMT
the
MTC
ID,
the
EMT
directory
crd
and
then
the
contents
of
my
my
folder,
which
is
a
directory
called
bar
with
the
part,
is
passed
and
here's
the
CID
of
bar
we've
got
a
function
that
I
can
call
to
get
the
content
of
it.
I've
got
some
Unix
investment
metadata
and
some
some
extra
information,
so
here's
my
dag
node
that
backs
the
the
root
node
of
that
dot,
CID
and
the
size
Etc.
So
you
know
some
something's
interesting.
So
the
size
is
a
bigint.
A
A
A
A
A
And
then
what
I'll
do
is
I
will
list
out
the
content
of
that
directory
again,
so
you'll
notice
that
I'm
passing
to
start
with
this
CID
and
then
I
do
an
operation
on
it
and
I
receive
a
new
CID
I
do
an
operation
on
it
here
and
I
receive
another
new
CID.
So
all
the
way
I
mutate,
I'm
getting
new
dags
built
behind
the
scenes
and
I
can
obviously
step
back
in
time
and
use
previous
cids
and
then
I
will
see
the
state
of
the
dag
as
it
were
before.
I
did
this
operation
on
it.
A
Live
code
in
more
fun,
anyway,
okay,
so
here
I
have
my
MCC
ID
I've
created
a
directory
called
bar
and
then
I've
added
my
file.
There's
my
file,
CID
I
copy
it
into
the
directory
and
finally,
I
list
directory.
Look
I've
got
a
directory
and
I've
got
a
filed
incredible.
So
a
few
things,
that's
interesting
to
note.
I
mentioned
the
size
being
bigots.
The
CID
has
come
back
to
V1
by
default,
they're
raw
leaves
by
default.
A
These
are
all
the
kind
of
things
that
we
wanted
to
make
the
changes
that
we
wanted
to
make
for
more,
a
more
efficient
directs
and
that
kind
of
thing.
So
those
are
the
defaults.
But
obviously,
if
you
want
the
old
school
versions,
you
can
you
can
just
pass
an
options
object
into
in
the
Importer.
You
can
change
the
CID
version
back
to
zero,
we're
only
used
to
false,
etc,
etc.
A
You
can
also
do
you
know
you
can
change
your
layout,
so
you
might
want
to
trickle-dag
and
also
name
it's
up
to
you.
It's
up
to
you,
wonderful.
What
what
a
great
lot
of
choice!
You
have.
Okay,
no
share
back
to
the
demo.
Okay,
enough
of
that
right,
what
else?
Okay,
so
ipns,
totally
shipped
to
First
ipns
implementation?
What
is
it
like
it's
this?
Is
you
know
it's
something
that
people
ask
for
a
lot
mutable
points
is
like
cids
are
great
until
like
people
are
like,
oh
I've
got
my
website
on
ipfs.
A
This
is
great.
It's
a
CID,
oh
I
need
to
update
my
website.
Oh
okay,
the
content's
still
low
anyway.
So
IPS
is
this
way
that
you
have
mutable
data
points,
so
you
have
a
peer
ID.
Well,
you
have
a
public
key,
an
easy
way
to
have
a
public
key
in
ipfs
to
have
a
peer
ID,
which
is
a
public
key,
and
you
publish
a
record
that
corresponds
to
that
public
key
to
the
result
of
a
CID.
In
order
to
resolve
it,
you
you
either!
Well,
you
have
to
receive
an
updated
record
somehow.
A
A
lot
of
moving
Parts
fundamentally
very
hard
to
debug,
because
there
are
lots
of
lots
of
Premium
modes,
but
it's
very
important
and
also
in
his
keyboard,
interrupt
I'm,
going
to
close
this
very
quickly,
because
it's
very
easy
to
you
can
poke
your
way
through
the
repo
or
your
leisure
and
I
would
love
to
talk
to
people
more
about
this,
because
it's
very
interesting.
B
A
So
here
we
go
I'm
just
going
to
go
through
this
very
quickly,
so
these
are
the
these.
Are
the
interrupt
tests
for
Helia
ipns,
so
each
each
repo
is
where
it
has
significant
functionality
is
now
being
bundled
where
they
say
an
interrupt
Suite.
So
these
interrupt
Suite
is
sure
that
we
can
ensure
that
we
can
work
with
Cubo.
A
If
we
get
like
a
rusty,
Krust
ipfs
release
on
npm
at
some
point
it
would
be
great
to
ensure
that
it
works
with
us
as
well,
but
in
the
interim
it's
just
Cuba.
It's
stuck
I'm
just
going
to
run
I'm
just
going
to
run
this
one
first
to
prove
that
it
worked.
A
A
We
publish
a
we
published
the
value,
which
is
this,
the
ID
that
we've
we've
prepared
earlier
and
then
yeah.
We
resolve.
A
So
we
use
Cuba
to
resolve
the
name
that
we
publish
on
okay
first,
so
there's
no!
No,
it
was
an
iPhone
has
to
use
them
Helios.
So
this
name
variable
is
an
instance
of
ipns
you'll,
see
that
we,
in
the
same
way
that
we
create
with
unixfs,
we
have
an
ipns
Factory
function.
We
pass
in
Helia.
We
have
one
routing
mechanism
here,
which
is
the
DHT.
A
What
else
so
in
order
to
configure
Helio
to
to
validate
and
select
records
properly,
we
need
to
pass
in
the
IPS,
validator
and
ipness
selector.
The
reason
it's
like
this
is
because
maybe
you
don't
need
open
S
at
all,
and
if
you
don't,
why
are
you
bundling
all
this
code
with
all
these
extra
dependencies?
A
A
With
a
thing,
these
ones
are
always
lots
of
fun
to
run
with
the
DHT
versions,
because
you
need
to
ensure
that
all
of
your
it's
like
you
need
to
make
sure
that
the
node
that
you're
published
into
is
the
one
you
think
is
going
to
get
the
record
look.
It
was
amazing.
B
A
A
Pinning
I
just
open
a
PR
tahitia
to
our
pinning,
so
it
uses
some
interesting
some
interesting
differences
between
this
and
JSI
BFS,
so
originally
Kubo
defined
how
pinning
works,
and
so
all
the
pins
are
stored
in
an
enormous
tag,
and
you
would
Traverse
that
dag,
while
creating
a
list
of
blocks
that
are
doomed
to
be
removed
from
the
Block
store.
A
This
turned
out
to
be
horrifically
slow,
so
Jay's
going
to
switch
to
using
a
data
store
to
store
the
pins
rather
than
a
big
tag,
which
was
like
massively
faster,
but
garbage
collection
was
still
quite
slow
because
every
time
you
did
Garbage
Collection,
you
would
Traverse
all
the
pin
dags
ever
to
see
which
ones
which
which
box
depend
on
which
ones
were,
of
course,
the
interesting
thing
about
dogs.
Is
they
never
change?
So
why
would
you
do
that?
So
what
Helia
does
is
instead
uses
reference
canceling.
A
So
when
you
pin
a
dag
it,
it
traverses
the
dag
to
ensure
that
the
blocks
are
present
and
where,
where
a
block
is
present,
it
makes
a
note
of
the
root
CID
and
the
block
that
it's
encountered
while
traversing
the
dag.
Then
it
stores
another
record
of
that
if
you
pin,
if
you
have
like
the
same
block,
that
is
pinned
via
two
different
cids,
the
same
things
happen
and
the
reference
count
is
incremented
for
that
block.
When
you
unpin
a
CID,
you
Traverse
the
dag
again
and
you
decrement
the
references
for
each
block.
A
If
the
reference
is
zero,
then
we
know,
then
we
remove
that
record
entirely
and
then,
when
we
come
to
the
garbage
collection,
we
just
need
to
go
through
the
the
data
store
and
look
at
which
which
blocks
have
references
like
any
references
to
pin
cids
and
then,
if
they
don't,
we
just
delete
them.
This
turns
out
to
be
a
lot
faster
than
traversing
nodes,
so
you
can
see
from
the
benchmarks
there.
The
heater
is
about.
A
You
know
a
third,
it's
about
half
faster
than
kibo
and
then
three
times
faster
than
Cuba
doing
the
same,
pinning
operations
pinning
and
GC
operation,
which
is
quite
fun.
It
says
it
says
demo,
but
you
know
LOL
I'm
not
really
going
to
demo
this,
because
it's
very
easy.
But
this
issue
has
all
the
discussion
and
then
there's
PR
here
number
36
has
the
actual
implementation
and
The
Benchmark
Suite,
so
I
invite
you
to
have
a
look
at
that.
A
What's
next
docs
more
examples,
other
file
systems,
maybe
definitely
trying
to
make
things
more
approachable,
so
I
think
with
the
pinning
API
that
kind
of
settles
the
API
for
here
I'm,
not
convinced
it
needs
any
other
Methods
at
all.
I
think
all
our
functionalities
would
just
be
modules
that
extend
it.
A
A
lot
of
Unix
and
ipns,
so
I
think
I
think
it's
safe
to
start
documenting
it
in
a
way
that
you
know
is
approachable
because
I,
don't
think
the
API
healer
itself
is
going
to
change
that
much
everything
else
I
think
will
be
experimentation
on
top
of
it,
rather
than
changing
the
core
of
it
but
yeah.
So
we
need
more
of
the
examples
putting
and
this
kind
of
thing
so
trying
to
pull
some
of
these.
A
C
I
have
one
question
so
thanks
for
the
introduction,
so
if
we
were
interested
in
having
like
Gateway
functionalities,
would
this
be
within
the
scope
of
this
project?
Or
do
you
see
that
something
on
the
side
that
will
be
implemented
externally.
A
Well,
I
think
if,
if
you
have
a
need
for
a
Gateway
I,
think
it's
I
think
if
now
we
have
the
Gateway
spec,
which
is
a
lot
smaller
than
me.
The
keyboard
RPC
API
should
be
relatively
trivial
to
implementing
using
Helia
I'm,
not
sure
I
will
personally
be
doing
it,
but,
like
you
can
see
the
way
that
Helio
is
extended
for
unixfs
and
ipns.
So
it
would
be
trivial
to
just
incorporate
that
into
a
simple
web
server
that
you
know
answers
the
whatever
it
is.
C
Do
you
think
this
will
be
just
the
only
missing
component
to
make
it
possible
to
integrate
it
with
something
like
say,
ipns,
companion,
ipfs
companion,
the
the
extension.
A
I'm
familiar
with
the
API
of
what
would
actually
be
missing.
Is
it
just
the
Gateway?
Is
that
all
that
needs
to
be
implemented?
Yeah.
C
Because,
because
previously
it
was
letting
you
use
like
you
could
use
like
the
previous
JS
implementation,
but
it
since
it
didn't
support
the
you
know,
gateways
it
basically
was
very
limited.
D
Thanks
yeah
thanks,
Thomas
and
like
if
that's
something
you're
interested
in
I,
don't
know
if
you
have
interest
in
contributing
that
I,
don't
think
we
have
an
issue
tracking
that
effort
and
I
agree
with
Alex.
As
probably
is
it's
it's
a
separate
thing
that
will
consume
it,
Helia
versus
being
baked
into
heli
itself.
D
I
will
say
there
is
a
lot
of
General
effort
by
other
folks
in
the
ipfs
community
around
the
gateways
in
terms
of
making
sure
that
they
get
even
more
fully
specified
and
there's
even
some
work
getting
started
around
having
conformance
tests
of
Gateway,
HTTP,
Gateway
implementations
because
there's
obviously
the
Kubo
implementation
we've
been
on
the
Kubo
side
with
Mingo.
We've
been
extracting
some
of
that
logic
out
into
a
general
Library,
so
that
others
can
make
their
own
Gateway
implementations.
D
So
anyway,
there's
definitely
a
active
area,
a
lot
of
people
in
involved,
but
I,
don't
think
anyone
has
raised
their
hand
to
go.
Build
a
JS
implementation
of
the
HTTP
Gateway,
spec
and
it'll
be
awesome
to
see
that
get
to
get
built
and,
if
you're
interested
in
contributing
love
to
talk
more
thanks
for
asking.
E
How
the
ipns
resolution
so
so
I
can
s
resolution
right.
You
pass
in
a
router
right.
You
can
pick
the
DHT
that
can
you
do
Pub
sub
resolution
at
this
point,
yep.
A
Yep,
if
you
look
in
the
openness
repo
you'll
see
in
the
interrupt
Suite,
there's
both
ght
and
Pub
sub
resolutions
and
of
course
you
can
use
both
at
the
same
time
as
well.
A
E
Basically,
okay
and
in
terms
of
like
observability,
what
what
kind
of
like
Observer
like
what
kind
of
observability
features?
Do
you
get
with
the
with
these
kinds
of
operations?
You
know
because
the
DHT
lookups
it
it's
not
like
this,
yes
or
no
type
operation
right.
It
has
to
like
Traverse
the
DHT
and
maybe
connect
to
new
peers
along
the
way.
How
can
you
like
know,
what's
actually
going
on
if
you
really,
if
you're,
trying
to
resolve
some
problems
or
you're,
not
sure,
what's
going
on
under
the
hood.
A
So
these
the
opens
apis
have
the
first
kind
of
like
set
of
unprogress
events,
so
I'm,
just
gonna
share
and
I'll
show
you
what
I'm
talking
about
so
in
the.
A
So
openness
has
these
Pro
progress
events,
so
you
can
pass
in
a
you,
can
pass
in
an
unpublished.
A
Sorry,
it
wasn't
an
unparagraph
handle
service,
USE
events
and
the
events
are
these.
You
know
informational
things
and
you
get
a
a
context.
Object
a
detailed
object
on
the
event
itself.
A
The
individual
routers
also
have
their
own
events.
So
you'll
see
PhD,
query
events
appear,
DHT
errors
for
Pub
sub
you'll,
see
100
subscriber
narrow
events,
so
you
basically
get
all
sorts
of
Errors.
So
all
sorts
of
moving
Wheels
hopefully
get
also
some
success
messages
but
you'll
see
all
sorts
of
progress.
Events
which
you
can
use
to
kind
of
diagnose
problems
with
resolution.
D
There's
a
question
from
Thomas
about
ens
and
yeah
resolution
on
ipns
and
chat.
A
The
machine
so
there's
there's
the
resolve,
resolve
function
on
the
ipns
object,
which
will
use
all
the
different
which
will
use
the
pubs
up
in
the
DHT
resolvers
to
try
and
find
the
DNS
record
and
then
there's
resolve
DNS,
which
takes
a
domain
name
which
will
do
a
DNS
lookup
and
try
and
resolve
the
record.
That
way.
A
Like
I
intentionally
split
resolve
and
resolve
DNS,
because
they're
completely
different,
there's
no
overlap
at
all
in
how
they
how
they
work
internally.
So
you
know
all
those
progress
events
and
all
that
kind
of
thing
aren't
really
applicable
to
the
DNS
resolutions.
Just
like
look
up
to
do
the
DNS
lookup
for
the
text
record
and
see
if
it's
there
or
not.
A
A
Okay,
I
think
we.
A
Over
time,
oh
I
have
a
question:
okay,
is
it
what's
your
password
I,
don't
know,
okay,
I'm
gonna
start
recording
up.
A
This
has
been
the
Helia
demo
day
for
February
the
20th
2023.
I'll,
see
you
for
the
next
one:
okay,
bye.