►
A
B
A
A
When
saving
to
peer
did
for
caching
format,
all
right
so
remember,
why
are
we
doing
all
this?
We
just
want
to
save
we?
Just
all
we
want
to
do
is
save
and
load
data
flows
right
from
disk.
What's
the
side
effect,
if
we
save
them
and
load
in
in
this
format
from
disk
also
becomes
something
that
we
can
pass
around
and
create
some
distributed
execution
with.
So.
A
Okay,
so
if
group,
if
organization
create,
add
great
ephemeral
entity
for
this
execution
or
let's
see
if
organization,
okay,
so
basically
entity
for
top
level
system
context,
okay,
so
we
kick
off
top
level
system
context.
Something
starts
so
our
first
call
basically
right
because
remember
this
is
like
a
calling
convention.
So
we
call
in
to
the
open
architecture
we
need
to
know
who
is
running
the
top
level
system
context
right.
So,
in
the
event
that
multiple
parties
are
involved
in
execution
of
the
top
level
system
context.
A
Equally
right,
so,
basically,
everybody
is
equal
in
some
org
and
you're
all
running
this
thing
as
an
org,
so
maybe
you're
doing
like
a
key
signing
ceremony
right.
An
entity
in
ad
hoc
ad
hawk
organization
will
be
formed
if
it's
not
already
being
referenced,
let's
actually
say
so.
This
is.
I
started
with
the
most
complex
case,
okay,
so
so
the
entity
for
that
org
will
be
used.
A
C
A
A
A
A
D
C
A
Once
within
the
callee,
the
caller
is
referred
to
as
the
parent
system
context
as
well
as
well.
Okay,
the
parent
system
context,
the
colony-
should
only
be
referred
to
as
the
parent
as
the
system
context.
Unless
we
are
talking
about
it
in
relation
to
the
caller
itself
being
a
subcontext,
it
launches
or
manages
it
if
it
begins
setting
up
a
colleague
via
formula
mantis,
we
will
start
referring
to
it
as
the
as
a
parent
system
context
within
the
context
of
its
relationship
to
its
new
potential
child.
A
A
A
A
A
A
A
Okay,
so
we'll
just
create
a
new
did
key.
If
we
don't
have
one
already
so
we're
gonna
do
all
this
in
memory
at
first
and
then
we'll
back
it
to
disk
via
dataflow
or
you
know,
via
you
know,
some
remote
database
or
whatever
we'll
figure
it
out
so
okay
entity
for
top
level
system
context
is
the
id
key
okay.
So.
A
Let's
see
so
in
the
input
network,
basically
we're
going
to
write.
You
know
this
dataflows
class
and
then
we're
going
to
write
input
networks
using
dataflows
class,
which
are
just
operations
which
basically
just
sit
there
and
listen
for
you
know
incoming
dids
and
then,
when
they
get
them,
they'll
add
them
as
inputs.
You
know:
they'll
grab
the
off
chain
data.
However,
they
need
to
grab
the
off
change
data
and
they'll,
convert
them
to
inputs
right
so
yeah.
Maybe
we
could
use.
A
A
A
For
static
data,
primitives,
yeah,
so
and,
and
so
remember,
this
is
the
purely
ids
are
almost
more
of
a
messaging
thing
than
actual.
You
know
like
what
what
you
know,
people
have
been
thinking
of
with
consensus,
maintained,
blockchains
right,
so
this
is
really
just
our
our
cryptographically
linked
list
here.
A
A
B
A
A
B
A
C
A
B
C
A
C
B
A
C
A
B
A
B
C
A
A
A
A
Let's
take
a
look
here
just
to
confirm
yeah,
so
d,
id
yeah,
so
pure
zero
means
that
this
is
a
did
key
right.
So
we
could
replace
this
portion
and
then
all
of
a
sudden
we'd
have
a
did
key
okay.
So
we
want
to
figure
out
how
to
use
verification,
material
value,
assigning
keys,
verification,
material,
okay,
verification,
material
authentication,
okay,
agreement.
B
A
A
A
A
A
A
B
A
A
Okay,
so
let's
yeah,
let's,
I
wonder,
find
principles
check
no
validate
sign
verify.
I
think
if
we
do
this,
this
is
going
to
allow
us
to
so
so.
Github
exposes
everybody's
public
keys,
which
is
great
they're
public.
So
that
means
we
can
chain
right
off
that
which
is
going
to
be
sweet.
If
we
can
use
these
so.
A
Json
webkey
set
okay
from
pam
json
web
key
export
to
fra
pam
from
pam.
Okay
creates
a
pkcs
11
formatted
data
loaded
from
a
pem
file,
import
from
pam
imports,
key
from
a
data
loader
from
a
pem
file.
Oh
my
god!
This
is
gonna,
be
so
cool.
Okay.
If
we
can
do
this,
it's
gonna
be
awesome.
Okay,
so
let's
do
ssh
keygen
or,
let's
see.
A
A
A
B
B
A
A
B
A
A
D
A
A
A
Dot
check
call
see
what
happens
it
might
be
choking
on
a
line
waiting
for
a
new
line
yeah
enter
in
or
place
where
you
want
to
save
the
file.
Okay,
yeah
we're
choking
on
that
new
line
yeah
I
wish
we
could
just
set
it
up
to
read.
I
think,
there's
there's
there's
a
way,
I'm
not
sure
what
it
is,
though,
but
there's
a
way.
A
A
A
B
B
A
A
Because
doing
it
like
this
means
that
we
have
technically
done
our
due
diligence
here
right,
we
we,
we
did
what
we
were
supposed
to
do
to
make
this
thing
secure
right.
All
I
have
to
do
is
provide
a
password
right.
The
rest
of
it
you
know
is
is
is
is
up
to
you,
so
we
know
that
we
need
the
key
in
this
format.
We
have
to
have
the
key
in
this
format
right
now,
but
we
can
say
to
do
make
this
configurable
in
the
future.
A
A
A
A
D
B
A
A
So
let's
go
ahead
and
create
some,
this
verification,
material
or
let's
go
ahead
and
understand
some
I'm
going
to
duplicate
this
tab
and
we're
going
to
go.
Look
for
verification,
verification,
material
agreement.
Actually
we're
going
to
go.
Look
at
this
key
and
where
this
key
is
used
and
then
we're
going
to
see
you
know
where
it's
used
to
create
some
verification,
material
agreements.
A
A
A
A
B
B
B
A
B
A
A
A
B
A
A
A
A
Path:
identity,
root;
okay,
I
think
it
helps
to
keep
their
type
name
on
them
somewhere.
I
usually
was
suffixing,
but
I
think
prefix
probably
makes
more
sense
because
it
is
a
path.
First
of
all,
what
type
is
it,
then?
What
the
hell
is
it
right?
And
if
you
do
that,
then
you
can
kind
of
always
maintain
what
the
hell.
What
are
you
working
with
here?
A
A
A
A
Okay,
let's
do
yeah
we'll
keep
we'll
keep
the
the
stuff
consistent,
so
we'll
say,
identity
root,
key
path,
and
I
think
the
reasoning
behind
actually
doing
the
type
name
as
the
suffix
now
I'm
realizing
was
the
fact
that
you
know
identity
root.
Key
is
almost
like
a
structure
that
you're
creating
ad
hoc
and
then
dot
path,
dot.
Contents
right,
if
you
look
at
it
that
way
so
read
and
key
generated.
A
A
A
A
A
C
A
A
A
C
C
C
A
B
A
A
A
A
B
C
C
A
B
A
C
B
A
But
without
the
ec
public,
okay
so
began
ec
public
key
okay.
So
maybe
oh
I've
run
into
this
before
so
they
are
I've
run
into
this
before
so
they
are
being
stored
in
pem
format,
but
the
header
is
wrong
and
the
library
is
validating
the
header.
So
what
we
need
to
do
is
basically
just
say:
ray
bytes
read
bytes.