►
From YouTube: IPFS DDC WG - Identity Profile
A
Are
you
recording,
yeah,
recording
hello,
everyone
I'm
glad
to
be
here
with
everyone
on
on
this
discussion?
So
first
off,
if
you
haven't
filled
your
name,
please
do
it
in
the
in
the
notes
and
also
I
need
the
volunteer
to
take
notes.
If
possible,
do
does
anyone
think
wanna
take
the
lead
on
the
notes.
I
can
take
note.
Thank
you
Jim,
alright,
so,
regarding
these
discussion
by
the
way,
the
title
is
wrong
by
the
way
I
will
fix
it.
A
So
today
we're
gonna
discuss
identity
profile.
So
let
me
try
to
explain
why
this
is
important.
So
if
you're
the,
if
you
agree
the
the
RNC
the
identity
profile,
contains
your
personal
details
as
well
as
your
social
groups
and
in
the
future,
it
might
contain
other
things
right,
but
for
now
it's
just
your
personal
details
and
your
social
truths.
So
essentially
those
two
things
are
created
by
you
and
signed
by
you
and
we
don't
need
any
third
party
in
order
to
create
those
those
details
in
those
roots.
A
So
the
first
topic
of
discussion
is
is
about
this
and
I
have
three
different
approaches
to
these
problems.
There
are
there:
are
they
aren't
exclusive,
so
they
can
be
implemented
at
the
same
time
or
be
present
as
an
option
for
the
end
user.
So
the
first
one
is
to
like
to
obey
the
principle
of
meaning
disclosure.
So
whenever
the
app
asks
details
about
a
user-
and
if
you
know
you
ports,
for
instance-
and
you
if
you
tried
it,
they
follow
this
principle.
So
specially
the
the
DA
asks
the
user
to
authenticate
and
the
user
says.
A
A
You
might
change
and
because
the
duck
only
saw
the
information
at
the
time
that
the
user
gave
optimisation
and
that
information
becomes
stale
or
when
time
passes,
and
these
leads
to
the
second
approach,
which
is
as
to
the
first
one
so
that
et
profile
is
best
when
I
dedicate
indicating,
alongside
a
token
and
buy
a
token,
it
can
be,
can
be
a
public/private
key.
It
can
be
anything
really,
and
so
the
user
gives
a
token
that
can
be
used
to
retrieve
the
same
information
whenever
necessary.
A
All
right
does
it
make
sense
so
far,
and
then
we
have
the
third
option,
and
the
third
option
is
is
really
not
is
a
combination
of
everything,
because
you
can
have
the
two
approaches:
they
are
not
non-exclusive,
so
the
third
option
is
to
have
a
public
profile.
So
essentially
imagine
whenever
you
create
your
identity,
you
put
your
name
and
your
photo
or
avatar
whatever,
and
you
might
say
all
right.
This
information
is
part
of
my
public
profile.
This
is
public.
A
A
B
Maybe
we
need
some
use
cases
to
really
sort
of
example,
use
cases
to
say
where
these
are
needed,
because
I
think
in
in
some
cases
like
with
it,
like
a
really
true
decentralized,
app,
like
I'm
thinking
like
say,
like
a
wiki
or
something
when
I'm
sharing
my
identity,
I'm,
sharing
it
with
an
app
which
is
running
on
my
computer,
that
I
completely
control
in
the
app
itself
is
not
is
actually
trustworthy.
It's
just
what
does
the
app
do
with
information
I'm
sharing
with
it
when
it
builds
so
like
if
I'm
do
if
I?
B
If
my
app
is
a
shopping
list
for
myself,
it
probably
doesn't
really
need
my
identity
like
it
might.
I
might
log
into
it.
So
I
can
synchronize
all
my
devices
right
but
like
it
doesn't
need
to
know
my
name
it
just
I.
Just
just
me,
it
probably
needs
only
into
in
the
Chicago
processes
yeah,
but
for
like
a
chat
app,
you
know
or
a
clone.
B
A
Yeah
I
think
we
have
three
different
use
cases
I
mean
we
have
more,
but
I
think
we
have
three
different
use
cases
that
most
are
similar
to
these,
so
we
have
one
that
that
is
completely
personal,
there's,
no
public
information
whatsoever.
It's
just
me
using
that,
and
these
guys
here
is,
for
instance,
you
are
using,
as
you
said,
ecommerce
website
and
you
want
to
authenticate
it
in
order
to
you
know,
have
a
cart
and
add
products,
and,
and
once
you're
done
you
do
the
second
process
and
doing
it
the
process.
A
You
need
to
have
more
information
about
you,
let's
see
this
case,
but
there's
no
public
information
whatsoever
in
those
in
that
scenario.
So
this
is
one
scenario.
The
second
one
is
something
similar
to
zoom
or
Google
Google
Docs,
for
instance,
where
there's
people
collaborating
documents,
but
the
document
is
like
privates
in
the
sense
that
only
the
collaborators
reading
the
documents
know
each
other
and
I
mean
you,
don't
really
need
to
deal
with
a
date.
A
Soft
identity
profile,
at
least
in
my
perspective,
and
then
we
have
the
end
of
the
line
scenario,
which
is
a
completely
public
application
such
as
this
classified,
for
instance.
So
it
specifies
is
that
application
that
you
have
comments,
and
it's
very
similar
to
Facebook
comments
and
or
whatnot,
and
essentially
everything
that
is
that
you
put
there
is
public,
there's
no
encryption
and
everyone,
even
guests,
guest
users
can
see
what
you
watch.
A
You
comment
on
coming
to
comment
application,
and-
and
this
is
where,
like
the
issue
comes
along,
because
if
the
user
asks
like
authenticates
to
the
to
the
duck
and
provides
information
such
as
its
name
and
it's
also
post
and
so
on,
how
can
the
duck
a
deal
with
the
plates
of
those
information?
If,
if
the
heart
that
up
once,
because
the
documents
might
want
to
be
stagnant
in
terms
of
the
name
and
avatar?
That
appears
in
the
comment?
But,
for
instance
Twitter?
A
So
that's
why
the
public
profile,
or
at
least
the
second
solution
of
having
a
real
token
that
can
be
used
to
fetch
the
data
formation
and
the
people
could
have
workable
token,
basically
means
that
the
user
might
revoke
that
up
and
once
see
if
he
books
it
up.
The
doc
can
no
longer
fetch
the
up
to
date.
Information.
C
You
port
has
a
good,
is
a
good
example
of
self
sovereign
identity
where
it
asks
you
like
Oh
wealth
capabilities
or
authorization
yeah.
He
asks
you
what
they
want
to
share
certain
parts
of
you
of
your
profile
with
with
do
that,
and
with
that
we
mean
particularly,
we
mean
other
users
right
where
there
is
no
central
authority
right
now,
so
I
think
it's
a
good,
a
good
principle
that
that
user
has
to
give
authorization
for
to
share
certain
parts
of
their
credentials
or
certain
credentials.
Sorry
I
think
regarding
the
this
profile
problem.
C
I
think
like
I've,
come
up
with
like
three
different
vectors
that
we
could
analyze
separately.
So
first
is
privacy,
so
whether
the
profile
is
going
to
be
is
going
to
be.
How
much
is
it
so?
Is
it
going
to
be
private
between
peers,
it's
going
to
be
public.
This
is
going
not
to
be
disclosed
at
all.
Is
it
going
to
be
just
shared
with
with
the
group
and
again
I
think
this
falls
into
a
specific
criteria
right
so,
for
instance,
in
in
social
app,
you
may
want
to
be
public
the
product.
C
The
profile
may
be
public,
so
publicly
fetched,
so
you
may
have
to
be
careful
with
what
you
just
close
and
you
know
profile,
and
you
have
to
give
where,
in
the
interface
of
that
you're,
disclosing
some
information
for
the
that
that
is
not
encrypted
in
any
way
the
public
can
can
access,
or
that
is
grouped
private.
You
are
in
a
chat,
app.
A
group
chat
at
like
what's
up
that
could
be
the
case
that
you're
you're
exposing
your
profile
to
this
to
this
group.
C
So
it's
going
to
be
group
private
sometime
to
be
public
to
everyone,
but
whatever
you
disclose
is
going
to
be
visible
to
this
group
of
people
and
the
the
third
mode
is
p2p
private.
So
it's
this
is
this.
This
profile
is
going
on
to
only
to
be
visible
to
this
other
peer,
whoever
that
that
is
that
that
will
be
the
throw
three
modes
of
privacy
of
the
profile.
C
The
other
aspect
of
audited
profile,
the
second,
would
be
synchronization
of
the
profile
right,
so
whether
you
want
to
synchronize
the
profile
with
other
being
other
devices
or
even
other
peers,
so
peers
may
or
push
your
profile
or
updates
on
your
profile,
and
you
want
may
may
want
to
give
them
that
that
capability
of
getting
the
latest
information
on
your
profile
so,
for
instance,
changes
on
email
address
or
changes
on
your
profile.
Taken
from
your
your
your
physical
address,
those
those
changes
will
fall
into
this.
C
This
problem,
category
of
synchronization
of
the
other
profile,
the
third
one
I
think,
would
be
discovering
or
indexing
well
I
mean
I,
also
discovery
and
I.
Think
you
have
like
different
screws,
like
you
have
the
traditional
social
network,
public
profile,
global
index
aspect,
where
everyone
has
a
public
profile
that
is
indexable.
C
You
can
search
like
you,
can
build
your
graph
by
searching
in
this
index
or
try
to
build
a
graph
by
searching
in
this
index,
which
is
a
huge
index
of
public
huge
index.
Somehow
it
this
happens
or
the
scuttlebutt
way
the
fusion
one
way
where
you
you
are
introduced
to
somewhere
else,
and
you
have
to
ask
for
permission
to
to
be
able
to
even
see
who
the
other
person
is
so
there's
there's
a
mutual
mutual
authentication,
that's
happening,
and
then
there
is
so
and
inside
it's
not
a
public
profile.
There
is
no
global
index.
A
Let
me
just
say
one
thing
about
the
the
you
force
what
what
apart
does
is
not
really
a
lot
because
a
lot
of
kids.
You
are
token
that
you
can
use
to
to
fetch
the
information
they
are
more
similar
to
the
first
approach,
where
you
disclose
one
time
and
that
information
is
tale
become
style.
You
can't
really
fetch
the
to
date.
Information
without
requesting
the
user
again
to
authenticate
talk
about
right.
C
A
Yeah
that
approach
is
is
like
is
common
to
the
first
ones
and
even
the
third
one
one
when
the
application
requests
on
some
few.
That
is
not
part
of
your
public
profile
and
imagine
the
out
education
screen
might
contain
that
information
as
well,
and
you
might
want
or
not
increases
into
this
one
thing
degree.
Five
or
initial
surveys
have
these
bruising
prison
presentations.
A
I
think
that's
the
only
thing
which
is
basically,
whenever
you
want
to
present
your
credentials
and
you
can
present
a
set
of
credentials
and
also
you
might
want
to
say,
I,
don't
use
these
fields
or
those
credentials
publicly
like
this.
You
should
be
treating
these
carefully
and
privately.
Of
course,
this
is
just
recycling
like
saying
be
careful,
but
you
know
in
the
spec
they
make
warnings
about
hey,
even
if
you
say
to
be
careful,
the
doc
might
make
their
own
information
public
and
disseminating
the
internet,
and
so
on,
like.
C
A
Should
make
sensing-
and
it's
nice
in
if
you
want
to
take,
take
that
feature
of
the
credentials
spec
into
our
one
system,
because
we
weren't
going
to
use
the
five
digits
yeah
so
yeah?
Basically,
there
are,
as
you
said,
a
few
use
cases
and
particles
that
we
need
to
explore
I'm
I'm,
more
leaning
more
in
to
be
simplistic
as
the
first
approach.
A
I
know
that
it
does
some
problems,
but
at
least
we
will
have
something
working
which
is
the
you
know,
the
more
private
one,
the
more
like
principle
of
meaning
disposal,
one
where
you
disclose
one
time
only
and
whenever
that
app
needs
receives
up
to
the
information
is
when
the
user
authenticates
again,
we
should
know
as
its
problem,
but
at
least
we
have
something
in
it
and
I
think
we'll
need
these
as
the
baseline
of
authentication
and
and
related
one.
We
might.
C
Just
one
one
question:
there's
something
that
is
not
very
clear
to
me
at
least
is
so
there
is
disclosure
like
you
can
provide
a
verifiable
credential
to
your
application.
So
your
dad
has
your
verify,
look
at
the
credential
now,
which
is
something
that
it
holds
in.
Oh
it's
a
sum
in
plain
text
that
within
memory
may
be
stored
encrypted,
but
but
it's
it's
health
so
with
then
what
it
does
when
other
peers
come
in
and
how
it
uses.
D
A
A
This
document
request
access
and
once
you
hit
the
request
access,
you
are
basically
encrypting
your
privates
credentials,
your
credential
that
want
to
disclose
about
yourself
at
your
name
and
your
supports
to
some
key
like
a
shared
key,
as
you
said,
for
instance,
or
even
the
owner
of
the
document,
if
only
donor
might
accept
a
new
new
people,
it
will
be
better
to
go
to
that
owner.
So
yeah,
it
really
depends
on
the
use
case
of
the
doubt.
As
you
said,
it's.
C
A
And
let
me
just
introduce
some
things
which
is
kind
of
related
to
this
and
which
kind
of
goes
into
the
second
topic,
but
is
somewhat
related
because
we
put
like
a
I
think
identity
profiles
that
can
be
consulted
at
any
time
and
replicated
among
brothers
and
I
like
like,
say
that
I
have
bid
rose
public
profile
and
and
whenever
Pedro
changes
it.
I
might
also
want
to
take
my
my
copy
of
Pedro's
credentials.
A
Think
you
more
possible
to
Microsoft
employees
that
made
the
proposal
and
it's
going
forward
and
I
think
they
are
willing
with
aspect
and
also
reference
implementation
of
outfits,
but
especially
imagine
that
any
identity
might
have
an
identity
have
hosted
in
its
home
or
even
in
in
some
cloud
provider,
and
what
it
does
is
that
it
only
facilitates
storage
and
and
facilitates
relaying
of
messages.
All
right
and
everything
is
encrypted
like
even
if
it's
Austin
on
another
or
not,
everything
is
encrypted
and
only
the
identity
can
unlock
what's
what's
in
there.
So
what
this
means
for?
D
A
Instance,
you
might
you
might
have,
and
by
the
way,
this
also
hands
computation.
So
it's
not
only
storage
all
right.
It
has
an
API
that
you
can
use
to
interact
with
the
data,
so
imagine,
for
instance,
the
second
scenario
where
I
say
that
identity
profile
is
best
when
authenticated.
Alongside
that
revocable
token.
This
is
actually
a
similar
feature
of
identity
where
adapt
is
given
authorization
to
access
the
identity,
public
information,
sorry
I
native
information,
private
information-
if
it
presents
a
valid
token
and
the
user
identity
might
revoke
that
token
and
whenever
they
they
want.
A
They're,
they're,
worthless,
fermentation
will
be
HTTP,
but
it's
not
tired
to
HTTP.
You
can
use
what
everyone
so
that's,
why
I'm
more
inclined
to
wait
and
see
what
they
come
up
with
and
if
it's
something
that
we
might
adopt
later
on
and
it's
better
instead
of
doing
our
own
solution
and
perhaps
it'll
be
incomplete
and
and
it
will
be
more
complex
and
I'm,
more
leaning
into
intermittent
just
a
basic
similar
to
your
port
approach,
where
you
just
disclose
your
your
stuff
and
there's
no
synchronization
in
terms
of
public
information
and
data.
A
A
Nevertheless,
we
still
need
to
approach
replication
because
we
have
several
devices
in
our
in
our
possession.
So
you
have
your
laptop
your
girl,
your
desktop
your
phone
and
so
on.
So
you
might
have
different
IDMS
VM
instances
running
on
those
devices,
so
you
need
a
way.
You
still
need
a
way.
It
is
privately
and
encrypted
to
share
or
to
replicate
all
those
credentials
amongst
your
devices.
So
let's
say
that
I
just
bought
a
new
computer
now
install
IDM
and
import.
A
My
identity
that
I
have
in
a
mobile
phone
I
should
be
seeing
my
name
in
my
avatar
and
my
social
groups
in
the
new
device
as
well
completely
synchronized
among
devices.
So
this
is
the
second
discussion
that
that
it's
there.
So
basically,
how
can
we
do
that?
Because
there's
no
spec
for
this?
Yes,
each
project
implements
these
kind
of
things
in
their
in
their
own
functions.
A
You
port
I,
know
that
your
port
uses
IP
FS
to
store
your
profile
and
so
on,
but
it's
not
clear
how
they
replicate
things
I
think
they
have
something
in
the
smart
contract
or
something
like
that
to
retrieve
the
C
IDs
or
something
like
that
of
your
profile.
Let's
the
way
they
synchronize
and
probably
they
listen
to
events
on
the
on
the
smartphone
job.
To
know
that
the
information
was
a
tight
budget,
but
it's
not
cool
because
you
know
that
that
part
is
not
public
really
they
implement
their
their
own
solution
blocks.
Tech
is
similar.
A
C
A
Yeah
I
heard
about
anything
two
or
three
months
before
so
I
think
nine
months
already
passed
and
I
didn't
see
any
real
evolution
on
the
project.
That's
what's
why
I'm
I'm
keeping
a
certain
distance
to
see
what
what
they
come
up
with
says
of
going
full
force
in
terms
of
adopting
identity
herbs,
but
I
think
they
resolve
the
replication
as
well,
because
they
have
those
information,
storage
yeah.
So
whenever
any
device
connects
to
that
entity,
it
has
permission
to
access
that
is
to
have
storage,
so
it
can
retrieve
identity
details.
A
B
Seems
to
me
like
they're,
like
the
actual
identity,
ignoring
like
everything
that
is
wrapped
in
is
basically
a
static
document
like
like
okay.
It
can
essentially
be
a
file,
an
IP
FS,
but
then
it
you
need.
The
ability
to
update
it
so
I,
pns,
perhaps
or
you
know
peer
base-
has
quick
quicker
application.
B
B
A
B
A
Have
the
concept
of
meta
information
around
around
identity?
Just
just
has
the
ideas
and
the
cryptographic
material
to
interact
with
that
so
from
the
outside
from
the
Dubs
all
inside?
What
did
that
will
receive
from
the
the
user
wants
to
user
authenticates?
Imagine
that
is
something
like
schema.org
person,
json
documents,
alongside
some
as
array
or
set
of
verifiable
credentials.
Saying
hey
these
are
your
social
proof
sand
is
your
social
code
center
got
Twitter,
Facebook
and
so
on?
A
This
is
my
credited
profile,
and
this
is
not
formalized
yet
in
terms
of
the
the
fully
schema
that
it
would
be,
but
if
imagine,
that
will
be
a
pack
of
schema
a
person
entity
and
a
set
of
credentials
yeah,
and
what
are
what
we
are
discussing
here
is
how
can
the
different
devices
that
connect
to
that
user
IDM
with
the
same
identity?
How
can
we
share
these
are
able
to
profile
among
devices
that
are
that
belong
to
the
identity
and,
as
you
as
you
said,
we
can
use
I,
penis
and
infest.
A
C
C
This
this
kind
of
multiplies
by
your
your
each
one
of
your
identities,
but
let's
just
think
of
one
identity.
So
it's
a
profile
and
a
set
of
verifiable
credentials,
at
least
right,
but
you
could
tie
this
up
into
a
document
and
you
never
have
a
CID
that
you
can
use
a
penis
and
a
penis
doesn't
need
to
be
slow,
as
you
can
use
a
penis
for
pops
up.
So
it
could
be
something
that
lets
you
store
on
a
penis
and
which
could
be
replicated
into
and
identity
hub
for
persistence.
C
C
Approach
right
that
I
can
can
think
of
that
uses
his
IP
at
first
and
all
the
defense
infrastructure.
Then
you
could
use
like
a
very
simple
identity
hub
would
be
implementation,
just
use
a
pinning
cluster
or
something
like
that
to
pin
the
soup
in
your
your
current
schedule.
For
for
for
this,
so
you'd
have
like
a
penis
and
then
and
then
pinned
that's
a.
A
Simple
approach
right,
but
it
has
similar
problems
to
the
ones
that
we
ID.
If
you
remember
mm-hmm,
so
if
you
have
any
device-
and
you
have
a
concurrent
scenario-
basically,
you
overwrite
each
other
or
have
a
higher
chance
of
overwriting
each
other.
And
this
is
the
same
thing.
It
has
a
much
better
problem
and
I'm,
not
saying
that
we
don't
might
might
not
want
to
use
ffs
probably
want
to
use
at
the
fest
start
actual
data,
but
we
must
solve
the
concurrency
on
top
I
think
we
must
one.
C
It
it's
better
to
have
to
be
encrypted,
so
I,
don't
see
why
you
don't
you
don't
itself
saving
them
as
text
documents?
Why
don't
you
encode
them
in
in
charity
and
then
you
can
use
the
same
device
that
we
came
up
with
for
their
IP
ID,
which
is
like
have
the
current,
for
instance,
let's
basic
about
the
profile
right,
you
have
the
profile
document
and
then
you
have
a
new
update
from
the
remotes,
but
those
could
be
concurrent
right.
So
you
do
it.
C
A
To
have
risen
tab
this
only
because
it's
very
similar
to
using
another
base,
so
you
have
to
have
connection
so
identity,
oh
and
the
changes
are
solved
by
using
atomic
e.
Like
imagine
like
the
user,
of
course,
there
are
also,
it
might
also
have
conflict
if
the
operations
are
not
going
over
and
it
might
have
some
right,
yeah
yeah.
A
Solve
that
one
way,
because
we
use
the
same
solution
on
this
one
as
well:
okay,
because
it's
the
same
problem
accessing
peppiness,
multi,
writer
problem,
all
right,
there's
also
another
project
that
I've
mentioned
here.
We
see
which
is
three
box
and
I.
Oh
it's
from
the
guys,
I
think
it
was
some
kind
of
fork
from
your
port
I,
don't
really
know
what
happened
there,
but
essentially
it's
the
concept
of
having
social
profiles.
A
A
Has
the
IP
ID
one
so
use
some
sort
of
CRT
and
we
can
compose
the
final
documents
and
based
on
the
salty,
merging
and
store
that
as
well
on
on
ad
FS
for
consistency
by
the
way
we
need
some,
some
sort
of
meaning.
For
this
thing
at
least
a
public
infrastructure,
a
small
public
infrastructure
went
we
until
we
solve
that
in
a
more
decentralized
way,
I
guess
so
having
some
sort
of
final
coin
or
something
that's
intuitive
here,
so
that
we
could
leverage
leverage
and
miners
to
store
the
that
information
for
us
yeah.
A
C
A
E
D
A
D
So
one
thing
I
was
thinking
is
I,
wonder
if
we
have
to
worry
too
much
about
the
mouse.
You
write
a
scenario
right
now,
because
it
might
just
be
a
UI
thing
where
you
know
you
tell
the
user
whether
the
update
has
been
saved,
and
until
that
update
is
saved.
You
know
you
just
kind
of
educate
them
to
know
that
whenever
they
save
it,
it's
going
to
overwrite
what
they've
done
somewhere
else.
D
A
You're
right,
let
me
just
ask
you
something:
if
is
it
possible
and
by
you
I
mean
everyone
aware
of
FS,
my
penis
is
it
possible
to
know
if
I
asked
for
the
resolution
of
the
Nepean
s
entry
like
give
me
these
a
penis
entry?
Is
it
possible
that
the
response
is
like
okay,
there's
no
entry
because
I'm
in
a
network
where
I
have
like
five
to
ten
years
like
it
sounds
very
local
and
there's
that,
but
is
there's
actually
an
entry
on
the
public
IP
FS?
D
C
A
P&S
is
the
thing
that
more
time
you
you
wait
for
something
or
more
time
you
listen
more
less
probability.
There
is
of
a
current
update
and
but
you're
you're,
never
absolutely
sure
that
there
is
no
concurrent
concurrent
doublet.
It's
a
bit
like
like
like
like
steady
piece,
so
you
could
do
I.
Think.
A
That
the
ID
multi
write
a
scenario
while
it's
more,
not
so
frequent,
but
if
it
if
this
happened,
it's
very
bad
for
the
using
experience,
because
that
device
that
was
nice
and
was
usable
because
it
was
part
of
the
daily
of
any
documents
the
next
day.
It
isn't,
and
you
must
saw
you
might
you
must
feeling
the
Pataki
again
and
so
on,
while
the
second
list,
what
we
discussed
here
like
having
your
name
and
so
what's
be
overridden
he's
not
so
bad
as
you
might
change
it.
A
B
I
want
to
talk
about
like
low-hanging
fruit,
which
is
like.
What's
the
easiest
thing
to
do,
that
would
sort
of
unlock
the
maximum
number
of
apps
and
the
problem
is
like
you
know,
like
identity.
Is
infinitely
like
deep,
it's
a
frogs,
a
bunch
of
yeah,
it's
a
fractal,
you
know
like.
Are
we
gonna,
like
you
know,
improve
Facebook
or
whatever,
like
I?
Don't
think
that's
where
we
should
start
like
I?
Think
if
you
look
at
some
like
peer
base,
what
does
peer
base
need
like
right?
Now?
B
Obviously,
we
want
to
figure
that
out,
but
you
know
like
you
would
just
unlock
if
you
could
just
sort
of
click
a
button,
your
name
and
your
avatars
in
there.
You
probably
don't
ever
need
to
update
your
name,
but
you
probably
want
update
your
avatar
quite
frequent
more
frequently
so
like
I,
think
if
we
can
think
about
like
that
use
case
and
then
think
about
like
how
do
you
layer
on
more
and
more
use
cases
on
to
it
so,
like
I,
think
like
that,
that
use
case
is
actually
fairly
easy.
B
First
implement
with
ipfs
like,
like
you
have
a
high
P,
NS
document.
You
know
it's
just
your
image
as
a
JPEG,
your
name
is
just
a
little
piece
of
text.
You
can
update
it.
You
probably
don't
update
it
very
odd
car.
Like
that's
your
profile,
you
know
now
it's
like
how
does
that
arrive
there
and
how
does
that
get
updated,
so
sort.
D
B
C
A
C
F
B
And
then
I
think
like
for,
like
in
thinking
like
internally
for
a
PR
staff
like
if
you
could,
the
first
step
would
be
like
a
verifiable
claim.
Like
are
you
what's
your
github?
Are
you
really
that
github
user?
Because
then
you
could
use
that
for
ACL
type
things
if
you
want
to
have
a
private
conversation
or.
D
B
A
Is
correct
if
you
should
just
put
your
name
on
it
will
be
two
credentials
basically
and
if
we
solve
that
in
terms
of
visually
visual
experience
in
actual
actual
schema
it
we
might
later
on,
add
and
other
fields
and
I
think
that
is
essential
for
us
to
have
something
to
trust
on,
because
verifiable
credentials
can
be
verified
right,
it
can
be
check.
The
sign
shows
and
you
can
check
if
the
probability
that
matched
the
sign
sure
is
part
of
your
Eid
covenant.
That's
that's
the
real
benefit
of
having
the
D
ID
and
the
IBM's
is.
C
A
A
And
then,
then
you
have
like
the
social
credentials
which
are
more
complete
because
you
can
actually
see
if
what
you
said
about
yourself
and
I
mean
the
idea
that
you
said
you
were,
and
your
name
is
actually
associated
with
the
profile
that
you
already
follow,
and
you
know
that
the
Pedro
is
a
GT
ITA
in
in
in
Twitter.
That's
another
level
of
trust
and
it's
okay.
You.
D
A
A
Someone
will
like
simplify
that
for
the
top
side,
but
for
the
device
side
I
think
we
should
use
the
same
solution
for
for
a
PID,
because
it's
a
reusable
solution.
If
you
can
make
a
package
for
that,
it's
pretty
insightful
to
music,
yes
and
I
will
go
for
FedEx
personally
and
and
later
on.
Of
course,
we
can
explore
the
identity
ads
and.
F
I'm,
just
you
know,
I'm
just
typing
in
a
couple
of
things
like
questions
and
thoughts
as
well
around,
because
we
were
talking
about
syncing
and
I.
Think
there's
some
real
fundamental
issues
around.
You
know
what
what
is
the
identity
key
and
is
there
a
master
key
above
it
I
think
that
was
discussed
online
and
the
sort
of
the
the
big
discussion
that
was
on
I
forget
which
repo
on
github
so
just
I'm.
Thinking
about
that
stuff,
too,
you
know
like,
for
instance,
I
was
going
to
type.
F
How
closely
is
the
you
know
the
IP
FS
ID
for
your
node?
You
know
just
how
closely
is
that
tied
to
you
know
your
identity,
you
know:
I'm
assuming
you're,
gonna,
you're
gonna
have
multiple
nodes
and
what
controls
those
keys
and
the
whole
idea
of
someone
stealing
your
key
and/or
device
and
getting
a
hold
of
a
private
key.
F
A
So
that
is
it's
tied
to
the
D,
ID
leaseback,
and
so
essentially,
a
deity
is
unique
identifier
that
that
resolves
to
add
in
the
ID
documents
and
that
the
ID
document
has
multiple
Lucas
and
they
are
layered
layered
kiss
and
by
layered
I
mean
some
keys
might
have
higher
permissions
than
others.
It
really
depends
on
the
D
IDs,
really
method
that
you
shoes
for
your
identity,
for
instance
the
the
one
based
on
our
IRC
seven
to
five.
A
If
I'm
not
mistaken,
has
this
concept
of
management,
keys
and
authentication
keys
and
so
on,
especially
a
management
key
has
higher
access
to
the
document
in
terms
of
editing
it.
You
can
basically
do
anything
and
while
an
authentication
one
just
is
there?
Basically,
you
can't
really
change
the
ID
token
you
just
use
for
authentication.
Imagine
like
you
have
a
computer
network
that
you
want
to
use
to
authenticate.
A
So
you
put
a
litigation
key
there,
but
you
want
don't
want
to
have
the
the
management
key
in
that
computer,
because
the
computer
is
like
shared
between
your
friends
or
your
colleagues,
that's
work,
and
so
on
an
IP
ID,
which
is
the
first
year
method
that
will
embrace
in
these
IDM
projects.
By
default.
It
doesn't
have
player
piece.
It
just
has
a
key
that
controls
your
because
it's
an
NS
record.
So
it's
just
a
key
that
controls
all
the
ID
documents.
A
It
will
be
asked
for,
like
for
a
threshold
of
of
the
paper,
clip
keys
words
for
you
to
generate
the
private
key
again
to
change
the
data
point
and
again
it
will
be
deleted
after
that
operation,
but
there's
another
solution
that
we
will
not
use
you,
which
is
a
layered
key
for
a
penis
for
a
PID
spec,
but
that
will
be
more
complex
for
for
has
implemented
his
face.
But
that
will
do
it
for
now.
In
terms
of
that,
okay.
F
A
I
actually
I
think
it's
too
late,
but
I
I
can
put
in
the
notes
or
perhaps
leave
a
link
in
the
notes
so
that
you
can
see
in
terms
of
the
user
experience
and
what
the
IDT
profile
really
is.
It's
very
simple,
exactly
an
avatar
and
a
name,
and
we
have
like
two
or
three
fields
more,
but
is
very
simple
in
terms
of
the
first
approach.
We
don't
want
to
explain
much
time
in
thinking
about
all
the
fields
that
the
schema
person
has
and
so
on.
A
So
it
will
be
very
simple
for
us
to
implement
a
verifiable
credential
module.
That's
you
know
you
can
create
a
credential
based
on
some
data
and
that
data
is
just
those
films
that
we
had
there
and
that's
part
of
your
identity,
packet
or
profile,
and
that's
basically
and
after
you
you
will
have
the
social
3500
credential,
which
are
normal,
which
other
potentials
but
the
proof
they
have.
The
proof
of
your
identity.
A
Sorry,
your
social
profile
on
Twitter
and
Facebook,
but
that's
something
that
we
do
after
we
sort
out
the
basic
details,
like
the
your
name
and
your
avatar
once
we
saw
that
will
also
solve
next
and
the
social
parts
linking
your
like
posting
it
something
on
Twitter
or
enlist
or
whatnot,
and
and
generate
a
credential.
Also
for
that
there
is
the
like.
We
first
have
to
solve
the
base,
and
then
you
should
have
experience
in
your
projects.
Ibm.
F
A
Basically,
what
you
did
in
your
in
your
project
is
a
verifiable,
a
set
of
equations
that
point
to
proofs
on
social
profiles
or
posts
or
whatnot,
and
those
are
part
of
your
identity
profile
and
and
the
coordination
itself.
The
data
structure
actual
hands
like
a
type
that
you
can
choose
whatever
it
goes
there.
It's
not.
There
are
recommended
types
which
we
can
invent
our
our
own,
like
IDM,
Twitter
proof,
or
something
like
that,
so
that
we
can
recognize
that
social
that
most
credentials
as
social
proofs
in
terms
of
the
user
experience
and
in
the
interface.
A
Alright,
so
I
think
we
passed
the
schedule
so
and
I
think
we
will
close
the
session
here
so
yeah
and
I.
Think
in
summary,
we'll
keep
it
simple:
go
to
the
go
towards
the
first
solution,
which
is
similar
to
you
port
in
terms
of
how
the
Dubs
received
the
the
profile
and
so
on
and
regarding
the
replication
among
devices
we'll
probably
go
into
the
same
solution
as
as
we
go
as
we
decided
to
die
PID
methods,
although
those
are
the
the
conclusions.