►
Description
Originally recorded during the Berlin Developers Meetings from July 9-13, 2018.
A
So
I'm
Jonny
crunch
and
so
I'm
gonna
talk
about
the
decentralized
identifiers.
We
touched
upon
this
a
little
bit
yesterday,
so
I
built
the
specification
of
the
D
ID
spec
on
top
of
IP
FS,
which
I
call
IP
ID.
This
was
born
out
of
frustration
using
project
in
D
in
hyper
ledger,
which
is
code
donated
by
the
sovereign
foundation
to
to
hyper
ledger
and
at
a
hackathon
I,
dug
through
the
code.
Realizing
what
they're
trying
to
accomplish
was
a
key
value
pair
using
distributed
hash
table
and
I
said
wait
a
minute.
This
looks
familiar.
A
This
looks
like
AI,
TFS
and
so
in
a
weekend,
I
hacked
something
together.
So
self-solving
digital
identities
came
out
of
the
rebooting
web
of
trust.
It's
a
global
identifiers
as
basically
an
urn
Uniform,
Resource
name
like
a
UID
or
the
namespace
identifier,
so
I
built
one
similar,
here's
the
one
that
was
shown
yesterday,
sovereign
or
the
method,
specific
identifier
and
the
method
there
being
sovereign,
so
I
built
one
using
I
called
IP
ID
with
a
name
specific
identifier.
A
That
is
the
hash
of
the
public
key
that
resolves
to
an
IP,
NS
namespace
that
actually
resolves
to
either
a
JSON
document
stored
in
ipfs
or
now
I'm,
actually
storing
an
IP
LD
resource.
So
let
me
give
you
so
basically
here's
the
the
JSON
that
this
is
what
we're
working
on
with
the
diff,
the
decentralized
entity,
foundation
and
w3c
about.
What's
this
Jason
looked
like
what
are
they
actually
the
the
structure
of
the
JSON?
How
to
actually
like
create
these
attributes?
A
The
how
you
rotate
the
keys
update
the
keys.
So
this
is
still
in
flux,
a
lot
of
its
coming
out
of
the
w3c
work,
but
you
know
basically
ipfs
dag
put
you
guys
know
how
to
do
this,
and
then
you
know
obviously
IDF
s,
dag
resolve
and
let
me
go
here
so
I'm
published
in
this
case:
I'm
publishing
it
to
an
IDI
two
five:
five,
one,
nine
key
Thank
You
Jeremy
for
supporting
that
and
basically
pushing
the
IPO
I.
He
LD
resource
to
that.
In
this
case
the
EC.
A
Indeed,
two
five
five
one
nine
and
then
I
built
some
go
code
to
resolve
it
and
so
it'll
go
actually
fetch
it
actually
Thank
You
Kyle
for
actually
fixing
the
resolution.
This
is
in
case
I'm
still
using
elliptic
curve,
so
actually
takes
still
a
little
bit
longer
than
in
the
DHT
to
actually
to
resolve
it,
but
it
should
come
back
in
this
case.
It'll
come
back
actually
with
the
signed
QR
code.
A
Any
second
now
come
on
come
on
Kyle,
don't
don't
fail
me
all
right!
I
won't
wait
for
it.
So
let
me
go
back
to
the
presentation,
so
this
is
like
a
specification
through
the
the
decentralized
identity
foundation,
so
other
examples,
including
sovereign
Varys,
one
you
poor,
stacked
Fabian
from
the
etherium
core
team,
is
actually
created.
Erc
725,
there's
I,
P,
ID
and
there's
a
couple
of
other
who
are
coming
along.
A
And
also
we're
working
on
something
called
verifiable
claims.
Veil
file
claims
are
basically
a
packets,
they
actually
of
signed
code
from
the
elliptic
curves
of
key
signatures.
That
basically
has
a
claim.
So
in
this
case
the
sort
of
hello
world
in
healthcare
is
for
EHRs
is
vaccination
registries,
so
I
built
a
vaccination
registry
using
D,
IDs
and
verifiable
claims,
and
here
is
a
proof
of
vaccination.
A
Credential
who's
issued
by
you
know,
signed
by
a
particular
key,
and
in
this
case
the
vaccination
code
is
one
two
three
that's
what
this
the
CDC's
code
for
vaccination
for
flu
shot
and
I'm
also
building
out
like
proofs.
So
if
you
want
a
timestamp
and
anchor
it
into
a
blockchain,
they
actually
can
go
to
a
smart
contract
and
actually
look
up
that
this
indeed,
was
actually
signed
and
actually
placed
into
as
an
anchor.
So
the
big
Nick
steps
are
finishing
this
work
and
then
creating
service
endpoints.
A
So
we
talked
a
little
bit
about
did
off,
and
so
this
is
separate,
then
resolving
the
D
ID
to
a
document
and
in
this
case
IP
the
LD.
This
is
actually
the
service
endpoint.
So
if
I
want
to
communicate
with
au
port
or
other
D
ID
specification,
I
need
to
have
a
service
in
point
to
actually
do
do.
Diffie-Hellman
key
exchange
I
need
to
have
some
resource
I'm
using
ideally
Lib
p2p.
So
this
is
something
I
haven't
built
out
yet
and
I
think
actually
needs
just
more.
A
Some
more
work,
I
think
what
a
grip
would
be
a
great
thing.
The
Segway
is
to
figure
out
the
signing
of
the
the
did,
the
destructor
of
IP
LD
and
maybe
Hector.
We
talked
a
little
bit
about
this
yesterday.
Was
that
you
know
what
do
we
sign?
Do
you
actually
sign
the
byte
code?
Do
you
actually
sign
the
JSON?
A
So
actually
we
make
sure
we
have
a
deterministic
way
of
solving
it,
so
I'll
take
that
and
I'll
take
questions
and
I
really
would
like
feedback
to-
and
this
is
this
totally
off
course-
I
hacked
this
together.
Just
because
I
have
fret
of
frustration
that
maybe
this
isn't
the
best
approach.
Southla
some
feedback.
A
Crazy
idea,
I
I,
think
it's
just
elegantly
simple
solution
to
to
this
and
truly
self
sovereign,
because
this
is
my
issue.
Is
that
like
Microsoft,
Varys
or
or
sovereign?
It's
you
still
report
rustling,
some
third
party
or
some
intermediary
I,
really
have
this
vision
that
I
want
to
go
back
to
the
Tim
berners-lee
model
which
is
I
was
noting.
Is
my
desk
and
I'm
just
as
valid
of
a
note
on
the
internet
or
in
this
case
identity
as
anyone
else.
A
The
way
that
works
right
now,
the
universal
resolver
is,
it
basically
hits
the
the
gateway.
So
actually,
that's
just
one
protocol
HTTP
that
actually
it
works
out.
There
was
just
one
line
of
code
for
Marcus
to
implement
and
the
resolver,
so
people
don't
need
to
be
running
a
whole
like
EFS
node,
basically,
the
UD
no
way
of
publishing
it
and
that's
what
the
how
to
wrap
the
code
in
a
way
that
actually
it
could
be
migrated
towards
older
ways
of
doing
that.
So.