►
Description
w3name: IPNS republishing as a service - presented by @alanshaw at IPFS þing 2022 - Connecting IPFS - https://2022.ipfs-thing.io
A
So
this
is
a
talk
about
w3
name:
it's
our
ipns
republishing
service,
that's
currently
available
on
web3.storage.
This
is
just
how
it
works.
At
the
moment,
it's
been
like
that
for
a
while,
but
yeah
you
can.
You
can
go
on
a
web
3.storage,
look
at
the
docs
and
use
it
use
it
right
now,
if
you
like,
I'm
just
going
to
tell
you
a
little
bit
about
it,
so
yeah
ips,
it's
a
way
of
adding
kind
of
mutability
to
ipfs.
A
Ipfs
does
immutable
really
well,
and
it
even
has
like
to
add
this
mutability.
It
has
a
thing
called
mfs,
which
is
essentially
this
thing
which
allows
you
to
sort
of
manipulate
a
dag,
as
you
add
new,
add
new
things
to
it
or
take
things
away
from
it
and
that
kind
of
gives
you
the
illusion
of
kind
of
mutability.
But
what
it's
doing
is
creating
a
new
thing
each
time
and
you
get
a
different
cid.
A
So
if
you
share
like
a
cid
of
a
dag
with
someone
and
then
you
change
it
and
you
get
a
new
cid
you're
gonna
have
to
share
that
new
cid
for
them
to
see
those
updates
that
you
made,
and
so
wouldn't
it
be
cool.
If
there
was
like
a
cid
that
you
didn't
have
to
kind
of
ch
that
didn't
change
when
you
changed
the
the
dag.
Well,
that's
ipns
so
kinda!
A
So
here
we
go
a
little
bit
background
on
ips.
If
you
don't
don't
know
about
it
like
it
all
starts
with
kind
of
cryptographic,
keys,
public
key
and
a
private
key.
The
public
key
is
the
old
looking
one
and
the
private
key
is
the
shiny
gold,
one
which
is
a
special
one,
which
you
shouldn't
share
with
anyone.
A
And
so
just
clear,
this
is
the
same
sort
of
keys
that
you
that
you
kind
of
typically
work
with
in
with
ipfs.
So
when
you
iqfs
in
it
you'll
get
a
key
generated
for
you
and
you
can
list
it
out
like
that
and
it's
called
called
self
by
default.
And
then
you
can
generate
your
own
key
and
call
it
my
key
and
you
get
a
new
one,
and
just
these
are
just
the
same
sort
of
keys.
You
work
with
with
ipfs
just
to
be.
B
A
A
No,
I
can't
remember,
but
it's
not
really
important
but,
like
you
can
think
of
an
ips
record
as
a
mapping
between
like
a
cid
or
an
it's
actually
like
an
ipfs
path
and
a
c
so
a
public
key
and
a
and
a
cid.
So
this
is
the
public
key.
This
is
the
cid
and
the
cool
thing
about
ipns
records
is
that
they
can
change
over
time.
A
You
can
get
the
latest
revision
using
like
a
http
get
and
it
will
give
you
back
the
current
ips
record
for
that
public
key,
that's
kind
of
cool
because,
like
you
know
it
might
have
changed
since
the
last
time
you
asked,
or
you
might
have
not
got
it
yet
so
it's
good
to
be
able
to
get
the
resolve
the
current
version.
So
so
that's
good!
But
how
do
you
know
when
the
record
changes?
A
Well,
because
you
might
not
be
the
one,
that's
actually
publishing
that
change
to
someone
else,
you're
just
kind
of
consuming
it,
maybe
well.
We
have
a
websocket
for
that.
So
you
can
listen
on
the
websocket
for
on
particular
keys
and
get
pushed
an
update
or
the
new
ips
record
as
it
gets
published.
So
that's
cool!
You
know.
The
record
is
good.
A
That
comes
down
the
line
because
it's
been
signed
by
the
author
and
you
can
also
like
validate
newness
based
on
like
if
you
have
an
existing
one,
you
can
compare
them
and
make
sure
the
sequence
number
is
greater
and
expiry
date,
et
cetera,
yeah.
So
does
that
that's
rad?
And
if
that's
not
enough,
then
what
we
also
do.
Is
we
publish
these
records
that
we
receive
to
the
dht?
A
So
these
names
are
resolvable
by
anyone
running
an
ip
ipfs
node
and
even
at
ipfs
gateways,
which
is
kind
of
cool.
You
can
just
type
ips.I,
o
slash,
ipns,
slash
key
and
it
will
resolve
the
name
to
the
latest
version.
Get
that
ipns
record
and
also
resolve
that
cid
to
whatever
data
it
is
and
serve
it
back
to
you,
which
is,
which
is
super
useful
cool.
So
this
is
a
that's
it
by
the
way.
That's
the
that's
the
that's
the
simple
mutability
api
that
we
have.
A
This
is
a
demo
of
a
like
a
dram
relay,
and
so
drand
is
a
distributed.
Randomness
beacon
every
30
seconds
it
emits
new
randomness
for
people
to
consume.
They
have
multiple
nodes,
collaborating
together
to
generate
this
randomness
and-
and
so
all
this
demo
is
is.
This
is
a
relay
that
updates
an
ips
record
with
the
new
randomness
value
as
it
gets
emitted
from
from
dram.
So
how
does
that
work?
A
Well,
all
we
have
is
this
kind
of
relays
vm,
just
it's
just
a
script,
that's
listening
to
dram
randomness
and
every
30
seconds
it
will
receive
that
randomness
and
it
kind
of
looks
like
this.
Every
randomness
has
like
a
round
number
which
is
sort
of
the
id
for
the
randomness,
the
randomness
value,
which
is
this
and
the
signature
which
typically
the
client
you're
using,
will
validate
that
for
you.
But
it
means
that
you
can
ensure
that
the
randomness
came
from
the
chain
that
you
expect
it
to
be
coming
from.
A
So
that's
good.
So
anyway,
once
we've
got
some
new
randomness
every
30
seconds.
What
the
relay
does
is
actually
puts
that
data
on
web3.storage
and
when
web3.storage
does
it
gets
it,
it
does
what
it
normally
does
and
it
creates
a
deal
on
filecoin
stores
that
data
it
puts
it
on
elastic
ipfs,
and
then
we
have
a
cid
for
that
new
randomness.
A
A
Yeah
it's
so
it's
open
source
on
github,
so
you
can
just
check
it
out.
I've
got
a
key
running
in
production,
it's
a
demo
so
for
this
key
you
can
actually
go
and
ask
web3.storage
api
for
the
current
ips
record
for
this
key,
and
if
I
make
that
a
little
bit
bigger
here,
we
go
so
the
value
here
is
just
for
convenience,
because
if
you
want
to
pick
it
out,
this
is
this
record.
Here
is
the
actual
ips
record.
You
can
pick
out
that
value
from
the
record.
A
A
There
we
go
yeah,
so
seven
night,
793,
okay,
so
that
was
reasonably
that's
my
mouse
gone.
Is
there
here
there
we
go.
So
this
is
the
current
the
current
value
I
think
we
just
put
in
790,
so
we
were
like
free
off
okay
so
anyway,
but
the
cool
thing
is,
I
think,
is
if
we,
if
we
actually
take
that
ips
key,
we
should
be
able
to
do
the
same
thing.
A
B
A
A
A
In
so
we
have
a
js
client
for
this,
which,
which
is
useful
information.
I
didn't
tell
you,
and
so
it
adds
like
a
far
future
expiry
date.
It's
like
a
year
or
something
we
do
republish
these,
the
the
I
can
s
records
to
account
for
like
network
churn
and
so
yeah,
it's
kind
of
your
no.
I
don't
have
a
specific
like
recommendation.
I
think
the
the
default
is
like
24
hours
or
something
in
ipfs,
but.
B
A
A
A
Has
anyone
used
this
yet,
like
I
don't
know,
we've
got
like
500
or
so
I
can
s
records
that
and
that's
just
individual
records
but
like
they
can
get
obviously
updated
with
new
sequence
numbers
every.
So
often
I
don't
know
how
many
actual
updates
we've
had
off
the
top
of
my
head,
but
I
think
we've
got.
A
B
B
B
A
B
A
B
Whenever
you're,
like
just
run
a
server,
people
aren't
gonna
use
it
so
like
okay,
if
we
could
host
these
and
then
there's
like
a
consensus
mechanism
because
you're
sending
it
to
this
one
service,
then
maybe
people
will
use
it
and
then,
after
you've
been
building
it
out.
It's
like
there's
some
other
issues
like
even
once.
You
have
the
service.
B
A
I
mean
it's
super
because
of
because
of
the
local
cache
that
we
have
in
web
3d
stories
that
the
centralized
thing
is
super
reliable.
I
guess,
as
far
as
centralized
things
are
the
ips
thing
I
mean
we
haven't,
made
any
progress
in
making
that,
like
we
haven't,
done
any
changes
or
fixes
to
make
that
more
reliable.
As
it
is
aware,.
B
A
B
A
A
If
you
have
a
long
expiration
time,
then
I
like
the
the
only
danger,
I
think,
is
that
you
can't
just
publish
it
and
forget
about
it
because
of
like
the
the
peers
that
you
put,
that
information
on
might
drop
out
the
network
and
then
no
one
will
be
able
to
resolve
it.
So
like
it's,
it's
that,
like
balance
of
like
how
he's
gonna
actually
be
able
to
send
it
back
to
you
yeah.
I
don't
know
if
there's
any
other.