►
Description
Workshop featuring Kyle Den Hartog from Evernym and Stephen Curran from BC.gov on Agents, what they are, how they work, what they can do in both Hyperledger Indy and the wider decentralized identity world.
----
Hyperledger – Open Source Blockchain Technologies
Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use
Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory
Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter
Follow-us on Twitter @Hyperledger
Learn about Hyperledger Membership: https://www.hyperledger.org/about/join
#Hyperledger #HyperledgerGlobalForum2018 #Blockchain
A
A
But
if
you
guys
don't
have
docker
already
set
up
it's
fairly
easy
to
setup
on
Mac
and
Ubuntu,
but
for
people
who
are
running
Windows
I've
found
it
somewhat
difficult
to
get
it
set
up,
especially
Windows
7
I
have
gotten
it
running
on
Windows
10
fairly
easily,
but
I've
also
seen
people
who
struggle
with
it.
So
if
you
are
doing
that,
you
want
to
follow
along
I
would
suggest
using
play
with
docker
to
actually
do
this
stuff
and
a
that's
specifically.
A
A
A
A
So
that
is
the
link
to
get
access
to
the
Google
Docs,
which
then
will
allow
you
view
only
access
to
find
the
rest
of
the
links
for
this
demo.
The
link
for
Google
document
here,
though,
is
this
very
bottom
one
right
here,
right
above
questions,
which
is
the
self-paced
tutorial
instructions
that
is
going
to
include
all
the
links
that
you
will
need
so
I'm,
just
going
to
refer
back
to
this
document
from
here
on.
You
shouldn't
need
the
slides
for
anything
else
on
this.
A
A
A
A
A
All
right
so
we're
going
to
make
a
new
directory
called
demo
and
inside
of
it
we're
going
to
get
clone
this
education,
repo,
and
so
what
I'm
gonna
do
is
just
clone
this
down.
You
should
be
able
to
do
this,
your
sign-in
in
front
of
the
or
inside
of
the
play
with
docker
and
since
all
of
the
documentation
I
built
was
built
on
that,
but
it's
nearly
the
exact
same
you're
running
a
lot
of
the
same
commands.
A
A
A
Hyper
ledger
demo
wrong
place.
There
we
go
into
education
and
then
once
you're
in
here
we're
gonna
go
into
the
LFS
directory,
and
then
we
want
to
go
into
Annie
materials
and
inside
of
any
materials
we're
gonna
go
into
nodejs.
What
this
is
is
built
upon
the
nodejs
reference
implementation,
there's
also
a
Python
implementation.
A
Kuzma
here
actually
built
the
Python
implementation
pretty
much.
He
was
the
hyper
ledger.
Intern
and
I've
been
helping
him
out
with
that,
but
he
was
the
one
who
caught
it
at
all.
I
just
helped
him
out
with
a
few
questions
and
stuff,
and
so
largely
he
was
he
did
that
stuff
independently.
So
it
is
possible
to
do
this
stuff
yourself.
A
So
now
that
we're
in
no
js'
here
we're
going
to
actually
do
a
script,
so
this
script
has
already
been
built,
so
it's
called
manage
and
you
can
see
that
in
the
pink
there
and
we've
got
manage
build,
so
this
is
gonna,
be
our
first
command
here.
What
this
is
doing
is
it's
going
to
go
and
set
up
some
docker
images,
and
it
looks
like
I
already
have
some
of
these
already
running
here.
A
A
Is
it's
pulling
in
new
versions
of
Indy
SDK,
building
off
with
some
new
functionality
and
stuff
like
that
to
be
able
to
show
these
types
of
demos,
one
of
the
things
that
happens
typically,
when
you're
running
with
Indy
SDK
is
your
Indy
SDK,
maybe
building
certain
aspects
in
a
transaction
in
a
specific
format
that
isn't
compatible
with
the
ledger.
You
know:
there's
one
small
little
tweak.
That's
that's
broken
in
between
formats
when
we
have
breaking
changes,
that's
not
common,
but
it
has
happened
from
where
we
were
about
six
months
ago
to
where
we
are
today.
A
B
B
A
B
Actors
in
the
system,
so
it's
not
a
new
connection,
request
and
she's
gonna
do
that
using
what's
called
the
endpoint
div.
So
using
that
endpoint
views
you
can
send
a
connection
request.
It's
gonna
look
up,
favors
endpoint,
send
that
connection
request
and
then
basically
automatically
create
a
connection
and
we'll
see
that
so
now
you
see
I
have
this
connection
here.
I
don't
know
much
about
it.
I
have
related
these
relationship
yandy's
here
and
their
endpoint
D
ID.
B
A
B
It
and
so
that's
kind
of
easier
than
this-
try
not
to
give
it
a
name
version
and
a
list
of
attributes,
and
this
will
write
that
schema
to
the
ledger
as
favor
now
I
have
to
create
a
credential
definition
based
on
that
schema,
but
this
is
now
very
specific
to
favor.
Only
favor
can
use
this
credit
or
definition
based
off
of
this
transcript
I'll,
give
it
a
tag
here,
and
this
one
takes
just
a
bit.
A
Somewhat
slow
in
this
demo,
but
when
you
actually
do
this
in
real
as
real-life
instances
like
this
is
nature
fairly
fast.
It's
like
some
big
one
session
speed,
and
so
my
guess
is
there's
probably
running
on
lightning
machines
like
Raspberry,
Pi
or
something
like
that,
which
is
to
the
point
raspberry
PI's
can't
run
ages.
They
may
be
a
little
bit
slower,
but
it's
still
possible
to
that.
B
B
A
Sorry
to
interrupt
guys,
okay,
so
yeah.
What
you'll
see
right
here
in
this
video
is
down
at
the
bottom.
Oh
you
guys
can't
see
that
well
down
at
the
bottom
here
when
you're
running
these
things,
there's
an
actual
D
ID
and
the
user
has
to
then
go
use
that
D,
ID
and
copy
it
over
to
the
other
person
in,
for
example,
connect
up
me,
which
is
the
that
my
company
builds
for
this,
which
is
a
mobile
application.
We
use
QR
codes,
so
you
didn't
even
have
to
see
it.
A
A
In
many
ways
this
this
is
new
age
PGP,
with
some
new
cool
stuff
built
on
top,
but
it's
very
similar
to
it.
So
we
have
to
get
user
experience
right.
If
we
don't
get
user
experience
right,
it
doesn't
allow
for
any
of
this
stuff
to
occur,
and
then
we're
back
to
paper
for
the
next
10
to
15
years.
So
that's
kind
of
the
reason
why
I
wanted
to
bring
that
other
one.
If
I
want
to.
B
B
A
Proof
so
what
you
mentioned
there
is
right
now,
one
of
the
things
that's
not
possible
is
the
fort.
As
somebody
who's
received
a
scheme,
ID
I
can't
go,
get
the
actual
schema
or
the
credential
definition
itself
to
actually
go
pull
that
down
and
use
that
with
my
agent.
That's
something
that
still
needs
to
be
built
into
the
Indy
SDK,
which
is
why,
in
this
you're,
actually
copying
and
pasting
JSON
again,
that's
something
that
shouldn't
happen
in
reproduction
level
system.
It's
a
bad
user
experience.
E
B
We
really
like
to
eventually
have
what
we
keep
calling
a
proof
request
builder,
where
you
can
really
just
pick
attributes
and
then
it's
just
you
can
either
say
they
can
just
give
me
this
upgrade
it's
a
self
attested
attribute,
or
you
can
tie
that
particular
attribute
to
a
list
of
credits,
a
definition.
So
you
can
say
so.
A
The
goal
of
these
reference,
implementations
like
I,
said
or
earlier,
is
that
you
should
be
able
to
take
these
reference
implementations
and
actually
build
stuff
on
top
of
them,
and
so
the
thinking
behind
this
and
there's
the
sovereign
foundation
now
hosts
a
mobile
application,
which
is
a
reference
implementation.
That's
open
source,
that's
built
based
upon
connect
up
me,
but
they're
going
to
somewhat
diverge
over
time,
but
the
underlying
protocols
will
not
is
basically
that
they
want
to
see
certain
UI
characteristics
built
in
in
certain
architectures
and
stuff
like
that.
B
Will
I'll
accept
a
degree
attribute
from
any
of
these
universities
or
something
like
that
right
now,
we're
just
pasting
in
a
JSON
object,
but
eventually
we
would
like
to
build
a
little
proof.
Request
builder,
where
you
can
dynamically
created,
save
different
proof
requests,
but
if
I
go
ahead
and
send
that
to
Alice,
Alice
now
gets
a
new
message.
It's
a
proof
request
asking
for
her
degree
status
in
a
year
from
her
transcript
again
from
Acme
corporation
I.
B
Go
ahead
and
accept
that
now
Acme
under
relationships
with
Alice
has
a
new
proof
for
transcript
and
I
can
go
ahead
and
validate
that
proof
right
now
into
this
any
valid.
So
I
can
guarantee
now
that
she
has
a
degree
of
Bachelor
of
Bachelor,
of
Science
marketing
degrees,
graduated
in
2015
and
that's
our
demo.
A
A
The
the
agent
for
this
I
don't
know
how
you
do
it,
but
I
feel
like
if
you
finagled
with
it
enough,
you
could
probably
get
it
to
work
most
of
what
has
been
done
for
the
smartphone
application
so
far,
so
like
what
you
do,
there
is
you'd,
be
like
self
hosting
a
web
server
on
your
phone
so
that
you
can
then
personally
access
it
and
stuff
like
that.
So
certainly
not
a
good
user
experience.
A
We
do
have
ways
that
you
can
actually
build
Live
Indie
for
Android
and
for
iOS.
So
that's
probably
the
more
efficient
and
the
more
production
level
solution.
But
if
you
wanted
to
you,
could
my
recommendation,
though,
is
go,
build
off
of
the
sovereign
connector
app,
so
it
exists
in
the
sovereign
foundation,
repo
I
believe,
and
so
that
would
be
a
good
place
to
look
when
you're
in
hydrology
rnd.
Sometimes
you
will
find
stuff
in
sovereign
foundation
because
we
implement
stuff
specifically
for
sovereign
but
they're
compatible
at
a
technological
level.
So
that's
the
the
only
difference.
A
A
And
what
this
is
gonna
do.
Is
it's
going
to
start
up
all
of
these
nodes?
Similarly,
to
what
you
saw
in
that
demo
there,
so
that
I
can
now
access
them
within
my
web
server,
and
so
it's
getting
already
started
up
right
now
and
it's
also
spinning
up
a
local
pool
so
that
I
can
communicate
directly
from
my
agents
to
that
pool
for
credential
issuance,
and
so
that's
kind
of
the
idea
behind
this
is
that
you
can
do
these
demos
than
these
proof
of
concepts
on
a
completely
local
machine.
A
However,
in
production
use
cases,
what
we
recommend
is
that
obviously
I'm
biased
but
I'd
recommend
that
you
use
the
sovereign
foundation
Network,
because
that
comes
with
your
business
and
your
legal
aspects
with
it,
and
if
you
need
specific
things
around
that,
you
know
contact
the
sovereign
foundation
folks
and
they
can
help
you
with,
like
trust
frameworks
and
these
types
of
things.
The
main
advantage
for
this
is
it
offloads
all
of
the
node
responsibility
and
the
node
trust.
Were
the
aspects
choose
somebody
else,
so
you
guys
don't
have
to
worry
about
that.
A
However,
I
did
have
somebody
come
up
and
ask
me:
could
I
run
a
local
network
internally?
Privately?
Yes,
it's
completely
possible
to
run
a
local
network.
Inside
of
your.
You
know
your
company
and
host
all
the
nodes
yourself,
but
at
that
point
you
might
as
well
just
be
running
a
database.
It'll
be
faster,
you'd
have
to
build
the
database
yourself,
though
that's
the
main
difference,
so
the
the
only
difference
between
it
is.
We
have
what
we
call
a
Genesis
transaction
file.
A
That's
interesting!
Those
are
some
new
messages.
You
wait.
We
have
something
called
a
Genesis
transaction
file
that
can
point
at
different
networks
and
essentially,
what
that
is
is
just
a
JSON
file
that
or
it's
a
file
that
contains
JSON
that
you
load
in,
so
that
you
can
actually
go
connect
to
different
networks.
So
in
the
future
it
may
be
the
case
where
there's
multiple
networks
of
Andy
running
and
you
want
to
go
connect
between
multiple
of
them.
This
is
where
agent
agent
communication
be
built
into
the
networks
would
be
very
valuable.
A
But
let's
move
forward
with
this
demo
here,
let
me
figure
out
the
IP
addresses.
So
what
I'm
going
to
need
to
do
is
go
back
to
this
link
and
what
I'm
going
to
take
a
look
at.
Is
this
getting
started
guide
here
that
they
had
I
see
the
tabs
are
still
cut
off
a
little
bit.
So
let
me
pull
that
down
to
similar
size.
A
All
right
there
we
go.
No,
we
get
some
tab.
Views
and
I
can
expand
this
a
little
bit
so
that
it's
more
readable.
So
what
I'm
gonna
click
on
is
this
agent
demo
script?
This
is
giving
me
the
instructions
on
how
to
actually
go
through
the
demo
that
was
just
shown
in
there.
So
we're
now
gonna
do
this
live.
A
So
it
looks
like
the
the
first
thing
that
we're
gonna
do
is
giving
kind
of
an
explanation
of
what's
going
on
traditionally,
if
you're
running
this
through
play
with
docker
you'll,
actually
get
a
view
of
the
IP
addresses
of
where
things
are
hosted.
I'm
gonna
have
to
go,
find
mind
and
I'm
gonna.
Do
that
through
my
terminal.
It
typically
prints
them
out
here.
A
A
Yes,
so
there's
an
agent
I
guess:
I
didn't
play
with
docker
one
of
the
cool
features
to
it.
Is
it
when
it
spins
up
other
docker
images
inside
of
the
docker
image,
it
will
actually
expose
a
link
inside
of
the
user
interface
that
shows
you
this
stuff,
so
it
makes
it
very
simple
to
be
able
to
to
play
along
and
see
what's
going
on,
the
ports
that
are
exposed
in
play
with
docker
that
are
like
9,000
level
are
the
actual
nodes
nodes
operate
with
two
ports
running
two
public
ports?
A
You
hit
control,
C
and
it
will
board
out.
My
guess
is
because
some
of
these
things
are
not
running
we're
gonna,
try
running
it
without
sudo,
because
a
few
of
these
things
are
not
running
that
it
didn't
shut
down
properly,
cuz,
normally
it'll
close
down
all
the
doctrines
and
stuff
like
that.
So
I'm
gonna
see
if
there's
a
way
for
me
to
clean
up
this
stuff,
yeah,
so
you're
supposed
to
do
down.
A
E
A
You're
trying
to
rebuild
these
make
sure
everything
is
built
properly.
It
should
be
because
if
one
instance
of
an
agent
is
working,
all
the
other
instances
of
the
agent
are
working
as
well.
Does
the
exact
same
dr.
container
just
running
with
different
you
guys
on
top
so
now
that
we
got
that,
let's
give
manage
up
a
second
try,
I
see
the
nodes
are
starting
Alice
and
the
webserver
starting
thrift.
All
the
other
ones
started
as
well.
A
So
now,
what
it's
doing
is
its
propagating
the
ledger
so,
like
I,
said,
there's
a
Genesis
transaction
file
that
exists.
So
what
it's
doing
is
that
Genesis
transaction
file
is
literally
just
a
copy
of
static,
static
transactions
that
are
automatically
loaded
when
you
start
up
the
the
node
and
it
loads
that
into
the
database,
and
so
there's
some
stuff
designed
specifically
for
that
bootstrapping
new
case
use
case,
essentially
what's
happening
with
the
Genesis
transaction.
A
It
looks
like
I'm
getting
multiple,
yes,
so
three
thousand
four,
for
example,
what's
happening
when
you're
putting
the
Genesis
so
there's
two
Genesis
transaction
files,
there's
one
for
the
nodes
and
then
there's
ones
to
connect
to
the
nodes.
The
ones
to
connect
to
the
nodes
are
specifying
the
IPS
and
traditionally
like
if
your
docker
is
not
working
like
if
you
get
a
leisure
time
out
here
traditionally,
when
you're
running
that
stuff
locally,
what
that
means
is
that
your
client
development
image
is
not
able
to
find
your
other
docker
images.
G
A
A
The
ledger
Explorer
is:
we've
got
two
three
four
and
one
one.
Two
three
four
looks
like
it
just
didn't
get
it
started:
it's
not
that
big
of
a
deal,
what
it's
really
showing
you
is
the
nodes,
and
then
you
can
also
see
the
actual
transaction
JSON,
that's
being
passed
on
the
ledger,
it's
similar
to
what
was
showing
over
and
the
Vaughn
agent
stuff
it.
The
Vaughn
agent
guys
were
actually
the
ones
to
build
this
demo.
So
we
will
go
ahead
with
the
demo
and
we
don't
have
Alice,
but
we
have
Bob.
A
So
we
can
do
the
exact
same
demo.
The
reason
Alice
and
Bob
both
exist
in
here,
as
well
as
to
show
how
Alice
and
Bob
can
communicate
with
each
other.
That's
another
functionality
that
they
wanted
to
show
which
we
can
do
through
the
messaging
format.
So
the
first
thing
we're
going
to
do
is
we're
going
to
connect
favor,
College
and
Bob
now,
and
we're
just
going
to
do
that
by
pasting.
A
This
D
ID
in
here
so
it
looks
like
I-
have
two
of
them
here
will
accept
one
and
reject
the
other.
So
the
way
you
do
that
is
you
go
into
this
message
and
then
you're
refresh.
So
we've
now
gotten
a
connection
request.
We're
gonna
reject
this
first
one
and
accept
the
second
one
and
hope
that
doesn't
break
things.
I,
don't
know
why
we're
competing
in
the
dictionary
just
popped
up.
A
A
One
of
the
things
that
we
considered
with
this
is,
if
you're
submitting
a
connection
request
and
get
a
rejection
information
back
that
it's
actually
a
point
of
which
information
that
can
be
revealed
and
correlated.
So,
for
example,
imagine
if
I
submit
a
facebook
friend
request
to
somebody
and
they
reject
me.
Facebook
doesn't
pop
up
with
a
notification
that
says
you've
been
rejected.
A
So
now,
we've
got
here
is
we've
got
an
actual
identity,
so
we're
going
to
now
with
favorite
college.
We
are
going
to
create
a
credential.
So
the
first
thing
that
we
have
to
do
has
favorite
college
is:
we
need
to
actually
submit
the
schema,
so
this
has
been
pre
formatted
in
this
text
here
and
we're
going
to
hit
submit
and
what
I
did
is
that
just
took
the
schema
and
it's
published
it
to
the
ledger.
A
So,
if
you're
running
this
demo
elsewhere
or
if
you're
running
with
docker,
you
will
actually
be
able
to
then
go
over
to
the
ledger
Explorer
and
you
will
be
able
to
see
this
information
that
exists.
I
believe
in
the
domain
ledger.
So
there's
four
different
Ledger's
that
are
running
and
in
the
domain
ledger
is
where
we
keep
the
majority
of
the
data,
that's
related
to
D
IDs.
So
now
that
we
have
that
we
are
going
to
create
a
credential
definition.
So
we've
got
this
pre-populated
here
with
my
transcript,
but
that
can
be
changed.
A
Yeah
yeah,
so
for
those
of
you
who
weren't
here
in
the
past
and
and
just
for
recovery,
essentially,
the
idea
behind
it
is
a
credential
definition
is
taking
a
schema
which
has
these
values
here,
and
it's
saying
this
D
ID
is
now
authorized
to
issue
this
credential.
So
it's
combining
as
I
like
to
say
a
D
ID
and
a
schema
together
to
show
what
a
credential
definition
ID
is,
and
so
what
this
does
is.
It
creates
a
closed
world
assumption
about
who
issues
what
credentials.
This
is
very
nice
for
your
ontological
views.
A
Open
world
assumptions
create
a
lot
of
messy
aspects.
So
with
that,
we
are
now
going
to
submit
that
credential
definition
and
just
like
the
video,
my
guess
is
it's
going
to
take
a
little
bit
to
be
able
to
do
it
and
there
it
goes
so
now.
What
I
shouldn't
be
able
to
see
you
in
here
is
that
I
have
a
credential
definition
that
I
can
send
as
an
offer.
A
Additionally,
with
that
I
can
select
who
my
endpoint
is
so
I've
got
endpoint
D
ID
here,
which
is
the
one
that
are
rejected
as
well
as
Bob
I
could
offer
a
credential
to
the
rejected
one,
but
the
connection
wouldn't
go
through
and
wouldn't
really
make
sense.
So
we
will
send
this
over
to
Bob
and
we
will
submit
that
to
him,
and
so
we
are
in
the
issuing
tab
right
now.
Let's
see
if
it's
in
this
message,
oh
wait.
We
need
to
be
in
Bob's
jump
over
to
messages.
A
We
will
now
see
that
Bob
has
been
issued,
a
credential
from
Faber
College.
This
is
essentially
saying:
I
am
willing
to
issue
you,
this
credential
I'm,
offering
you
this
credential.
You
can
choose
to
accept
or
reject
it.
This
is
where
the
negotiation
on
the
issue
inside
starts
to
come
into
play
in
the
future.
A
The
capabilities
of
this
should
allow
you
to
not
only
accept
a
request
or
accept
or
reject,
but
you
should
also
be
able
to
counteroffer
credentials
and
say:
hey
I,
see
that
you're
offering
me
this
one,
but
you
also
offer
that
one,
that's
the
one
I
actually
wanted.
So
in
the
instance
of
the
driver's
license
or
something
like
that,
where
the
d-o-t
offers
both
a
driver's
license
and
a
voter
registration,
you
may
need
different
ones,
and
so
that
would
be
a
use
case
where
you
may
need
to
request
a
a
separate
credential
offer
in
this
case.
A
So
we
are
going
to
go
ahead
and
accept
it
and
move
forward
with
this
demo,
and
so
we've
now
gone
and
accepted
that
on
Bob's
agent,
we're
gonna
jump
back
over
here
to
favorite
colleges
agent,
and
we
don't
see
any
messages
in
here.
So
my
guess
is
it's
now
within
the
credentials
we
can
actually
see
transcript,
so
we've
got
transcript
1.3,
which
is
the
credential.
We
can
see
the
actual
values
itself
and
underneath
all
this
is
actually
signed,
data
which
I
can
then
go
and
use
to
prove
information
later
on.
A
So,
additionally,
we're
now
going
to
go,
set
up
a
connection
with
Acme
corporation,
so
moving
along
with
that
demo.
We're
going
to
now
go
get
our
employee
credential
and
so
the
way
that
we're
going
to
do
this
is
we're
going
to
take
acne
credentials
or
acne
Corporation's
di
D
and
we're
going
to
go
ahead
and
set
up
that
connection.
Request
again
initiate
the
connection
here,
so
we've
now
sent
it
over
we're
gonna
jump
back
over
to
the
messages
refresh
we're
gonna
hit,
accept
and
so
on.
This.
A
The
reason
why
you're
seeing
name
here
is
because
that's
the
difference
between
the
D
ID
and
the
actual
name
itself,
so
as
a
part
of
this
connection
protocol,
but
not
the
standardized
one.
One
of
the
options
is
that
you
can
actually
offer
a
name
for
the
D.
Id
will
likely
include
this
in
the
connection
protocol
as
an
optional
aspect
of
it,
because
this
data
is
moving
over
plaintext,
but
that's
something
to
be
debated
on
our
nd
agent
cost.
A
So
if
you
guys
want
to
come,
join
and
offer
your
your
opinions
on
that,
please
do
join
us,
so
we
will
hit
accept
here
and
now
we
will
jump
back
over
to
Bob's
agent.
We
will
refresh-
and
now
we
see
we
have
a
connection
setup
here
with
acne
and
so
with
acne.
We've
got
this
connection
here
and
we
can
see
my
D
ID
and
we
can
see
their
D
ID
still
as
well
as
a
public
D
ID.
D
A
As
a
part
of
the
connection
request
yeah,
so
one
of
the
things
that
we
are
working
on
in
the
hypes
community
is
defining
standards
around
these
things.
So
this
was
implemented
using
a
non
standardized
approach,
because
we
didn't
have
a
standardized
connection
protocol
set
up
at
the
time
and
so
the
the
thinking
behind
that
was
well.
We
want
to
be
able
to
show
this
stuff
works,
but
you
know
I
don't
want
to
have
to
wait
until
we
go
through
a
standardization
process.
Yeah.
F
A
A
What
they're
doing
was
actually
something
that
we
agreed
is
probably
not
the
best
way
to
approach
it,
which
is
they
were
using
a
public
identifier
on
ledger
to
go
pass
a
pairwise
identifier
and
the
problem
with
that
is
your
public
di
D
now
becomes
a
global
cookie
between
all
these
things,
even
though
you're
running
pairwise
the
IDS.
So
this
was
likely
something
to
do
with
the
protocol
itself,
not
meeting
the
needs
of
anti-correlation,
so
yeah
go
ahead.
A
The
reason
the
credential
issuance
is
separate
from
the
connection
itself
is
because
the
connection
itself
is
the
set
up
of
the
encrypted
channel.
The
credential
itself
is
when
you're
actually
starting
to
move
data,
so,
for
example,
as
a
part
of
the
credential
process,
you
may
be
moving
data
and
plaintext,
and
that
reveals
information
about
it.
So
the
first
thing
that
we
do
is
we
bootstrap
and
into
end
encryption
connection
or
in
encrypted
connection
between
the
two
parties
before
we
have
them
communicate.
Does
that
make
sense.
A
So
you
can
do
that,
but
there
you're
not
always
going
to
be
doing
credential
issuance
over
the
communication
protocol,
so
you
could
be
doing
just
communication.
So
one
thing
that
was
brought
up
during
these
conversations
is:
do
you
need
to
pass
the
data
through
credential
at
all
times,
and
the
answer
to
that
is
no.
The
reason
for
that
is
credentials
are
awesome
for
establishing
data
provenance
when
you're
chaining
provenance
between
multiple
identities.
A
However,
if
you
have
direct
connection
to
the
provenance-
and
you
trust
that
provenance,
because
they've
presented
proofs
you
or
something
like
that,
because
the
connection
itself
is
valueless,
it's
just
an
encrypted
channel,
the
value
comes
from
the
fact
that
they
can
prove
their
identity
to
you
with
credentials.
But
once
they've
proved
that
to
you,
you
then
know
something
about
them,
which
then
allows
you
to
ask
directly
for
information.
A
D
D
A
So
this
is
where
we
get
our
major
scalability
advantages
is
that
we
can
move
data
completely
off
ledger
and
you
can
do
this
completely
off
ledger.
So
one
of
the
things
that
I've
realized
in
this
is
the
ledger
is
valuable,
basically
for
issuing
on
this
stuff,
but
you
could
technically
do
issuing
of
credentials
and
revocation
off
ledger.
None
of
this
has
been
defined,
but
it
is
possible
to
do
because
the
whole
point
of
the
ledger
and
the
whole
point
of
the
data
that's
on
the
ledger-
is
that
it
should
be
globally
discoverable.
D
A
Yes,
so
these
things
are
all
on
ledger
because
they're
globally
discoverable,
but
if
you
built
in
this
functionality
it
is
possible
to
do
it,
because
the
main
point
of
credentials
is
that
you
can
discover
the
keys.
You
can
discover
the
revocation
registry,
you
can
discover
the
credential
definitions
and
you
can
discover
the
schemas
the
easiest
way,
because
this
data
is
basically
non
correlating
and
not
personal
and
personally
identifiable
information
is
just
put
it
on
a
ledger
and
make
it
globally.
Discoverable.
A
However,
there's
cases
for
example,
where
I
may
issue
a
basically
a
single
sign-on
within
my
my
company,
a
single
sign-on
credential,
and
that
credential
is
only
valuable
within
my
company
itself.
So
I
could
set
up
these
credentials
to
operate
in
within
my
own
company
itself
and
none
of
that
data
and
none
of
the
revocation
registries.
None
of
that
stuff
actually
has
to
go
on
ledger.
I
can
do
all
that
stuff
off
later.
That's
a
design
thing
and
it's
an
idea.
A
A
C
C
I
A
A
We
don't
expect
users
to
go
through
this
user
experience
if
I
had
to
I
wouldn't
use
this
system,
and
that's
that's
plain
and
simple,
but
we
know
that
it's
capable
to
build
good
and
efficient
user
experience,
user
experiments
or
experiences
that
are
possible,
and
so
because
of
that
we
look
at
it
and
we
go
there's
going
to
be
a
basically
marketplace
of
agents
that
are
going
to
do
different
things
they
will
compete
based
upon.
You
know
many
different
aspects,
user
experiences
being
one
of
them.
A
Another
one
is,
can
I
trust
the
person
who
created
the
agent,
so
you
know,
for
example,
if
that
agent
is,
you
know,
run
by
Google
and
stuff,
and
we've
known
in
the
past
that
Google
wants
to
gobble
up
as
much
data.
It's
going
to
be
hard
to
trust
that
they
actually
built
this
if
they
aren't
showing
us
the
code
for
it,
you
know
so.
The
these
are
the
types
of
things
that
users
will
have
to
consider.
However,
if
they're
all
running
the
same
protocol,
it
shouldn't
make
a
difference.
A
D
A
The
technology
is
a
part
of
the
indie
structure,
but
as
a
part
of
the
sovereign
foundation.
Within
our
governance
framework,
we
set
certain
principles
and
certain
ideas
into
what
a
developer
has
to
do
to
me,
a
sovereign
compliant
agent,
and
so
that's
kind
of
the
thinking
behind
it.
So,
for
example,
if
somebody
comes
in
and
says
that
they're
doing
it
in
this
way,
technologically
they
can
speak.
A
You
know
all
the
agent
agent
protocols,
but
they
will
not
be
considered
sovereign
compliant,
and
that
will
be
a
major
advantage
within
the
marketplace
is
to
have
this
sovereign
compliance,
that's
kind
of
the
thinking
behind
that
very
early
stage
thinking,
but
it's
one
of
the
only
ways
that
we
see
that
we
can
enforce
these
types
of
things,
and
so,
if
there's
better
ways
to
enforce
this,
that
give
us
better
trust.
We
will
do
that
so
yeah
go
ahead.
G
G
A
That
would
be
even
better
because
the
whole
point
of
this
is
that
self
sovereign
identity
is
basically
building
blocks
to
enable
these
use
cases.
But
it's
up
to
the
creators
and
the
developers
of
these
agents
to
actually
determine
the
use
cases
and
how
they
can
use
this
to
provide
real-world
value
because
well,
SSI
is
a
great
system
to
work
with.
It's,
not
the
only
piece
you're
going
to
need
in
order
to
do
this
stuff
you
may
need
you
know,
other
databases
that
you
already
have
that
are
being
run
through
your
through
your
current
business
systems.
A
A
Yes,
it
doesn't
have
to,
though,
so
there
are
cases
so
one
of
the
things-
and
this
is
why,
in
the
definition
of
the
the
agents,
let
me
pull
that
back
up
here,
real
quick,
so
that
we
can
take
a
look
at.
That
is
that
agents
can
be
what
we
refer
to
as
Def
dim,
but
not
both.
They
can
be
neither
def
or
Dom.
A
What
that
means
is
they
can
listen
only
they
can
speak
only
or
they
can
do
speaking
and
listening
roles,
in
which
case,
if
you
are
listening
only
you
don't
really
need
a
key,
but
you,
you
probably
will,
because
you
need
to
be
able
to
decrypt
messages
for
you,
but
there's
there's
instances
where
these
things
could
happen
where
you
don't
need
keys.
However,
if
you're
doing
that,
you
could
be
revealing
PII
data,
which
is
in
violation
of
self
sovereign
identity.
A
So
it's
one
of
those
things
where
it
really
depends
upon
your
use
case,
but
nearly
every
single
time
you
should
be
defaulting
to
keys,
but
in
the
example
of
like
IOT
devices,
where
it's
gonna
be
hard
to
store.
You
know
an
entire.
You
know
wallet
with
a
database
of
thousands
of
keys
and
stuff,
like
that.
We've
thought
of
these
things
called
static
agents
and
what
a
static
agent
is
is
basically
something
that
stores
a
key
inside
of
a
file.
Now
for
most
people,
who've
dealt
with
keys
before
that's
very
like
unsmurfy.
A
So
I
can
know
whether
or
not
I
trust
that
data
at
what
level
I'm,
trusting
I
guess
I
should
say,
and
in
some
cases
it
doesn't
make
a
difference,
but
in
other
cases
it
may-
and
you
may
want
to
reject
it,
because
it
doesn't
meet
your
security
context
that
you
expect
so
jumping
back
to
that
definition.
This
is
where
we
use
this
idea
of
speaker.
Listen,
so
you
can
speak
or
listen
protocols
or
you
can
do
both
a
protocol
which
can
do
both.
A
We
refer
to
as
kind
of
like
a
full
agent
or
a
full-blown
agent,
and
then
you
may
have
something
like
static
agent,
which
is
running.
You
know
it's
not
running
a
wallet.
It's
just
going
and
grabbing
a
key
from
a
file
or
it
may
be.
You
know
leveraging
the
keychain
and
putting
a
key
inside
of
the
keychain
to
be
able
to
do
these
types
of
things.
There's
many
different
capabilities
again.
A
D
A
The
the
thinking
behind
it
is
that
you
get
to
choose
which
end
points
you
expose
so
we'll
go
in
here.
This
is
a
slightly
different,
so
I'm
gonna
I'm
gonna
keep
this
one
fairly
time
box,
but
no,
where
is
it?
It's
it's
an
excellent
question,
and
actually
it's
somewhat
near
and
dear
to
me
because
I'm,
the
one
building
it
so
the
wire
message
right
here
is
where
we're
actually
talking
about
these
types
of
things,
and
so
this
is
what
we
define
as
how
you
actually
encrypt
these
messages.
A
So
one
thing
you'll
notice
is:
we
have
a
lot
of
documentation
to
detail
these
types
of
things.
How
messages
will
get
routed
between
multiple
devices?
So,
for
example,
you
may
have
what
we
refer
to
as
an
agency
which
is
acting
as
a
public
endpoint
for
you
and
the
agency
is
the
only
one
that
knows
your
actual
endpoint.
You
don't
even
reveal
that
endpoint
to
the
other
person,
you
reveal
your
agency's
endpoint
and
then
you
can
basically
close
these
things
off.
A
However,
the
nice
thing
about
this
is
you're,
not
developing
firewall
infrastructures
around
this,
because
everything's
encrypted
from
point
to
point
and
potentially
encrypted,
for
example,
from
device
one
directly
to
device
for
where
device,
9,
3
and
6
don't
even
have
access
to
data
that
they
don't
need.
What
you're
doing
is
you're,
basically
creating
a
zero
trust
architecture
around
these
types
of
things,
and
so
that's
one
of
the
defining
principles
of
this
communication
protocol
is
that
you
don't
need
to
build
all
these
firewalls
and
these
types
of
things
where
I've
got
this.
A
You
know
this
idea
of
I'm
closed
off
from
the
world.
That's
one
of
the
things
about
this
picture.
This
dotted
line
helps
to
understand
it,
but
in
reality
there
is
no
difference
between
the
connection
from
3
to
6
and
from
9
to
3.
Similarly,
there
is
no
difference
between
the
connection
from
1
to
2,
to
1,
to
8
or
8
to
9,
and
that's
because
they're,
all
speaking,
the
same
protocol
they're
all
encrypting.
A
D
G
D
A
So
we
are
depending
on
signal
in
many
ways
for
forward
secrecy
and
stuff
like
this,
but
we
are
doing
it
in
a
way.
That's
slightly
tweaked,
so
we're
not
using
actual
signal,
api's
and
stuff
like
that.
We're
looking
to
use
like
noise
framework
and
the
biggest
thing
that
we're
adding
to
this
is
non
correlation
of
information.
So
traditionally
what
most
people
would
do,
especially
in
signal
Protocol.
A
For
example,
if
we
jump
back
to
that
picture,
they
have
an
intermediary
server
that
sits
in
the
middle
and
that
intermediary
server
gets
certain
pieces
of
metadata
that
it
doesn't
necessarily
need.
So,
for
example,
if
I'm
taking
a
look
at
this
picture
and
what
about
here,
we've
got
a
number
8
and
number
2
which
are
acting
as
intermediaries.
Now,
just
recently,
the
GCHQ
I
don't
know
how
this
information
was
found,
but
is
a
publicly
known
controversy
at
this
point,
GCHQ
has
stated
they
don't
plan
to
break
encryption.
They
don't
look
for
black
doors.
A
Their
intention
is
to
go
after
the
people
who
host
these
intermediary
servers
and
force
them
to
interject
them
into
the
conversations
which
doesn't
break
the
encryption.
It
just
adds
a
new
end
to
the
encryption,
and
so
that's
the
thinking
behind
this
is,
if
somebody
can
do
that,
then
that's
not
possible
all
right
that
that's
a
problem
essentially
with
our
system.
That's
not
really
possible
because
the
message
is
directly
encrypted
from
one
to
four
and
one
is
also
including
messages
directly
that
are
being
wrapped
around
at
2
2
&
8
with
the
revealing
information.
A
So
there
is
another
routing
protocol
here
that
describes
this
stuff.
It
is
actively
in
discussion.
This
was
what
we
were
discussing
last
week.
So
if
you
want
to
come
and
join
us
on
these,
these
calls
that
would
be
the
the
best
thing
to
do.
I
either
way.
If
you
can't
drain
us
on
the
calls
pay
attention
to
the
hypes
comments
on
them-
and
you
know
that's
a
another
great
way
to
help
us
out
and
make
sure
that
we're
building
you
know
the
best
system.
F
A
A
However,
if
thousands
of
people
are
communicating
over
the
same
IP
address
back
and
forth
between
two
agencies,
it
provides
that
herd
immunity
which
allows
you
to
prevent
correlation,
and
so
that's
kind
of
the
idea
behind
the
eight
nine
here
they
don't
exist
within
your
domain.
They
can't
decrypt
a
message.
They
can
see
a
D
ID
that
has
been
identified
only
to
them
and
to
the
other
party,
and
that's
all
they
can
identify.
A
Similarly,
we
have
this
concept
of
a
cloud
agent
or
what's
referred
to
as
a
routing
agent
as
well,
which
is
going
to
essentially
act
as
an
agent
where
a
message
will
come
in
to
8:00
and
it
will
end
up
on
number
twos
box
because,
as
we
know,
number
one
is
its
mobile
device
does
not
maintain
the
static
IP
and
is
not
always
online.
That's
the
advantage
of
the
cloud
agent
or
also
referred
to
as
the
routing
agent
is
that
it's
always
available.
A
If
you
can
have
a
agent
wishes
always
available,
and
you
trust
and
hone
so,
for
example,
a
device
that
may
sit
at
home
or
something
like
that,
you
can
basically
put
that
routing
agent
in
your
own
home
and
it
can
also
decrypt
the
messages
and
you
can
have
messages
intended
for
that
as
a
recipient
or
what
we
refer
to
as
an
edge
device.
Because,
if
you
think
about
this
in
terms
of
a
graph,
these
are
the
devices
that
sit
at
the
very
edge
of
the
graph.
Everything
else
is
an
inner
mere
intermediary
node
in
between.
C
A
So
what
he's
pointing
out
is
something
that
we've
been
discussing
for
quite
some
time
and
to
give
you
guys
a
little
context.
I
will
cover
this
essentially
what's
happening
is
when
Alice
wants
to
send
a
message
from
her
phone
over
to
Bob's
phone,
which
is
number
4.
They
have
to
go
through
intermediaries.
So
down
here
we
see
1
2
8
9
3
4.
A
A
For
so
what
you'll
notice
is
that
8,
9
and
3?
All
they
need
to
know
is
what
they
need
to
do
to
to
the
next
hop.
This
is
something
that
we've
referred
to
as
basically
a
relay
er
within
this
pattern.
Essentially-
and
so
this
is
better
described
in
this
hype-
and
this
is
been
developed
by
Daniel
Hardman
over
here,
as
well
as
Tobias
I,
believe
his
last
name
is
liquor
or
looper.
He
is
down
in
New,
Zealand
and
so
he's
been
helping
out,
helping
us
some
out
with
this
stuff.
A
H
A
This
is
where
we
use
something
referred
to
as
the
forward
message
we're
in
the
forward
message.
If
you're
doing
Onion
Routing,
for
example,
you
specify
the
key
of
the
device
and
then
wrap
it
up.
Stick
it
inside
of
a
forward
message,
wrap
it
up
and
do
that
type
of
thing
and
just
in
time,
I
am
not
entirely
certain
on
the
routing
protocol
of
what
they've
developed
like
off
the
top
of
my
head.
So
you'd
have
to
go.
A
Take
a
look
at
that,
but
it
specifies
basically
how
you
use
relaying
messaging
to
actually
go
and
do
just-in-time
routing,
which
makes
it
a
little
bit
easier
on
your
edge
devices
for
encryption,
and
so
that's
kind
of
the
thinking
behind
it.
However,
it
doesn't
reveal
information,
and
so
that's
kind
of
one
of
the
the
main
advantages
to
it.
C
A
A
The
the
point
here
was
to
get
you
guys
familiar
with
the
Indy
SDK,
but
you
guys
are
already
jumping
on.
You
know
the
important
questions
that
we're
trying
to
solve
right
now,
like
I,
said
at
the
very
beginning
of
this,
were
it's
like
we're
walking
through
a
force
with
a
machete
and
we're
trying
to
cut
our
own
path.
So
if
you
guys
want
to
come
in
grab
a
machete
it'll
make
us
easier
to
cut
a
bigger
path
and
make
this
better.
So
yeah
go
ahead.
A
A
A
How
to's
you
guys
saw
the
video
of
this.
You
saw
that
it
works.
It's
not
some
sort
of
like
basically
vaporware.
This
code
is
publicly
available.
This
code
exists
in
both
the
education,
repo
I
believe
as
well
as
it
exists
in
the
indie
agent
repo,
so
that
can
be
found
at
github,
slash,
hyper
ledger
and
indie
agent,
and
so
here
we
have
to
to
reference
agents
as
well
as
the
test
suite.
A
So
if
you
guys
want
to
go
build
on
top
of
this
or
you
want
to
go,
take
a
look
at
the
code,
that's
where
it
exists.
What
I
did
want
to
get
to,
though,
is
the
actual
Indy
SDK
running,
and
so
what
I
wanted
to
show
you
from
the
very
beginning.
So
this
is
all
that
code
pulled
up
here,
so
I'm
going
to
close
it
out
so
that
we
can
show
the
full
demo
of
just
clone
it
and
get
yourself
set
up.
A
So
this
isn't
my
personal
repository
right
now.
It
is
linked
in
the
slides.
The
intention
of
this
is
that
it's
a
development
environment
inside
of
a
docker
ice
container.
It
runs
the
Python
wrapper
right
now.
The
intention
is
that
you
can
run
all
four
wrappers
as
well,
and
you
should
be
able
to
develop
your
own
agent.
Additionally,
I
want
to
take
the
reference
agents
and
put
them
inside
of
there,
so
that
you
can
just
build
on
top
of
them
inside
of
the
development
environment.
A
This
fight
provides
two
main
advantages:
one
you
can
get
started
very
quickly
and
two
when
it
breaks
for
one
it
breaks
for
all.
Hopefully,
the
intention
behind
that
is,
if
we're
all
using
the
exact
same
development
environment,
we
can
know
when
things
break,
and
we
can
know
when
things
happen,
so
we
can
rapidly
get
these
things
fixed,
much
faster.
A
But
again,
this
is
my
personal
side
project
that
I
typically
linked
to
to
show
these
types
of
things
and
it's
being
used,
it's
being
worked
on,
but
it's
being
worked
on
in
the
side.
So
if
you
guys
want
to
come
help
me
to
add
rapper
support
or
something
like
that,
I
can
help
you
I
can
help
direct
you.
I
will
also
contribute
code
with
you
right
now,
I'm,
mainly
the
person
helping
Kuzma
has
helped
me
out
with
this,
as
well
as
a
few
others
in
the
community.
A
A
A
Opus
OpenSSH
and
loop
sodium
installed
natively
on
their
laptop,
so
the
docker
environment.
Does
this
a
little
easier
with
that
said,
I'm
now
going
to
go
open
this
folder
directly,
so
I
can
show
kind
of
what
a
development
experience
would
be
like.
So
we're
going
to
go
to
my
folder
dev
demo
and
we're
going
to
open
any
dev.
A
A
I'm
doing
make
start
I'm
going
to
start
a
pool
and
a
docker
image
just
like
that,
and
so
what
I've
done
is
I've
actually
mounted
all
the
files
which
are
locally
hosted
right
here
and
developer
within
vs
code
on
my
local
file
system
and
I've
now
mounted
them
to
the
docker
image
so
that
I
can
actually
go
and
run
them.
So,
for
example,
we've
got
we're
gonna
CD
into
Python,
which
is
where
all
the
Python
code
exists
and
we've
got
the
getting
started
guide,
as
well
as
the
how
to's.
A
So
now
we
can
see
the
into
the
how
to's
here
and
we
can
see
all
seven
of
those
six
and
seven
are
not
complete
right
now,
they're
in
progress
stuff,
so
one
through
five
are
the
two
that
we're
working
six
actually
might
be
working
I
didn't
test
it,
though
so
I
don't
want
to
say
it
is,
and
seven
I
don't
believe,
is
working.
It's
not
complete,
but
it's
on
its
way.
A
A
A
That
I
haven't
done
that,
though,
but
the
idea
behind
this
is
essentially,
you
can
see
this
code
running,
and
so
what
you
should
be
able
to
see
is
that
you
would
see
all
of
these
logging
outputs
running
down
here
and
you
would
be
able
to
see
it,
and
the
nice
thing
about
this
is
that
you
can
actually
go
and
take
a
look
and
rapidly.
You
know
see
what's
happening
with
these
development
scripts
so,
for
example,
and
the
how-to
right
here,
let's
give
that
one,
a
try,
I,
don't
think
it's
gonna
work.
A
We
can
try
running
right,
D,
ID,
query,
ver
key,
so
yeah
this
one,
the
the
thing
re
test,
because
when
I
ran
the
last
one,
it
created
a
pool
transaction
file
for
me
that
was
pointing
at
my
local
ledger
and
it
wasn't
able
to
delete
it.
So
it's
hitting
a
namespace
collision
right
now
and
one
of
the
things
that
I
change
to
get
this
demo
working
is
it
used
to
show
all
of
these
files
directly
on
these
left
side?
C
A
That's
exactly
so
one
of
the
things
that
happens
on
on
startup
and
what
I
might
be
able
to
do
is
show
you
guys
how
how
I
could
just
easily
edit
these
scripts.
So
at
the
end
of
each
script,
we
actually
have
a
queen
up,
which
is
13
through
15
in
this
one.
So
I'm,
gonna,
try
and
do
is
move
that
to
the
very
top
and
try
to
be
running
at.
A
So
yeah
now
this
is
calling
wallet
handle
before
it
happened.
So
I
would
need
to
edit
this.
But
what
you'll
notice
here
is
that
I
actually
got
a
different
error
and
so
in
editing
this
this
work
inside
of
vs
code
I'm,
now
able
to
run
it
directly
inside
of
the
docker
container
and
create
this
rapid
development
cycle
where
I
have
a
consistent
development
environment.
A
No
matter
what
my
host
operating
system
machine
is,
but
at
the
same
time
I
can
have
all
of
this
code
and
all
of
the
files
actually
living
on
my
local
file
system
and
I
can
use
all
the
local
file
system
access
mechanism
points.
So
traditionally
what
I've
seen
people
do
is
they
run
like
full-on
virtual
machines
and
stuff
like
this
and
then
the
gooeys
when
you're
running
it?
The
gooeys
are
like
very
laggy
and
these
types
of
things.
C
C
A
So,
along
with
this,
I
will
update
this
and
it
should
be
countable
I'm,
going
to
fix
it
tonight,
because
I'm
actually
giving
the
same
demo
tomorrow,
I'm
going
to
go
and
fix
this
stuff,
but
if
you
guys
want
to
run
this
later
on,
it
should
be
working
and
there's
actually
documentation.
Inside
of
here,
that's
commenting
and
describing
what
these
codes
are
doing.
So
what
you're?
Looking
for
inside
of
all
these
are
the
SDK
commands
like
pooled,
create
pool,
ledger
and
stuff
like
that.
A
What
you're,
trying
to
figure
out
with
these
demos
is
how
I
can
take
the
SDK
and
create
real
world
value
with
it.
So
how
would
I
go
and
create
a
credential,
for
example?
So
you
have
to
make
a
few
calls
like
I
need
to
set
up
a
wallet.
I
need
to
set
up.
You
know
the
schema
definition.
I
need
to
set
up
the
credential
definition.
I
need
to
do
all
these
pieces
in
order
to
do
it.
So
that's
what
these
how-to
guides
are
showing.
A
You
is
basically
here's
all
the
steps
that
you
need
to
do
in
order
to
perform
this
functionality,
so
we've
got
write,
D
ID
and
a
write
name
and
query
via
turkey,
so
I'm
writing
a
DI
to
the
ledger
and
getting
the
Berkey
the
verification
key
back,
there's
also
a
rotate
key.
One
save
schema,
that's
half
of
stuff,
so.
A
So
the
current
thinking
is
that
you
can
store
an
encrypted
Bob
from
one
device
and
pull
that
encrypted
Bob
down
to
another.
Additionally,
you
could
just
copy
it
directly
over
from
one
to
the
other.
So
there's
there
is
something
about
it.
There's
no
standardized
way
to
do
it
at
this
point,
so
I
would
say
coming
to
propose
a
hype
and
we'll
discuss
it
cool.
Thank
you
guys
very
much.
Awesome
questions,
I
very
much
appreciate
it
and
I'm.
Sorry.