►
From YouTube: Hyperledger Indy Technical Deep Dive workshop
Description
A virtual workshop hosted on February 3, 2022. Instructors from Indicio ran a four-hour course that advances your skills related to coding with Hyperledger Indy Node. It also familiarizes you with commonly used cryptography libraries contained in Hyperledger Ursa and an overview of the Plenum ledger.
Topics include:
Hyperledger Indy Stack overview, including Ursa and Plenum
Introduction to libindy
Hyperledger Indy VDR (replacement for Indy SDK)
Learning about Hyperledger Indy Node
Making changes to Hyperledger Indy Node code
Build and IndyTest the changes locally
How to get involved in the community further with chats, helplines, and meetings
If you're interested in going through the workshop by watching this recording, check out the relevant material used in the workshop at:
https://wiki.hyperledger.org/display/events/Hyperledger+Indy+Technical+Deep+Dive
And if you have questions about this workshop or about Hyperledger Indy, you can ask at:
https://chat.hyperledger.org/channel/indy
----
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 #Blockchain
A
A
A
And
people
are
probably
familiar
with
this,
but
there's
a
few
different
ways
to
ask
questions.
You
can
come
off
mute.
You
can
use
the
race
hand
feature
then
there's
chat.
We
are
encouraging
you
to
use
the
indie
chat
channel
instead
of
the
zoom
chat
channel,
and
that's
because
after
this
workshop
is
over,
that
indie
chat
channel
is
the
place
where
you
can
go
to
stay
in
touch
with
the
community
and
ask
questions.
You
know
the
zoom
chat
channel
will
go
away
when
the
workshop
is
over.
A
A
A
No,
no
I'm
set
yeah
feel
free
to
kick
off.
Okay,
awesome
well,
hello,
everyone
and
welcome
to
today's
workshop
of
hyperledger
indie
deep
dive.
My
name
is
james
schulte
and
I'm
vice
president
of
business
development
here
at
ndco,
and
we're
very
excited
to
host
today's
session
in
partnership
with
hyperledger
foundation.
So
a
big
thank
you
to
the
hyperledger
team.
A
The
work
that
the
open
source
community
is
doing
with
the
hyperledger
indie
is
playing
an
important
role
in
the
transition
from
traditional
identity
management
systems
towards
decentralized
identity
models.
Hyperledger
india
has
become
a
major
force
in
driving
the
adoption
of
decentralized
identity
or
oftentimes
called
self-sovereign
identity
or
ssi.
A
If
you
have
any
questions
or
or
need
help,
we
ask
that
you
take
those
questions
to
the
indie
channel
in
the
hyperledger
rocket
chat,
and
we
will
be
periodically
dropping
a
link
to
that
in
the
zoom
channel.
Here
in
the
prerequisites
that
you
were
provided
when
you
registered
for
this
course,
you
should
have
gotten
instructions
on
joining
the
indie
channel.
If
you
haven't
done
that,
yet
no
worries
go
ahead
and
use
that
link
and
you
should
be
able
to
get
on
that
pretty
quickly.
A
The
reason
we
ask
you
to
direct
your
questions
to
the
rocketchat
channel
is
so
that
these
questions
and
answers
that
are
given
today
can
act
as
a
resource
long
after
this
workshop,
and
if,
for
some
reason
you
won't
be
able
to
join
the
indie
channel,
feel
free
to
drop
them
and
zoom
and
we'll
do
our
best
to
get
to
those
questions.
But
we
have
members
of
the
indicio
team
who
will
be
monitoring
mostly
the
indie
channel,
but
we'll
we'll
do
the
best
to
handle
all
that
we
can
so
provided
on
screen.
A
Here
we
have
a
link
to
the
rocket
chat
channel
as
well
as
a
handout
that
will
be
used
during
the
hands-on
portion
during
the
workshop
today,
so
feel
free
to
use
these
qr
codes
to
access
those
feel
free
to
screenshot.
We
will
also
be
dropping
a
link
to
the
and
out
in
the
chat
as
well
so
yeah
as
mentioned
prior
to
today's
workshop.
You
should
have
been
provided
a
set
of
prerequisites,
but
if
you
haven't
done,
those
no
worries,
we're
have
we're
still
happy
to
have.
A
A
We
will
first
hear
from
sam
curran
who
will
talk
about
community
efforts
and
how
to
get
engaged
and
contribute.
Then
we
will
get
an
overview
of
the
indie
stack
by
adam
burdette,
after
which
he
will
discuss
the
ursa
cryptographic.
Library,
daniel
and
lynn
will
then
walk
us
through
the
nds
decay
and
after
that,
we'll
have
a
five
minute.
Five
minute
intermission
so
stand
up,
get
a
drink,
walk
around
then
we'll
come
back
and
lynn.
Ben
dixon
will
provide
instruction
on
network
management
and
then
adam
will
give
an
introduction
to
plenum
code.
A
We'll
have
another
five
minute
break
and
then
adam
will
lead
a
hands-on
portion
regarding
indie
node
code,
and
then
we
will
conclude
with
sam
and
daniel
discussing
the
future
of
hyperledger.
Indeed,
so
again,
we're
very
excited
to
have
you
here
today.
We
hope
that
this
is
a
very
valuable
time
for
you
and
and
helps
you
in
all
the
work
that
you're
doing
and
with
that
I'll,
go
ahead
and
hand
off
to
sam
curran
to
discuss
community.
C
Thanks
james
we're
glad
that
everyone
is
here,
I
I'm
going
to
take
a
couple
of
minutes
and
talk
about
engaging
with
the
community,
and
this
may
be
old
hat
and
very
familiar
to
many
of
you.
If
it's
helpful
to
to
some,
though,
then
it's
it's
worth
covering
to
to
help
us
along
and
to
help
you
be
familiar
with
how
to
engage
with
the
community
and
and
get
involved,
I'm
sam
curran,
I'm
an
architect
at
indicio.
C
I
am
telegram
sam
on
all
the
things
and
I'm
a
co-chair
of
two
different
working
groups
within
the
open
source
community
here
in
heifer,
ledger,
I'm
a
co-chair
of
the
aries
working
group
and
at
the
decentralized
identity
foundation.
I'm
a
co-chair
of
the
of
the
did
come
working
group
there,
so
a
bunch
of
experience
engaging
with
the
community
and
and
organizing
and
all
sorts
of
things,
and
so
I
hope
that
what
I
share
here
is
useful
to
you.
First,
some
some.
Why
engage
with
the
community
right?
C
We,
the
the
community,
is
made
by
the
people
who
join
it,
and
and
and
we
need
you
both
for
your
expertise
with
the
project,
but
also
in
in
life
and
circumstances
and
and
and
and
the
insights
that
you
can
provide.
I
want
to
highlight
that
this
is
not
just
for
developers.
We
love
developers,
of
course,
but
there's
often
work
in
user
experience
and
documentation
and
project
management
and
other
types
of
things
that
most
open
source
projects
can
benefit
from.
C
There's
three
main
projects
here
that
that
we
work
with
at
the
hyperledger
foundation,
we're
here
today,
of
course,
to
talk
about
indy
and
out
of
indy
there.
There
are
two
separate
projects
that
were
born
out
of
that
to
make
them
a
little
more
general
and
approachable.
One
is,
of
course,
hyperledger
aries
the
agent
side
of
things,
as
opposed
to
the
ledger
side
covered
by
indy
and
hyperledger
ursa,
which
is
a
cryptographic
library
that
contains
lots
of
the
the
cryptographic.
C
Primitives
are
useful
for
all
sorts
of
this
stuff,
and
so
those
are
the
the
groups
that
are
here.
There
are
other
groups
besides
hyperledger
that
are
involved,
and
we
wanted
to
highlight
a
few
of
those
and
what
they
do.
The
decentralized
identity
foundation
does
work.
The
did
come
working
group
is
there
for
vidcon
v2.
The
interoperability
working
group
is
often
has
really
engaging
discussions
about
various
topics
and
there
are
other
groups
as
well
working
on
identifiers
discovery
and
claims,
etc.
C
So
a
good
group
over
there
trusts
over
ip
is
another
such
group,
and
I
want
to
draw
some
attention
to
the
utility
foundry
working
group
of
which
our
own
lynn,
ben
dixon
is
a
is
a
co-chair,
and
so
they
do
a
lot
of
good
stuff.
They
also
have
a
really
cool
layer
model
that
they've
developed
that
helps
sort
of
explain
how
the
different
pieces
fit
in
in
different
places,
and
so
they
do
a
bunch
of
good
work.
C
Working
groups
generally
communicate
via
chat
is
very
common.
Today,
email
lists
are
still
active
and
and
carry
some
really
engaging
conversations,
and
then
most
working
groups
have
a
regular
call
of
some
kind
that
you
can
either
join
or
or
or
listen
to
later,
calls
are
generally,
where
lots
of
active
discussion
happens.
C
So
please
be
aware
of
the
policies:
lots
of
groups,
call
them
out
or
or
provide
links
to
those,
and
you
can.
You
can
be
familiar
with
them
and
if
there's
I'll
talk
a
little
bit
later,
but
if
there's
any
issues
with
these
or
something
that
is
not
being
followed
in
the
policy,
then
then
that's
worth
bringing
up
and
trying
to
to
find
a
resolution
to
most
calls
have
meeting
agendas.
Topics
are
almost
always
welcome.
Sometimes
the
the
next
few
calls
are
already
scheduled
in
advance
or
there's
invited
speakers.
C
But
if
you
want
to
talk
about
something
or
present
on
something,
then
that's
almost
always
welcome.
Different
calls
have
different
forms
of
interaction.
If
you
want
to
say
something
in
the
call,
sometimes
you
can
just
say
something.
Typically,
in
a
smaller
meeting,
larger
meetings
often
use
a
more
formal
mechanism
like
the
raised
hands
feature
in
in
in
zoom
or
they'll
have
a
cue
that
they
manage
with
the
chat.
C
Meetings
are
often
recorded,
which
is
super
handy
for
the
times
that
you
can't
be
present
or
you
have
a
conflict.
One
of
the
perks
of
watching
is
that,
if
you,
if
you
pick
a
player
that
has
this
feature
and
vlc
is
one
of
those
you
can,
you
can
play
back
the
meeting
in
faster
than
real
time
and
so
that
that
allows
you
to
get
caught
up
on
meetings
that
you
may
have
missed.
The
recordings
are
usually
posted
on
the
agenda
or
in
another
regular
place.
C
Most
groups
have
a
github
repository
that
they're
working
on,
given
that
this
is
open
source.
Not
all
the
repositories
are
code,
but
some
are
used
for
documentation
or
other
sorts
of
things,
but
there's
usually
one
there's
a
readme
file,
usually
in
the
root
with
some
meeting
info
and
sometimes
links
to
rendered
copies
of
the
repository
contents,
which
is
very
helpful.
C
It's
worth
getting
familiar
with
the
various
issues
and
and
and
to
contribute
to
the
resolution
of
those
issues
or
or
commentary
there.
You
can
view
pull
requests
before
they're
committed,
which
will
help
understand
the
changes
that
are
being
proposed
to
the
group's
work,
and
you
can
also
through
github
you
can
you
can
look
at
the
commit
history
and
see
what
changes
have
happened
recently.
C
If
you
want
to
contribute
your
code,
which
is
an
obvious
goal,
or
I
say
code
here,
this
also
includes
documentation,
changes,
etc.
You
want
to
mine
the
code
license
and
the
requirements
for
working
on
it
and
and
make
sure
that
those
are
are
compatible
with
the
work
that
you're
doing
most
of
the
work.
You
want
to
do
typically
on
a
repository
fork,
so
you
would,
you
would
fork
the
repository
and
then
create
a
branch
within
that
fork
for
your
contribution.
C
C
Then
after
you've
got
your
your
change
made
to
your
fork,
you
want
to
push
it
to
to
your
good
github
fork
and
then
open
a
pr
to
the
main
branch
on
the
original
repository,
and
that
makes
it
easier
to
update
or
adjust
your
pr
so
that
you
can
so
that
if
there's
any
changes
suggested
by
the
community
and
discussion,
it's
easy
to
make
pushing
code
back
is
how
the
whole
open
source
code
base
works.
And
so
that's
a
that's.
An
easy
thing
to
do.
C
C
We
particularly
need
that
if
you
don't
feel
like
you
fit
in,
we
unfortunately
sometimes
cultural
things
being
what
they
are
have
far
too
much
representation
in
some
areas
of
life
than
others
and
and
I'm
not
just
speaking
about
the
fact
that
we
tend
to
have
a
lot
more
developers
than
we
have
ux
for
designers
or
other
things
like
that.
Please
be
persistent
with
your
contributions
and
patient
with
others.
C
We've
all
got
stresses
in
life,
and
we
don't
all
handle
things
perfectly
in
the
moment
and
and
encourage
you
to
try
and
and
stay
and
and
work
through
any
issues
that
you
might
encounter.
That
is
not
an
encouragement
to
put
up
with
bad
behavior.
If,
if
there
is,
is
bad
behavior
happening
of
any
kind
in
in
groups,
please
engage
the
code
of
conduct
and
see
how
seek
help
from
the
leaders
in
the
community
and
others
around.
You
to
help
resolve
those
issues
so
that
the
real
work
can
go
forward.
C
We
need
you
and
I
hope
that
you
will
consider
jumping
in
to
to
the
community,
in
whatever
form
you
think
would
be
useful
or
helpful
to
you
and
and-
and
we
hope
that
that
turns
out
to
be
a
great,
a
great
thing
for
you
and
helps
build
the
communities
in
general,
so
that
wraps
up
my
my
brief
introduction
to
communities
with
that.
Our
next
speaker
is
adam
burdette
and
I
will
have.
I
will
go
ahead
and
hang
out
on
the
on
the
rocket
chat.
D
D
Some
of
my
original
contributions
have
been
in
actually
in
the
node.
I
helped
with
the
rich
schemas
and
the
developments
around
those
protocols
and
code.
I
also
have
helped
bring
the
transaction
author
and
adore
endor
taa
trans
transaction
author
agreement.
Pardon
me
into
being
getting
it
anchored
onto
the
ledgers.
D
D
Cloud
agent
python
occupy
I'm
a
plug-in
developer
for
that
and
if
you
guys
have
seen
the
universal
resolver
I
I
was
one
of
the
main
developers
on
that
project.
So
enough
about
me
that
little
spill
well
yes
to
accompany
this
session,
there's
a
handout
inside
the
handout,
there's
actually
instructions
that
we'll
use
in
the
hands-on
portion.
D
So
it's
it's
kind
of
important
for
later
to
look
at
that
and
also
to
make
sure
that
you've
gone
through
the
prereq
setup
and,
as
you
have
questions,
please,
please
go
to
rocket
chat
and
ask
them.
There'll,
be
people
that
are
gonna
answer
them
and
my
colleagues
have
been
instructed
to
catch
me
in
my
spot
on
the
slides.
If
I
miss
something
or
if
there's
a
big
question
asked.
D
All
right,
it's
my
pleasure
to
introduce
you
to
indy.
Now
james
did
a
really
good
job
introducing
indy
and
what
it
does.
I
want
to
make
sure
that
we
have
this
mental
model,
that
indy
is
an
identity
management
platform
device,
that's
decentralized
and
allows
credential
holders
to
interact
with
verifiers
without
gatekeepers,
and
so
that's
like
that's
kind
of
like
the
overarching
goal.
D
D
D
Ursa
was
created
because
people
in
hyperledger
community
realized
that
it
would
save
time
effort
and
improve
our
security.
If
we
all
collaborated
on
our
top
cryptographic
code
since
cryptographic,
apis
are
relatively
straightforward
to
define,
it
would
be
possible
for
many
different
projects
to
utilize
the
same
code
without
too
many
too
much
difficulty.
D
D
These
are
the
types
most
commonly
used
in
indie
for
the
keys
associated
with
dids.
We
have
bls
signatures
for
pairing,
friendly
curves.
This
is
used
for
multi-sig
on
ledger
transactions.
In
indy
we
have
the
cll
signatures
which
use
rsa,
which
are
the
basis
for
non-credits,
and
we
also
have
a
smear
secret
sharing.
D
Libris
exposes
a
c
callable
interface.
This
c
callball
interface
allows
any
language
that
supports
foreign
function,
interfacing
to
be
able
to
wrap
versa
and
use
it
natively
in
that
language.
It
also
exposes
a
rust
native
interface,
as
it
is
implemented
in
rust.
So
rest
developers
can
consume
the
crates
and
use
it
natively
as
well.
D
D
D
One
of
the
reasons
I
actually
call
out
zmix
because
I
don't
know
very
many
libraries
actual
projects
using
it
yet,
but
there
it
sports
bbs
signatures,
which
is
something
that
the
aries
community
is
starting
to
talk
about
incorporating
into
their
projects.
It
also
supports
ps
signatures
g
signatures.
D
D
B
B
You
might
remember
my
name
if
you
attended
the
aries
workshop
a
couple
weeks
back.
That's
definitely
more
my
area
of
expertise.
I
spend
more
time
in
aries
than
I
do
indie,
but
since
within
aries
we
consume
indie.
I've
had
a
lot
of
experience
working
with
the
indie
sdk,
especially
and
more
recently
getting
more
involved
on
the
ledger
side
of
things
within
indie.
B
Cool
so,
as
I
said,
we
are
going
to
be
talking
about
the
next
layers
up
in
the
stack
which
builds
on
top
of
versa,
and
this
is
broadly
termed
the
indie
sdk,
but
this
contains
live
indie
itself,
as
well
as
the
language
wrappers
that
utilize
the
vindi
and
expose
the
functionality
of
livini
to
aries
agents
built
on
top
of
them
I'll
go
through
a
quick
overview
of
the
sdk
project
as
a
whole.
I'm
also
going
to
talk
a
little
bit
about
the
architecture
of
the
india
sdk.
B
B
So
in
the
indie
sdk,
if
you
were
to
pull
up
the
project
repository
right
now
and
take
a
look
at
the
folders
that
are
in
there,
you'll
see
at
least
these
three.
There
are
several
more,
but
these
are
the
three.
I
wanted
to
really
focus
on
and
call
out
so
first
off
libendy-
and
this
is
the
actual
library.
The
c
call
rust
library
that
has
most
of
the
entering
interesting
stuff
of
the
indie
sdk.
B
The
library
is
then
consumed
by
rappers,
which
are
language
specific
wrappers
around
that
c
callable
library.
We
have
wrappers4.net
java,
ios,
node.js,
python
and
rust,
which
is
a
pretty
broad
coverage.
I
would
say
for
most
languages
that
people
are
using.
I
know
there
are
others
that
are
outside
of
the
indie
sdk
repo,
which
tends
to
extend
wrappers
within
the
repo
to
expose
functionality,
for,
for
example,
react
native,
I
think,
has
some
more
wrappers
for
indie
and
various
projects
out
there.
B
So,
to
elaborate
a
little
bit
more
on
these
wrappers,
if
you
were
to
go
and
actually
look
at
one
of
these
wrappers,
let's
say
python,
and
even
though
it's
the
the
main
point
of
interaction
that
your
application
will
have
with
the
live.
Indie
library,
you
are
actually
not
gonna,
find
too
much
within
those
wrappers.
It's
pretty
much
just
taking
the
idiomatic.
B
For
now,
it
strikes
me
that
I
didn't
actually
give
a
broad
definition
of
the
nd
sdk
so
I'll
back
up
a
little
bit
and
say
that
now
so
the
sdk
is
the
main
place
to
go
for
developing
applications
on
top
of
nd.
That
might
be
self-explanatory,
given
it's
an
sdk,
but
this
is
how
we
interact
with
the
indie
ledger.
This
is
how
we
also
create
and
interact
with
a
non-credits
credentials
using
the
indie
libraries.
B
B
In
fact,
there
will
be
things
called
ledger
that
aren't
going
to
be
exactly
what
I'm
describing
here.
So
this
is
mostly
conceptual
just
rough
groupings
of
functionality,
so
ledger
being
you
know,
being
able
to
communicate
with
the
ledger
and
all
the
various
interfaces
needed
for
that
wallet
being
the
secure
storage
aspect
of
the
nd
sdk,
so
how
we
hold
on
to
private
keys
in
a
way
that
protects
them
and
and
helps
prevent
misuse
of
those
private
keys
and
then
a
non-credits
so
being
able
to
issue
and
verify
and
non-credit's
credentials.
B
So
it
is
the
point
at
which
keys
are
created
and
stored,
and
then
it
also
serves
as
a
hub
for
crypto
operations
which
need
the
private
keys
stored
within
the
wallet,
and
this
allows
us
to
do
really
useful
things
like
making
sure
that
memory
is
zeroed
out
where
a
private
key
was
previously
stored
without
having
to
rely
on
the
layers
above.
The
nd
sdk
stack
where
it's
often
more
difficult
to
zero
out
memory
to
perform
that
the
india
sdk
wallet
helps
us
to
keep
private
stuff
private.
B
B
B
B
B
B
In
a
very
similar
fashion,
the
wallet
kind
of
serves
as
our
entry
point
for
nearly
everything
else
within
the
sdk.
Before
we
can,
you
know,
do
crypto
operations,
we
typically
need
access
to
private
keys
or
to
create
private
keys,
and
all
of
that
takes
place
within
the
wallet.
So
naturally,
we
first
need
to
open
a
wallet
to
perform
any
of
those
operations.
B
So
this
wallet
api
to
clarify
is
not
where
the
storage
is
actually
occurring.
If
you
were
to
go
and
look
at
the
wallet
module
within
the
india
sdk,
this
is
instead,
where
we
go
to
manage
the
wallet,
so
creation
open
and
close
delete
import
export,
so
the
full
wallet
life
cycle,
I
suppose,
is
represented
by
this
api.
B
This
module
also
contains
builders
for
the
various
transactions
on
an
indie
network
such
as
pool
or
excuse
me,
nim
pool
management,
non-grids
objects
and
we'll
get
into
a
little
bit
more
detail
on
those
different
transactions.
As
we
talk
about
ndnode
and
plenum,
and
such
excuse
me
within
the
ledger
api,
we
also
have
parsers
for
transaction
responses.
So
when
we
submit
a
transaction
to
the
ledger,
the
returning
value
is
not
binary.
It's
not
an
unreadable
format.
B
B
Using
the
did
api,
we
can
also
perform
key
rotation
of
the
keys
associated
with
the
did
so,
of
course,
very
important
when
keys
for
given
dad
are
compromised
and
then
other
apis
within
the
sdk.
Allow
us
to
publish
that
key
rotation
to
the
ledger.
If
it's
a
public
did
or
we
would
then
engage
in
a
protocol
with
our
connection,
to
inform
them
of
the
key
rotation.
Otherwise,
the
did
api
also
contains
some
helpers
for
storing
and
retrieving
metadata
about
a
did.
B
B
B
I
will
call
out
that
the
non-secrets
api
is
not
necessarily
something
that
we
should
be
using
for
just
all
application
data.
It
should
still
really
be
just
for
information
that
is
sensitive,
such
as
the
I'll
take
a
concrete
example,
just
to
speak
a
little
bit
more
precisely
and
aries
cloud
agent
python
as
we're
engaging
in
a
credential
issuance
protocol.
B
The
credential
issuance
records
that
we're
using
to
keep
track
of
that
protocol
will
contain
for
a
time
at
least
the
information
that
is
actually
issued
in
the
credential,
which
is
considered
to
be
generally
speaking
personally
identifying
information
about
the
recipient
of
the
credential.
So
that
would
naturally
be
something
that
we
would
want
to
store
securely
and
certainly
never
store
in
plain
text
anywhere.
B
So
the
non-secrets
api
helps
us
to
do
that.
This
is
also
a
an
interesting
point
here.
We
can
store
crypto
primitives
that
are
not
natively,
supported
by
indie
within
the
non-secrets
portion
of
the
api.
We
won't
get
the
nice,
you
know
zeroing
memory
and
and
all
the
other
key
hygiene
stuff
that
nd
provides
for
the
native
key
types,
but
it
is
still
you
know
being
able
to
store.
B
B
Okay,
so
this
is
a
diagram
pulled
directly
from
the
india
sdk
documentation
which
is
found
within
the
repo.
If
you
navigate
there,
there's
a
docs
section.
This
is
an
overview
of
the
architecture
itself,
so
less
abstractly,
as
I've
been
talking
about
it
and
more
of
what
you'll
actually
see
in
the
repo
in
the
rest
library.
B
B
So
this
is
following
the
command
design
pattern,
if
you're
familiar
with
that,
it
is
quite
thoroughly
executed
according
to
that
design
pattern.
So
if
knowledge
of
that
design,
pattern
will
certainly
help
make
contributions
to
the
indie
sdk,
but
will
also
help
us
to
locate.
You
know
what
is
happening
when
I
make
this
call
from
the
wrapper
to
be
able
to
follow
it
down
the
stack
yeah.
B
B
This
is
served
us
well
to
have
all
this
within
the
same
repository
in
the
sdk.
It's
a
one-stop
shop
for
everything
which
fits
great
if
you
are
coming
into
the
indie
ecosystem,
full
on
ready
to
dive
deep,
where
it
is
not
quite
as
helpful
is
in.
If
you
want
to
only
communicate
with
the
ledger,
you
can't
really
do
that
without
pulling
in
everything
else,
so
wallet
and
non-credits
would
have
to
come
along
with
it
in
order
to
do
that,
ledger
communication
bit
same
with
the
wallet.
B
We've
come
to
realize
that
having
more
modular
components
would
be
extremely
helpful
and
I'll
call
out.
Bcgov
government
of
british
columbia
and
their
team
they've
definitely
been
pioneering
in
this
andy
shared
library
project,
so
a
huge
shout
out
to
them
and
all
the
work
that
they've
been
doing
there
have
been
others
from
the
community
as
well,
don't
want
to
minimize
their
contributions
but
yeah.
B
B
B
B
B
Component
to
something
that's
just
generally
within
aries-
and
this
is
a
secure
storage
library
which
is
very
heavily
inspired
by
the
indie
sdk
wallet,
so
it
behaves
similarly.
Similarly,
in
that,
you
know,
it
helps
us
store
secrets
and
also
non-secrets,
so
just
arbitrary
data
that
we'd
like
to
keep
secure,
but
it
also
presents
a
slightly
more
permissive
approach
to
granting
access
to
secrets
within
the
hyperledger
areas.
B
I
don't
necessarily
have
numbers
right
in
front
of
me,
but
anecdotally,
it's
so
fast
that
people
are
actually
experiencing
problems
with
the
speed
and
their
older
systems
that
were
geared
to
the
speed
of
india
sdk
not
being
able
to
keep
up
so
aries.
Ascar.
We're
really
excited
about
both
the
performance
improvements,
as
well
as
the
improved
api
and
access
to
secrets
as
we
go
forward
within
the
aries
ecosystem.
E
Thanks
daniel,
my
name
is
lynn
bennickson,
I'm
the
director
of
network
operations
in
dco,
and
you
can
find
me
at
the
atlanta
bendixson
and
almost
all
the
chat
places
that
you
can.
You
can
find
in
the
community
and
as
sam
mentioned
earlier,
I
just
recently
got
named
as
the
co-chair
of
the
trust
over
ip
utility
foundry
working
group.
E
That
working
group
is
is
one
that
helps
to
create
standards
for
public
utilities
and
help
give
resources
and
stuff
for
people
who
would
like
to
to
create
their
own
public
utilities.
So
it
can
also
help
with
private
utilities
and
that
sort
of
thing,
but
that's
the
that's
what
the
utility
foundry
working
group
does
at
the
tip,
I've
been
working
in
ssi,
decentralized
identity.
E
For
about
three
and
a
half
years
now
I
started
helping
with
the
sovereign
networks
and
and
now
I'm
helping
in
dco
do
the
same
thing
build
and
manage
public
and
private
networks
is
kind
of
what
I
do
in
as
my
main
operation
at
indicio.
So
that's
me
essentially
one
of
the
experts
in
the
the
field
of
indian
networks.
E
So
what
the
purpose
of
what
I'm
going
to
do
here
today
is
tell
you
a
little
bit
more
about
the
ndcli
first
and
and
then
we'll
have
a
break
and
then
and
I'll
move
into
some
more
in-depth
stuff.
But
the
reason
that
we're
going
to
go
into
a
little
bit
about
the
ndcli
is
to
to
give
you
some
of
the
background
and
information
that
you
need
to
be
able
to
understand
better
how
the
whole
network
works
and
what
part.
E
Those
things
are
important
if
you're
gonna
know
anything
about
indie
note
and
how
it
works,
so
we're
giving
you
these
preliminary
background
information,
essentially
to
help
you
understand
where
we're
coming
from
and
we're
trying
to
do
it
in
a
good
order,
but
feel
free
to
ask
questions.
If
there's
this
things
that
are
confusing
and
we'll
we'll
plow
forward
here
as
best
we
can,
let's
see
if
I
can.
E
E
E
Sorry,
a
text-based
tool,
not
a
gui
tool,
other
you
can
make
gui
tools
and
use
the
sdk
to
to
build
those
things,
but
the
the
tool
that
comes
with
it
is
just
text
based
so
and
it's
not
too
hard
to
use
and
it's
pretty
easy
to
install
and
I'm
not
gonna,
follow
this
link
here
or
just
refer
you
to
once
again
to
the
handout.
I
believe
this
link
is
in
the
handout.
E
The
installation
is
pretty
simple
and
if
you
go
to
the
the
last,
the
presentation
that
we
did,
I
included
a
link
to
that.
As
an
answer
to
one
of
marius's
question
in
the
in
the
chat,
we
have
a
lot
more
details
on
how
to
install
the
the
cli
there,
so
I
won't
go
into
detail
on
that,
but
we'll
just
refer
to
it,
and
so
you
have
a
link
there
and
you
can
do
that
before
we
get
into
explaining
very
much
about
what
the
cli
does.
E
One
of
the
first
things
that
you
do
after
you've
installed
the
cli.
Is
you
download
a
genesis
file
and
in
this
case
it's
a
pool,
genesis
file
and
it's
the
thing
that's
used
to
to
connect
you
to
the
network.
All
the
clients
need
to
use
that
file
to
connect
to
the
network,
and
so
I'll
tell
you
a
little
bit
about
what
a
genesis
files
is
they're.
They
are
the
files
that
are
created
before
a
network
is
instantiated
and
they
include
the
pool.
E
Usually,
when
I
create
a
network,
I
just
do
four
because
that's
kind
of
the
minimum,
and
so
I
do
four
nodes
in
the
genesis
file,
and
that
means
that
you
know
we
don't
have
a
lot
of
them
that
we
have
to
deal
with
and
then
you
can
add
more
nodes
to
a
network
later.
So
I
create
it
with
the
minimum
number
and
then
add
more
notes
later,
because
the
the
genesis
nodes
are
ones
that
really
need
to
stay
there
for
the
the
life
of
the
network.
E
E
So
I
keep
saying
some
terminology
thinks
it
might
be
difficult
to
understand
because
we
kind
of
interchange
some
of
the
words.
So
let
me
take
just
a
minute,
and
I
tell
you
that
a
lot
a
lot
of
the
slides
we
have
today
will
refer
to
connecting
to
the
ledger
or
connecting
to
the
network
and
when
we
say
those
two
words,
we
pretty
much
mean
the
same
thing.
E
The
ledger
is
the
network
and
the
ledger
is
a
compilation
of
many
sub-ledgers,
the
the
two
main
ones
being
the
pool
ledger,
which
is
the
list
of
all
of
the
nodes
that
are
in
the
pool
or
the
network
right
these.
These
terminologies,
we
kind
of
use
them
and
interchange
them,
and
hopefully
you
can
get
used
to
it.
E
As
we
talk
about
it
and
understand
what
we're
saying
but
feel
free
to
ask
again
in
the
chat
or
on
the
the
indie
rocket
chat
to,
then
we
can
help
you
understand
it
a
little
better
if
it's
confusing,
so
the
genesis
files
are
static.
When
you
add
a
node
to
a
ledger,
you
don't
change
the
genesis
file.
The
genesis
file
will
stay
the
same
throughout
the
life
of
the
ledger
in
most
cases.
E
E
E
So
you
run
these
commands
to
create
a
pool.
This
is
the
genesis
file
that
I
was
talking
about.
Usually
you
can
download
that
from
the
network
somewhere
and
I'll
show
you
where
an
example
of
some
some
of
those
files
in
in
a
little
bit
later,
the
if
you're
running
your
ndcli
from
a
place
where
this
isn't,
then
you
need
to
put
the
whole
path
here,
so
you
might
need
the
whole
path
to
this
genesis
file.
E
Just
a
couple.
Little
gotchas
as
we
go
along
here,
the
wallet
command
is
this
key
here
is
really
just
a
password
for
your
local
wallet.
The
this
wallet
create,
creates
a
place
to
store
your
dids
and
your
keys
for
those
dids
and
other
things
like
schemas
and
credential
definitions
and
those
sorts
of
things.
All
the
keys
for
those
things
will
be
in
your
local
wallet.
So
you
need
to
be
careful
that
you
either
back
that
up
or
keep
track
of
those
keys
in
the
way
that
that
you
don't
lose
them.
E
E
So,
once
you've
created
a
pool
and
opened
up
your
wallet
or
connected
to
a
pool
and
opened
up
a
wallet,
then
you
need
to
put
some
dips
in
it,
and
so
this
is
the
command
for
creating
a
new
did,
and
I
added
the
seed
command
on
this
one.
Unlike
the
the
last
presentation,
I
did
because
this
seed
is
what
allows
you
it's
a
32
character,
seed
that
allows
you
to
put
the
same
did
into
different
wallets.
E
So,
if
you're
like,
if
you're
a
company
that
has
a
steward-
and
you
have
you're
the
main
node
operator-
and
you
have
a
a
backup,
node
operator-
and
both
of
you
need
this-
you
can
both
use
the
same
seed
for
your
steward
did
and
both
will
be
manage
your
own
node,
for
example,
so
we'll
get
more
into
what
a
steward
is
and
trustees
and
that
sort
of
thing
in
just
a
little
bit.
Also
so
don't
worry
about
that
and
then
to
be
able
to
do
any
of
the
commands
on
the
ledger.
E
You
need
to
use
that
did
or
activate
it.
That's
what
the
use
thing
means
is
to
make
it
so
that
that
did
is
now
the
active
did
and
you're
using
that
to
do
your
commands
on
the
ledger
and
I
think
that's
it
for
a
good
start
here,
we're
ready
for
a
little
break.
My
watch
says
10
after
the
hour
should
we
come
back
at
20
after
what
do
you
think
james.
E
E
So
what
does
that
mean
when
we
say
network
management
essentially
you're
talking
about
the
configuration
and
administration
of
a
hyper
ledger?
Indie
network?
Okay?
So
as
it
says
on
the
slide
here,
every
instantiation
of
a
hyperliterary
network
should
have
governance
documents
that
go
along
with
them,
even
if
you're
just
doing
a
private
network,
you
should
you
should
think
about
how
you
want
your
network
to
be
governed
so
that
the
users
of
your
network
have
some
confidence
that
you're
that
you're
is
configured
and
maintained
in
a
way
that
they
feel
comfortable
with
it.
E
But
the
the
network
administrator
needs
to
configure
at
least
production
networks
right.
You
need
to
configure
your
production
networks
to
to
make
it
so
it
it
matches
the
governance
and
is
more
secure
and
we'll
we'll
dig
into
to
what
that
means.
Here
as
we
go
along
so
before
we
dig
in
too
much
further,
we
need
to
talk
a
little
bit
about
the
roles.
E
Training,
where
we
talk
a
little
bit
more
about
roles
and
go
into
a
lot
of
detail,
but
here
we'll
cover
just
kind
of
a
high
level,
and
then
hopefully
it's
it's
it's
enough
here
that
we
can.
We
can
continue
on
without
spending
a
lot
of
time
on
it,
but
you
know
at
a
high
level
here
the
the
trustees
are,
the
administrators
of
the
network.
E
The
trustee
role
runs
all
of
the
administrative
type
transactions
for
the
ledger.
They
do
the
node
management,
the
nim
management
nim,
that's
another
one
of
those
words
we
use
because
that's
what
is
called
on
the
ledger
itself.
Those
are
the
commands
we
use,
but
those
are
essentially
dids,
so
nim
and
did
or
interchangeable
terminology
wise.
E
Oh,
I
forgot
to
mention
the
roles
on
the
network.
Are
these
ones
right?
These
are
the
roles
that
exist.
You
can
actually
set
up
your
auth
rules
to
make
it
so
that
each
one
of
these
is
different
right.
The
way
the
auth
rules
are
set
up,
the
authentication
rules
determines
what
these
roles
can
and
can't
do.
E
So
you
can
everything
that
I'm
saying
here
about
what
these
roles
are.
Are
the
roles
the
these
names
have
on
in
the
governance
frameworks
that
are
the
ones
that
I'm
most
familiar
with,
so
the
sovereign
and
in
dco
governance
frameworks
are
the
way
that
I'm
talking
about
these
roles
and
again,
but
you
can
set
them
up.
E
However,
you
want
it's
a
it's
a
configurable
for
the
most
part,
maybe
not
entirely,
but
the
you
know
the
the
things
that
these
guys
can
do
is
determined
by
off
the
rolls
and
we'll
talk
about
that
more
in
just
a
minute,
but
on
the
governance
frameworks
that
I
deal
with
the
steward
only
deals
with
his
own
node.
He
can
add
or
remove
his
own
node
from
the
network
and
look
at
the
what's
called
validator
info
for
his
node.
E
E
E
E
E
They
they
can't
do
as
much
as
a
steward
does
with
adding
removing
nodes.
They
just
get
information
about
the
current
status,
so
I
saw
a
question
in
the
chat
that
says
what
is
validator
node
remember
when
we
were
talking
about
a
pool
thanks
for
the
question
by
the
way,
that's
an
excellent
question.
We
were
talking
about
a
pool
and
we
said
there
was
a
bunch
of
nodes
on
the
network
in
the
pool.
That's
what
a
validator
node
is
it's
just
one
of
those
nodes.
It's
all.
E
E
Okay,
so
now
that
we
have
the
a
little
bit
of
background
on
what
the
roles
are,
we
can
start
talking
about
what
the
some
of
the
things
that
the
trustee
can
do
and
the
actions
that
they
can
perform
and
the
configurations
that
they
need
to
do
right.
So
one
of
the
first
things
that
a
trustee
needs
to
should
do
on
a
a
public
production
network
is
to
build,
what's
called
a
transaction
author
agreement
or
taa.
E
And
so
essentially,
when
a
network
has
this
transaction
author
agreement
set
up
on
it
and
then
enforced,
then
every
time
you
get
when
every
time
you
want
to
write
to
the
network,
you
have
to
do
some
level
of
agreeing
to
it
and
then
the
way
you
agree
to
it
is
also
has
to
be
written
to
the
ledger.
The
possible
ways
of
agreeing
to
it
are
in
the
acceptance
mechanism
list
or
aml.
E
E
E
There's
two
steps
to
setting
that
up
on
your
network
and
the
first
one
is
to
to
build
and
post
this
acceptance
mechanism
list,
and
so
we'll
just
show
you.
What
one
of
those
looks
like
up
here
at
the
top
is
to
the
basic
thing
that
goes
on
the
network,
so
you
can
see
what
it
is
and
then
it
gives
you
in
this
document
it
gives
you
some
of
the
descriptions
about
what
each
one
of
those
is
and
then
we
don't
have
time
to
go
through.
E
What
I
will
say
quickly
is
that
usually
in
the
ndcli,
we
use
four
session
so
right
when
you
start
up
your
ndcli
and
you
connect
to
a
pool
it
will.
If
you
have
this
four
session
thing
set
up
in
your
config
file
for
ndcli,
then
it
will
show
you
the
the
taa
and
then
ask
if
you
want
to
agree
to
it
or
not,
so
the
ndcli
has
a
as
a
way
in
it.
E
E
An
enterprise
corporation
that
has
a
client
and
they
sign
a
service
agreement.
They
say
they'll,
never
write
anything
bad
to
the
network
at
the
beginning,
then,
inside
your
code
you
can
say
they'll,
they
sign
the
service
agreement
and
then
they
don't
have
to
keep
signing
it
over
and
over
again,
like
we
do
for
the
cli.
So
there's
that's
just
a
small
example
of
that.
So
and
then
I'll
show
you
the
taa
here
really
quick.
E
That's
the
that's.
What
I
wanted
to
show
you
there,
maybe
an
intro
to
ta.
Now
we're
going
to
talk
just
a
little
bit
about
how
to
write
that
to
the
ledger.
There
is
a
document.
I
hope
that
I
put
that
on
the
in
the
handout.
So
you
can
see
it,
but
I
wanted
to
show
you
that
how
putting
it
on
the
ledger
is
very
simple:
there's
just
two
commands
the
first
one.
E
Is
this
ledger
transaction
acceptance
mechanisms
command
and
then,
after
that,
you
just
copy
in
the
acceptance
mechanism
list
that
you
saw
on
the
other
page
and
then
you
give
it
a
version
number
and
something
else.
So
this
document
makes
it
super
easy
because
you
can
just
cut
and
paste
this
kind
of
stuff
and-
and
it
has
this
context
here
where
it
actually
gets
that
exact
file
from
or
it
has
a
link
to
the
that
file.
I
was
showing
you
on
in
github.
E
So
that's
what
this
context
thing
is
here
and
then
to
add
the
transaction
author
agreement.
First,
you
download
it
and
then
say
file
equals
because
it's
too
huge
to
actually
copy
in
like
this
other
one,
but
there
is
a
kind
of
a
funny
thing.
I
wanted
to
explain
really
quick
here.
So
when
you're
setting
up
your
taa
you'll
you'll
use
this
ratification.
Timestamp
thing
when
you
first
set
it
up.
E
Sorry,
I
needed
a
quick
drink
break
there,
so
this
ratification
timestamp
is
just
a
unix
timestamp.
That
says
when
that
new
taa
was
approved
by
whatever
board
of
approval
needed
to
approve
it
for
your
network.
Okay,
so
you
put
that
in
there
when
you
first
start
this
retirement
timestamp,
I'm
sorry
this!
This
is
the
command
you
can
use
to
get
some
more
help
on
how
that
works
and
what
it's
all
about
it
gives
you
some
examples,
but
I
just
wanted
to
bring
up
these
timestamp
things,
because
it's
a
little
bit
weird
how
it
works.
E
E
E
Hey
you've
got
a
new
taa.
You've
got
45
days,
two
months
to
to
move
to
the
new
one,
but
both
of
them
will
work
in
the
whole
in
the
meantime,
so
you
don't
have
this
hard
stop
of
okay,
everyone
has
to
change
their
code
at
exactly
the
same
time.
Does
that
make
sense,
so
the
retirement
timestamp
says:
okay,
we're
gonna,
put
the
new
one
on
and
then
we'll
give
you
45
days
or
two
months
or
whatever
to
to
switch
over
to
it
before
the
old
one
goes
away,
so
they
can
change
at
their
leisure.
E
Somebody
asked
a
question
in
the
in
the
chat
eduardo
the
retirement
timestamp
is,
is
put
on
later.
You'll
rerun
the
same
command
as
when
you
first
put
the
transaction
author
agreement
on
it
when
you
already
have
a
new
one
on,
so
you
put
your
new
one
on
the
second
say,
we
have
you
put
the
first
one
on
and
you
save
the
command
that
you
used
when
you
did
it
and
then
run
that
same
command
and
add
retirement
timestamp
on
it
after
you
put
the
second
one
on
the
ledger.
B
E
E
E
E
E
E
E
Okay,
the
auth
rules
that
you
set
up
should
be
based
on
what
you
see
in
the
governance
framework
for
your
network.
The
governance
framework
needs
to
be
set
up
in
a
way
that
it
defines
how
you
know
how
many
signatures
and
who's
in
control
and
how
to
do
these
sorts
of
things,
especially
for
a
public
network
that
is
a
production
network.
So.
E
E
Writing
of
something
to
the
ledger
and
the
each
row
is
a
different
one
and
there's
50
some
odd
rows
and
that's
all
the
ones
you
can
do.
You
can't
go
and
add
to
the
auth
rules
table.
For
example,
some
of
you
may
have
seen
online
that
there's
not
thrills
table
and
it
feels
like.
Oh,
I
need
I
want
to
add
a
new
author.
E
Well,
unless
you
go
and
change
the
code
and
make
it
so
there's
a
different
way
to
add
something
else,
the
then,
then
there
isn't
any
more
things,
and
so,
when
you
add
sorry,
when
you
change
one
of
the
auth
rules,
you
don't
add
any
authors.
We
just
change
them
when
you
change
one
of
the
auth
rules
to
adjust
how
many
signatures
it
requires
for
that
action.
E
These
first
five
rows
here
are
static.
You
just
put
all
of
those
on
the
command
line,
and
then
this
is
the
thing
that
you're
changing
the
the
constraint
for
that
particular
command.
Okay,
so
each
command
is
depicted
by
using
these
five
different
values
for
it.
So
this
first
one
here
we're
trying
to
add
a
nim
which
is
a
did
again
we're
trying
to
add
a
did.
E
E
So
this
row
is
add
a
new
trustee
to
the
network,
and
this
old
value
is
dash
here
and
in
the
in
the
command
you'll
see
later
that
that
will
become
a
star,
because,
if
you're
adding
a
new
one
using
the
add
command,
it
doesn't
exist.
It's
not
there
right
now,
so
so
we're
going
to
add
a
did
to
the
ledger,
and
that
did
is
going
to
be
a
trustee.
E
E
E
E
So
it's
maybe
a
little
bit
small
apologies
for
how
small
it
is
here,
but
we
scroll
up
to
the
top
of
that
command,
and
we
see
that
thing
I
was
showing
you
in
the
on
the
slide.
That's
the
first
one
of
those
and
you
see
also
that
there's
a
whole
bunch
of
them.
Like
I
mentioned,
and
each
one
of
these
corresponds
to
a
a
row
in
the
off
rule
table
and
each
row
is
a
different
command
that
can
be
performed
on
the
ledger
right
and
then
and
like
I
said
these
don't
change
it
just.
E
This
is
how
you
refer
to
this
row.
So
if
you
want
to
change
how
who
can
add
a
steward
did
to
the
ledger,
then
you
would
go
over
here
and
you
would
change
that.
If
you
wanted
stewards
to
be
able
to
add
other
stewards,
then
you
would
put
over
here
a
two
and
put
another
number
here.
So
let's
see
three
stewards
can
add
another
steward.
Then
you
would
change
this
to
a
two
and
this
to
a.
D
E
E
E
So
essentially
this
just
lists
all
of
them
and
says
that
anyone
can
add
an
attribute
to
their
own
did
and
all
the
schema.
One
is
just
like
that,
other
one
where
you
have
to
be
an
endorser
or
a
trustee,
and
this
is
not
how
it
looks
on
the
main
net,
I'm
pretty
sure
only
an
endorser
can
add
a
schema
when
we're
on
the
main
net.
E
E
Version
number
etc.
So
there's
the
credential
definition
stuff.
So
as
we
go
down
through
here,
you
see
some
of
the
some
of
the
commands
that
people
can
run
and
here's
our
some
of
our
pool
commands
we'll
talk
about
those
a
little
bit
more
in
just
a
minute,
but
the
people
who
can
do
pool
commands
are
just
the
trustees
and
again
on
the
main
net.
All
of
these
all
these
have
three
signatures
on
you.
E
E
What
we'll
do
is
we'll
I'll
switch
back
and
forth
a
little
bit,
so
you
can
see
that
we
filled
in
the
action
field.
The
example
I'm
showing
here
is
is
exactly
the
from
here,
so
the
action
field
has
an
ad
on
it.
Here,
it's
a
roll
field,
a
nim
type,
all
of
those
have
to
match
and
and
like
I
said
earlier,
the
the
dash
and
it
needs
to
be
a
star
when
you
send
the
command
in
so
all
of
those
commands
match,
and
then
you
can
change
this
constraint.
E
The
part
you
change
is
this
part
right
here
to
say
how
many
can
do
that
particular
action.
So
this
these
define
the
thing
that
you
want
to
do
on
the
network.
So
if
you
want
to
add
a
trustee,
this
is
the
constraint
for
it,
and
so
this
one
actually
changes
it
from
what
it
said
in
the
last
slide,
one
trustee
now
you
have
three
trustees
required
to
do
it.
If
I
were
to
send
this
command,
then
three
trustees
would
be
required
to
add
a
new
trustee
to
the
network.
E
Okay,
so
now
that
I've
told
you
it
takes
three
signatures
to
do
something.
I
thought
I
should
tell
you
a
little
bit
about
how
to
add
signatures
to
a
transaction.
How
do
you
create
a
transaction
and
then
and
get
multiple
signatures
on
it
in
the
ndcli,
and
this
is
the
command
right
here.
Essentially,
you
add
a
send
equals
false
to
the
end
of
your
normal
command.
So
this
is
adding
a
pretended
did
serve
longer
than
this
and
the
keys
are
longer.
E
But
I
shortened
it
to
refer
to
the
example
here,
so
we
have
a
did
and
a
ver
key
with
a
rollup
trustee.
Okay,
this
is
the
command
that
we
just
changed
and
then
we
put
in
send
equals
false,
and
what
that
does.
Is
it
spits
out
a
transaction
to
the
screen
that
you
can
then
send
to
the
people
who
need
to
sign
it?
E
So
if
you're
a
trustee-
and
you
run
this-
then
your
signature
will
be
on
the
transaction
and
you
need
to
send
it
to
two
other
trustees
to
get
them
to
sign
it
and
you
can
actually
send
it
at
the
same
time
to
both
of
them
and
then
combine
the
resulting
signatures.
Just
add
them
to
the
signature
list
list.
E
When
they've
signed
it-
and
this
is
the
command-
you
tell
them
to
do
say-
hey
run
this
command
on
your
thing.
Ledger
sign,
multi
transaction
equals
the
result
of
this
one,
and
then
they
return
that
to
you
and
their
signature
is
in
there
and
as
an
administrator,
you
can
then
combine
the
signatures
and
send
the
transaction
to
the
ledger
and,
and
it
becomes
whatever
it
is
you
needed
to
send.
So
that's
the
sign
multi
for
the
ndcli
and
then
a
few
other
things
that
administrators
need
to
do
is
they
need
to
be
able
to.
E
B
E
E
E
So
I
give
you
it
gives
you
an
example
of
adding
a
node
to
the
ledger
here,
where
you
have
a
target,
which
is
the
which
came
from
running
init,
indie
node
on
your
node
and
then
a
node
ip
import,
a
client,
ip
import
and
alias
make
sure
you
use
the
same,
alias
everywhere.
That's
a
little
gotcha.
If
you
use
a
different,
alias
that
causes
all
kinds
of
troubles,
because
that
alias
name
is
used
in
directory
names
and
stuff
and
then
services
equals
validator
is
what
turns
on
your
node
as
a
validator.
E
So
if
we
were
doing
a
demotion,
we
would
say
removing
it
from
the
ledger:
we'd
say:
services
equals
blank
and
then
so.
This
is
adding
a
node,
though,
when
you
add
it
usually
you
set
it
up
as
a
validator
and
then
you
have
to
use.
Do
your
vls
key
and
your
vls
key
pop
to
to
get
it
on
the
ledger
and
then,
if
you
want
to
just
change
the
second
example
here
is
changing
the
node
ip
and
the
client
id.
E
E
And
then
there's
also
another
command
called
pool,
dash
restart,
and
you
just
list
the
aliases
of
the
nodes
that
you
want
to
restart
a
lot
of
times.
A
node
will
start
having
some
troubles
and
a
lot
when,
as
an
admin,
I
will
just
go
out
and
do
ledger
pool
restart
with
the
node
name
to
see.
If
that
fixes
it
and
about
half
the
time
it
does
as
sometimes
it
just
needs
a
little
restart
to
get
things
going.
E
So
we
talked
about
this
kind
of
just
started
repeat
slide
here.
We've
talked
a
little
bit
about
network
management
and
why
we
need
it
and
then
the
taa
and
the
auth
rules.
We've
spent
a
long
time
on
that,
because
it's
a
little
confusing
happy
to
answer
more
questions
on
that
and
we
also
talked
about
network
maintenance
and
and
what
some
of
the
roles
do
and
and
how
they
all
work.
Hopefully
you
get
a
little
bit
of
terminology
background
and
understanding,
as
you
dig
into
indie
node
to.
E
So
if
you,
if
you
only
have
four
in
there
and
you
lose
one
that
might
be
okay
once
you've
lost
two
or
three
though-
and
you
only
have
one
genesis-
node
left,
it
might
be
a
delay
for
the
client
to
be
able
to
connect
to
it.
So
the
initial
nodes
should
remain
as
constant
as
you
can,
and
it
makes
for
a
having
a
rough
time
if
they,
if
they
don't
so.
E
E
B
Yeah
I'll
briefly,
add
anecdotally
to
lynn's
answer
there
about
the
genesis
notes
being
offline.
There
was
a
period
of
time
in
the
development
of
aries
cloud
agent
python.
Actually
I
think
it
was.
It
went
all
the
way
back
to
the
indie
sdk,
but
an
error
would
be
displayed
if
it
failed
to
connect
to
one
of
the
genesis
nodes
and
for
the
sovereign
builder
net
there
were
a
few
nodes
that
had
been
decommissioned
or
something
along
those
lines.
B
B
B
I
will
say
that
I
am
not
a
cryptographer,
nor
do
I
play
one
on
tv,
so
I
cannot
claim
to
be
an
expert
on
the
the
topics
brought
up
here,
but
I
I
know
at
least
enough
to
share
my
knowledge
and
I
might
rather
than
answering
questions
directly
direct
you
to
better
resources
than
myself.
So
hopefully
that's
adequate
to
answer
the
questions
that
come
up
today.
Hey.
B
B
So
hyperledger
indieplenum
is
a
python
project.
It's
written
in
python
and
according
to
its
own
project,
description
is
a
byzantine
fault,
tolerant
protocol.
So
what
that
means-
and
some
more
words
is
that
it
provides
a
framework
for
consensus
which
is
specialized
for
identity
systems,
and
this
is
what
we
are
using
within
hyperledger
indian
networks
for
consensus.
B
This
is
a
actually
a
question
that
was
brought
up
in
the
chat,
but
it
was
a
really
good
one
and
stephen
curran
actually
happened
to
answer
off
the
cuff.
I
don't
even
think
he's
currently
attending
this
workshop,
but
he
had
a
really
good
answer,
so
a
contrast
between
hyperledger
and
the
and
hyperledger
fabric.
Briefly,
so
the
question
was
raised.
B
B
B
B
So
plenum
uses
our
bft
as
the
consensus
algorithm
that
stands
for
redundant
byzantine
fault,
tolerance,
I'll
talk
a
little
bit
more
about
that
in
a
moment,
plenum
communicates
via
curve
cmq,
which
is
a
encrypted
version
of
the
zero
mq
protocol.
However,
plenum
also
provides
abstractions
for
implementing
other
communication
protocols.
If
you
are
interested
in
doing
that,
all
production
deployments
of
indie
today
are
just
using
the
box
standard,
built-in,
curves
emq,
but
there's
opportunities
for
other
communication
protocols.
B
State
storage
within
plenum
is
handled
by
a
python
implementation
of
ethereum's,
patricia
tri
data
structure
and
then
the
actual
data
itself
is
stored
using
a
key
value
store.
I
believe
there's
support
for
everything
from
in-memory
to
I'm
blanking
on
some
of
the
other
implementations
that
I
saw
in
there.
But
level
db
is
what
is
used
most
commonly
in
production
deployments
today,
specifically
roxtv.
If
I'm
not
mistaken,
is
that
right
adam?
Let
me
let
me
clarify
that.
B
So
there's
a
good
question
in
the
chat
here
that
I'll
briefly
address
so
can
nd
be
used
in
place
of
digital
signatures
and
data.
Signing
encryption
decryption
so
indy
as
a
stack
is
a
ledger
designed
to
support
a
decentralized
identity
ecosystem,
so
building
with
the
ids
or
decentralized
identifiers
which
have
keys
associated
with
them
through
a
did
document.
B
Inside
of
that
did
document,
you
can
have
any
number
of
keys
and
specialize
those
keys
to
one
use
case
or
another,
such
as
this
key
will
be
used
for
signing.
This
key
will
be
used,
for
you
know
a
symmetric
encryption
key
derivation
process
as
opposed
to
putting
the
symmetric
encryption
key
directly
in
the
dit
dock,
of
course.
B
So
it
to
answer
your
question.
In
short,
indy
has
crypto
primitives
associated
with
the
objects
you
can
use
and
create
with
indy
to
do
signing
encryption
and
decryption.
So
it's
pretty
flexible
in
that
sense
to
expound
on
that.
A
little
bit
more
verifiable
credentials
which
andy
supports
through
the
anon
credits,
credentialing
system
used,
cl
signatures
or
communicate.
B
There's
a
good
question
in
the
chat
I'm
going
to
direct
you
to
rocket
chat
for
that
one.
So
can
the
master
secret
be
accessed
the
nearest
car,
so
I
think
adam
can
assist
a
little
bit
in
in
that
in
rocket
chat.
Okay,
so
coming
back
to
plenum
to
round
off
the
last
thing
I
just
said:
data
storage
is
handled
by
level
dvd
in
production
networks
rocksdb
more
specifically,.
B
So
what
is
a
consensus?
Algorithm
I'll
start
again
with
another
disclaimer
that
again,
I'm
not
a
complete
expert
on
all
things
consensus.
There
is
a
huge
amount
of
academic
papers
on
this
subject,
so
I
will
not
pretend
to
be
in
that
space
in
terms
of
research
and
description
of
these
consensus
algorithms.
B
So
we
have
peers
who
are
collaborating
in
order
to
determine
what
truth
is,
and
I
put
truth
in
in
quotes
there,
because
it
is
a
process
determined
by
what
the
whole
group
agrees
upon
by
a
majority
and
these
consensus.
Algorithms
are
designed
to
prevent
bad
actors
from
injecting
values
into
the
network
that
are
considered
false,
at
least
by
consensus,
to
recursively
use
some
terms
here.
B
So,
ultimately,
it
is
through
these
consensus,
algorithms,
that
we
achieve
a
decentralization
of
what
is
truth
so,
rather
than
just
having
one
centralized
authority
where
all
parties,
except
the
central
authority,
are
dependent
on
the
central
authority.
For
what
truth
is,
it
is
a
collaborative
process
and
it
is
possible
for
disagreements
to
occur
whether
that's
legitimate
or
illegitimate,
and
the
consensus
algorithm
is
what
is
required
in
order
to
have
strictly
ordered
in
most
cases
and
agreed
upon
values.
For
what
truth
is.
B
So
to
call
out
a
few
consensus,
algorithms
that
are
in
the
wild
and
again
this
is
not
super
detailed
by
any
means
more
just
a
allusion
to
some
consensus,
algorithms
that
are
out
there.
So
we
have
proof
of
work
based,
algorithms,
such
as
bitcoin
and
ethereum.
As
of
today,
I
believe
still,
unless
I've
missed
some
news.
B
This
is
a
relatively
energy
intensive
process,
but
it
allows
anyone
to
join
in
this
pool
of
peers
contributing
to
this
consensus
algorithm.
So
it
is
considered
to
be
a
permissionless
system
and
the
data
is
accessible
to
anyone.
So
it
is
considered
to
be
public,
it's
possible
to
deploy
a
proof-of-work
system
in
a
private
environment
as
well
and
to
permission
who
is
able
to
join.
So
the
fact
that
I
call
these
out
as
being
public
permissionless,
it's
not
universal
by
any
means,
but
tends
to
be
how
the
proof-of-work
consensus
algorithms
are
used.
B
B
Individuals
within
the
pool,
having
a
certain
amount
of
token
that
they're
staking
in
the
process
of
joining
in
the
consensus
algorithm
again.
These
tend
to
be
public
and
permissionless,
but
it
is
also
possible
to,
for
instance,
deploy
an
ethereum
contract
within
a
private
environment
and
use
it.
For
you
know
a
government
jurisdiction
and
use
that
to
bring
down
gas
fees,
while
still
still
taking
advantage
of
the
decentralization.
B
So
in
in
the
bft
camp,
we
have
practical
byzantine
fault,
tolerance,
which
is
what
plenum
actually
used
to
be
based
on.
We
also
have
redundant
byzantine
fault,
tolerance,
which
is
what
plenum
is
currently
based
on
and
then
there's
other
byzantine
fault
tolerance,
protocols
out
there
such
as
federated,
I
believe,
that's
used
by
like
stellar,
for
instance-
and
there
might
be
a
few
variations
of
this
federated
byzantine
fault,
tolerance
as
well.
B
These
are
again
very
highly
technical
in
what
the
differences
are
between
these
different
protocols
or
algorithms.
I
should
say-
and
of
course
there
are
many
more
consensus-
algorithms
out
there
in
the
world
today,
with
the
prevalence
of
cryptocurrencies
and
such
so
plenum
uses
the
rvfd
algorithm.
As
I
said
just
a
moment
ago,
I
will
not
be
getting
into
the
details
of
this
algorithm
today,
but
I
have
linked
in
the
handout
which
I'll
drop
another
link
in
the
chat.
Just
in
case
you
have
missed
all
my
other
postings
of
links.
B
What's
going
on,
though,
a
client
using
the
genesis
transaction
that
len
was
just
talking
about,
will
send
a
request
to
the
nodes
contained
within
the
genesis
transaction
to
discover
or
uses
the
genesis
transaction
to
discover
the
network,
and
then
the
transaction
is
sent
to
each
of
those
nodes.
The
nodes
go
through
a
process
of
propagating
that
request
to
all
the
nodes.
B
In
the
network,
then
there's
a
pre-prepare
prepare
and
commit
phase
which,
by
the
end
of
this
commit
phase,
the
consensus
has
been
reached
that
this
state
is
the
next
valid
state
for
the
ledger
and
that
data
is
committed
and
a
reply
is
sent
back
to
the
client
and
then
in
the
rbft
version
of
this
protocol.
There's
a
redundant
process
going
on
here,
where
I
believe
this
pre-prepare
prepare
and
commit
phase
are
performed
a
number
of
times
across,
perhaps
different
portions
of
the
network.
Again,
I
will
direct
you
to
the
paper
for
more
details
on
that.
B
So
why
are
bft
for
plymouth?
There's
a
few
benefits
that
I'll
call
out
these
again
are
coming
from
the
lay
person
first
off
low
latency
finality.
This
is
a
term
referencing.
The
amount
of
time
elapsed
between
submission
of
the
transaction
and
actually
being
committed
to
the
ledger
for
sure
is
low
when
compared
to
other
ledgers.
B
Additionally,
node
operators
are
not
incentivized
to
win
the
next
block
in
in
the
ledger,
so
this
tends
at
least
to
mean
that
the
notes
are
more
inherently
altruistic.
They
are
participating
in
the
consensus
algorithm
because
they
believe
in
the
principles
of
decentralized
identity
and
would
like
to
make
that
system
a
reality.
B
B
B
B
B
B
B
B
B
Plenum
in,
like
manner,
provides
tooling
for
users,
in
this
case
very
specifically,
node,
to
write
their
own
transaction
request.
Handlers
so
plenum
is
handling
the
committing
of
the
transactions
taking
care
of
all
that
consensus
stuff
in
the
background,
distributing
it
to
the
nodes
and
then
ultimately,
arriving
at
the
committed
state
plenum's
taking
care
of
that
most
of
the
heavy
lifting
for
that
at
least,
and
then
plenum
provides
base
classes
for
handlers
for
both
reading
and
writing
of
operations
to
the
network.
B
B
So,
to
elaborate
a
little
bit
more
on
that,
so
plenum
has
support
for
core
transactions,
so
transactions
that
are
fundamental
to
the
running
of
the
network
itself.
I
believe
this
is
mostly
limited
to
basic
nim
support
and
the
pool
management
side
of
things
so
introducing
a
new
node
to
the
network.
There
is
at
least
a
core
set
of
functionality
within
plenum
to
provide
that
so
plenum
can
stand
alone.
B
It
is
not
dependent
on
an
implementation
within
extending
it
to
be
functional,
but
then
node
goes
on
to
add
additional
handlers
for
all
other
indie
transactions
and
we'll
get
into
more
details
about
some
of
these
transactions
as
we
discuss
node.
But
a
quick
sampling
here
schema
and
retrieving
schemas
great
desks
and
retrieving
those
credefs
and
retrieving
them
attributes.
B
B
Each
of
these
request
handler
base
classes
have
a
set
of
abstract
methods
that
are
implemented
by
subclasses,
so
static
validation
and
the
base
request
handler
so
this.
In
other
words,
this
is
common
to
both
reads
and
writes.
This
is
validation
of
the
transaction
itself,
so
the
transaction
request
so
did
the
role
associated
with
this
nim
transaction?
Is
that
actually,
in
the
list
of
known
roles
for
the
network.
B
So
unique
to
the
write
request
handler
is
also
the
update
state
method,
and
this
is
if
we
were
to
go
back
to
the
web
frameworks
analogy.
This
would
be
the
handle
method.
This
is
what
is
actually
doing
the
the
state
transition
for
writing
to
the
network
so
for
most
write,
request
handlers.
This
is
the
interesting
bit
of
code
to
keep
an
eye
on
the
update
state.
B
So
I've
pulled
an
example
here
briefly
from
plenum's
nimhandler.
I've
omitted
most
of
the
data
most
of
the
like
actual
implementations
of
these
methods,
and
I
do
that
mostly
because
the
the
differences
between
the
nim
handler
within
node
and
the
differences
between
with
the
plenum's
version
of
the
nimhandler
they're,
actually
quite
different,
so
to
avoid
confusion
on
what's
actually
taking
place
between
the
nim
and
plinim
and
nim
and
node.
I've
omitted
some
of
these
details,
but
this
is
a
nim
handler.
It
inherits
from
write
requests.
B
B
So
as
a
a
summary
of
what
we've
just
gone
over,
then
we
are
looking
at
indie
plenum
in
the
stack
we'll
be
looking
at
indie
node.
Next
and
again,
just
to
reiterate
indieplenum
provides
the
framework
that
endynode
builds
upon
to
implement
all
the
actual
interesting
transactions
that
take
place
in
an
indie
network.
B
B
E
E
I've
been
looking
in
the
indie
channel
on
rocketchat
and
I'm
super
happy
to
see
that
other
people
from
the
community
or
from
this
call
that
are
watching
that
are
answering
questions
and
how
to
you
know,
and
as
a
community
effort
to
answer
some
of
the
issues
that
people
are
having
and
working
together.
I
think
that's
awesome.
A
I'll
go
ahead
and
answer
a
question
that
I
saw
from
from
harrison
tang
in
the
zoom
chat.
Here,
it's
a
great
question
about
the
incentives
for
running
a
node
on
a
network
it
it
depends
on
the
way
the
network
is
set
up
or
what
governance
is
set
in
place.
Some
network
cooperatives
have
different
incentive
programs,
but
really
at
the
heart
of
it.
It
is
a.
D
D
D
D
Indie
node
provides
the
decentralized
route
of
trust
needed
to
enable
verifiable
credentials
exchange
and
enable
identity
owners
to
choose
with
whom
they
share
their
data.
Right.
We've
talked
about
this
several
times,
just
hammering
home
the
the
need
on
this
mental
model
that
there
needs
to
be
a
place
where
a
verifier
can
go
and
get
the
public
information
needed
to
verify
holders
credentials,
and
this
is
important
because
it
removes
the
ability
to
discriminate
against
individuals
and
how
they
use
their
credentials,
and
the
ledger,
of
course,
stores
those
public
cryptographic
artifacts.
D
They
prefer
test
driven
development
watching
to
see
that
tests
are
implemented
for
every
feature.
That's
added.
They
want
document
documents
updated
with
info
pertinent
information
around
things
that
have
changed
and
as
you're
coding,
if
you
find
problems
in
the
code,
add
to
do's.
Add
fix
me.
Fist
fix
me
in
the
comments,
so
that's
easy,
easily
searchable,
as
well
as
raising
issues
on
github,
where
appropriate.
D
We
previously
were
using
a
jira
board
for
issue
and
development
tracking.
I
believe
we
have
now
switched
over
to
github,
and
this
is
recent
enough.
If
you
wanted
to
go
and
get
an
easy
pull
requests
on
the
repo,
you
could
go
and
update
the
documentation
to
reflect
that
we
follow
pep
8
coding
standards
when
adding
features.
We
want
to
follow
a
separation
of
concerns,
principle
going
object,
oriented
using
polymorphism
with
inheritance.
D
It's
important
to
remember,
I
think
sam
might
even
have
talked
about
this
in
his
contributor
notes
on
the
hyper
ledger:
indie
node
repo,
it's
important
that
you
add
a
commit
sign
off,
that's
dco
and
is
essentially
your
name
and
email,
saying
that
you
are
contributing
this
to
the
project
with
and
that
it's
open
source
that
it's
that
you
don't
retain
any
like
ownership
over.
I
guess
I
don't
know,
I'm
not
a
legal
expert
on
that.
D
You
can
ask
questions
in
the
chat
it's,
but
it's
it's!
It's
a
headache
to
go
and
correct
after
the
fact.
So
remember
it's
just
adding
hyphen
s
to
your
commits
and
get
on
the
command
line,
don't
code
or
develop
in
a
vacuum.
We're
trying
to
be
an
active
community
features,
often
start
as
hypes,
which
are
hyperledger
nd
protocol
enhancements
and
then
issues
created
in
github
where
you
can
assign
yourself
and
go
and
develop
that
feature.
E
D
So
some
important
places
to
go:
look
as
you're
becoming
familiar
with
the
repo
there's,
a
setup
dev
markdown
file.
It
explains
how
to
set
up
your
environment.
Our
prereq
actually
is
essentially
the
first
line
of
that
document
and
it
actually
outlines
how
to
set
up
visual
studio's
code.
As
in
the
prereq,
we
tried
to
be
more
general
and
just
have
you
set
up
docker,
but
I
highly
suggest
using
visual
studio
code.
I
believe
that
is
the
preferred
method
in
the
dev
setup.
D
Readme
there's
a
troubleshooting
document
where,
if
you
get
stuck
that's
a
easy
place,
go
see
if
there's
helpful
advice,
there's
also
rocket
chat.
When
you
make
a
pr,
you
can
go
to
the
I
believe,
there's
an
indie
or
a
hype,
rocket,
chat,
channel
and
say:
hey.
Please,
review
my
pr
there's.
As
we
just
mentioned
the
code
guidelines,
we
went
over
the
important
parts
of
those
historically
new
features
that
come
into
the
project
have
had
a
design
document
created
beforehand
so
going
into
the
design
directory.
D
You
can
find
a
non-creds,
I
believe
some
some
documents
on
the
consensus,
algorithm
view
change
and
how
that
procedures
work
as
well
as
just
opening
up
plenum's
docs
on
the
consensus
can
help
a
lot
specifically
the
static
validation
and
at
what
point
that's
done
during
the
consensus
and
then
the
additional
dynamic
validation
and,
as
dan
you
know,
spoke
about
earlier.
The
update
state
method
of
what
we
have
all
been
waiting
for.
We
have
no
more
slides.
This
is
off
the
rails.
Anything
can
happen,
no
holds
barred
daniel.
B
B
B
This
could
take
a
really
long
time
if
we
drilled
down
into
all
the
details,
so
I
might
go
down
a
path
a
little
bit
and
then
backtrack
just
a
little
for
the
sake
of
getting
on
with
the
actual
hands-on
portion
of
this
workshop.
I
guess
so,
but
here
we
are
so.
This
is
the
nim
handler
as
implemented
with
an
indie
node.
We
see
that
it
is
implementing
the
or
extending
rather
the
handler
from
plenum.
B
B
B
B
B
It
doesn't
make
sense
to
perform
an
operation
on
a
nim
without
specifying
that
nim,
and
then
we
also
make
sure
that
the
rule
associated
with
the
name
in
the
request
is
a
valid
role.
This
is
not
an
authorization
check.
This
is
actually
just
checking.
Is
this
role
within
the
set
of
known
roles
and
failing?
Otherwise,
authorization
occurs
during
the
dynamic
validation
step
which
I'll
move
on
to
now,
so
we've
got
a
redundant
request,
type
check.
B
We
pull
out
that
operation
again,
and
then
we
recall
from
the
ledger
a
nim
to
see
if
this
name
already
exists
on
the
ledger
or
not.
If
it
does,
that
indicates
that
it
is
a
nim
being
updated
by
this
transaction
potentially,
and
if
it
does
not,
it
means
that
we
are
publishing
a
new
name
to
the
ledger.
B
B
The
value
is,
then
serialized,
I'm
going
to
step
into
this
one
real
fast.
This
is
more
or
less
just
performing
a
json
encode
step,
and
then
we
determine
what
key
will
be
used
to
reference
this
nim
from
the
ledger
in
the
future,
which,
if
I
take
a
glance
at
that,
is
just
taking
the
hash
of
the
nem
value
and
using
that
as
the
key
in
the
ledger
state.
B
D
B
So
since
we
looked
at
the
nim
transaction
I'll,
look
at
the
corresponding
read
transaction
for
an
m,
we
have
here
the
get
name
handler
which
inherits
from
read
request
handler,
which
is
defined
in
plenum
as
we
discussed,
and
it
has
the
the
core
method
here
of
get
result.
So
this
will
likewise
do
a
request,
type
validation.
B
B
We
construct
the
path
for
that
nim
in
the
state,
and
this,
I
believe,
corresponds
to
yeah
it's
doing
more
or
less
the
same
operation
as
the
determining
the
key
for
the
state
was
previously
just
using
a
different
helper
for
that,
and
then
we
retrieve
from
the
state
the
path
identified
from
that
value
that
we
just
determined
and
then,
if
something
was
returned,
we
populate
some
values.
If
nothing
was
returned,
we
insert
none
instead
and
then
we
construct
a
transaction.
B
So
pretty
simple,
I
think
again
we
can
get
deeper
and
deeper
and
drill
down
further
and
further
into
the
code
and
what's
happening
happening
in
the
background,
but
at
least
from
a
high
level.
I
hope
this
gives
a
good
overview
of
the
different
components
and
pieces
that
we
see
here,
since
we
will
be
looking
at
this
in
just
a
moment.
I
also
wanted
to
take
a
moment
to
look
at
a
particular
file
within
node
here
so
inside
of
the
indie
common
package.
B
B
B
Yeah,
so
these
fields
are
aggregated
down
below.
Let
me
skip
ahead
to
that
in
the
client
operation
field,
so
for
each
transaction
type
that
exists,
we're
associating
the
schema
with
it,
and
so
we
can
have
one
central
field
attribute
that
we
can
use
to
check
the
operation
type
for
a
given
transaction.
B
And
we
will
be
coming
back
to
this
in
just
a
moment
without
them
in
the
hands
on.
It
strikes
me
that
it
might
be
helpful
that
we've
now
that
we've
just
reviewed
the
nimhandler
and
we've
seen
the
different
steps
that
it
takes
to
write
the
transaction.
I've
got
a
diagram
pulled
out
here
that
I'll
share
real
fast.
B
B
B
Let's
see,
and
this
diagram
is
available
in
the
nd
plenum
read
the
docs
underneath
plenum
diagrams
under
write
requests,
since
we're
here
figure.
It's
also
a
good
time
to
look
at
the
read
request.
That's
quite
small!
Let
me
see
if
I
can
zoom
a
little
bit
nope
that
didn't
do.
What
I
wanted
so
read.
Request
has
a
similar
flow
to
it,
except
it
doesn't
have
the
dynamic
validation
process,
but
it
enters
parses.
The
request,
git
transaction,
yes,
trans-static,
validation,.
B
I'm
not
exactly
sure
what
this
branch
of
it
is,
so
I
will
direct
you
to
other
documentation
for
more
details
on
what
this
check
is
in
the
base
case.
I
believe
we're
we'll
be
hitting
the
static
validation
and
then
getting
the
reply
from
the
state.
Try
and
state
proof
is
associated
with
the
object
that
is
retrieved
and
any
other
associated
verification.
Cryptographically
that
this
transaction
was
actually
written
to
the
ledger
is
included
in
the
reply.
B
B
So
aj
brings
up
the
question:
are
we
also
going
to
be
talking
about
in
the
sdk,
so
for
this
hands-on
portion
we'll
be
focusing
on
node
and
development
for
node?
Ndsdk
was
talked
about
a
little
bit
earlier
in
our
presentation.
That's
as
far
as
we're
going
to
take
it
for
this
one
but
yeah
we
can
definitely
add
talk
directly
to
more
resources
on
the
sdk.
For
those
who
are
interested.
D
Okay,
so
let's
say
you
want
to
do
something
like
put
a
github
profile
picture
on
the
ledger.
You
shouldn't
do
this.
That
would
be
considered
private
information
and
would
violate
the
taa,
but
if
you're
running
your
own
private
ledger
and
wanted
to
do
it
well,
why
not
create
a
or
update
the
nim
transaction?
To
actually
take
that
image?
D
D
D
B
D
Absolutely
like
raise
your
hand
if
you
hit
that
I
have
my
hand
raised
it's
yeah,
sorry
about
that
should
be
bolded
in
a
few
places.
This
is
like
the
docker
container.
We're
using
is
brand
new.
I
think
it
was
merged
a
week
or
two
ago
like
this
is
hot
off.
The
presses
changes,
we're
we're
using.
So
thank
you,
daniel
jumping
in
following
the
guidelines.
We
should
create
a
test.
D
I
guess
it's
not
in
servers
inside
ending
node,
there's
a
test
directory
inside
the
test
directory,
we'll
find
a
nim
transactions
and
there's
a
few
that
are
like
there's
only
two
tests
in
here.
I
think
that
do
very,
very
basic
stuff.
But
if
we
go
into
test
nim
additional
there's
quite
a
few
tests
in
here
that
we'll
be
able
to
borrow
logic
from
and
be
able
to
extend.
D
D
D
And
then
these
fixtures
provide
the
the
dids
and
the
writing
methods
to
actually
create
transactions
and
send
them.
I
realize
a
little
bit
of
background
knowledge
for
every
test.
I
believe
there's
four
nodes
alpha
beta
delta
charlie-
maybe
I
don't
know,
there's
several
nodes
that
spun
up
a
little
tiny
test
ledger
per
se
and
in
that
genesis
transaction,
that's
given
to
create
those
that
test
ledger,
there's
a
seed
that
creates
a
steward
d
id
and
there
is
a
seed
that
creates
a
endorser
did.
So.
D
D
D
D
D
D
D
D
D
D
D
D
B
So,
to
reiterate
what
what's
happening
in
the
background
here?
Is
we
run
this
test?
Adam
already
described
it
a
little
bit,
but
this
is
actually
spinning
up
a
test
network
with
four
nodes
alpha
beta
gamma
delta.
I
believe-
and
we
are
using
the
test
framework
and
the
fixtures
provided
already
within
any
node
to
interact
with
that
test
network.
B
D
D
Oh
no,
this
failed
okay,
good.
So
in
summary,
we
have
a
failing
test
for
adding
an
image
to
the
nem
transaction.
I'm
going
to
jump
into
that's
the
most
extensive
part
of
the
code.
Like
writing
the
rest
of
it
is
just
understanding.
What's
going
on
daniel,
do
you
have
any
comments
dad
before
I
jump
into
updating
the
operator.
B
D
D
So
if
we
navigate
back
up
into
indy
common
types
inside
the
types
file
way
down
low,
around
470.
there's
this
client
operations-
daniel
just
showed
us
this
a
few
minutes
ago.
So
this
should
look
familiar
to
you,
you
guys
it
extends
plenum's,
client,
operation
field
and
so
there's
not
already.
Currently
a
nim
client
operator,
operation.
D
B
D
D
D
I
have
a
plug-in
that
will
automatically
manage
my
imports.
This
should
spit
up
a
whole
lot
more
red
than
it
is.
I
believe
so
I
believe,
but
all
we've
done
is
in
addition
to
roll
target
nim
over
key
and
alias
transaction
type.
We
are
adding
an
image,
so
we
can
put
images
from
github,
maybe
even
an
image
of
your
face,
your
profile,
which
is
frowned
upon.
B
D
D
D
D
D
D
B
Within
the
test,
it
seems
to
be
acceptable
to
not
use
those
constant
values,
but
that
would
of
course,
be
a
pain
if
you
ever
did
change
them,
because
you'd
have
to
change
the
test
manually.
So
when
making
changes,
those
that's
something
to
keep
in
mind
for
sure,
but
there's
there's
less
of
a
strong
requirement
in
the
presence
of
this
constant
in
in
the
tests.
D
D
So
if
we
go
into
indie
node
and
look
at
server
inside
servers,
you
will
find
request
handlers
and
there's
request
handlers
for
each
sub
ledger
and
then
there's
a
read
request
handler.
If
we
go
into
domain
request
handler,
we
can
find
the
nim
handler
and
in
review
as
daniel
went
over
this.
The
nim
handler
is
extending
plundom
plenum's
handler.
We
can
actually
go
look
at
that.
D
B
D
D
We're
not
gonna,
be
we're
not
going
to
be
that
robust,
and
so
all
we
want
to
do
is
store
the
image
so
we're
able
to
retrieve
it
and
create
it,
with
the
only
limitation
being
that
raw
data
string
field
limit
and
so
inside,
of
the
update
state
which
the
icebreaker
we
went
over.
We
can
see
that
there's
checks
for
different
things
of
the
operation,
the
transaction.
D
D
D
B
D
That
just
added
the
import
from
constance
of
image
that
we
just
created
okay.
So
if
the
image
is
there
in
the
transaction
data,
then
we're
going
to
store
it
processing
will
occur
to
where
the
state
is
set
with
the
key
in
value,
and
it
will
have
our
image
in
it.
There
are
nothing,
there's
nothing
else.
I
believe
we
need
to
do
any.
E
D
B
There's
an
effort
on
going
in
the
community
right
now
for
diddindy
method,
which
adds
an
attribute
onto
the
nim
for
deduct
content.
This
hands-on
walk-through
is
actually
pretty
much
inspired
by
that
effort
and
we
found
it
was
pretty
interesting
that,
while
any
node
might
seem
intimidating,
especially
on
the
surface,
it
was
it's
actually
pretty
straightforward
change
to
add
things
to
something
like
the
nim
transaction.
B
So
yeah
you
can
add
functionality
and
not
too
many
modifications
to
indie
node
and
have
a
pretty
significant
impact.
I
think,
on
the
direction
of
the
indie
project.
So
that's
I
guess
my
plug
for
getting
involved.
Node
has
served
us
well
for
a
long
time,
but
that
doesn't
mean
it's
perfect,
so
your
contributions
are
more
than
welcome.
D
Thank
you,
daniel.
If
you
look
at
step
six
of
the
handout
celebrate
the
past,
we
have,
it
did
its
thing.
We
updated
the
operation
to
have
an
image
tag
or
parameter.
We
then
updated
the
handler
to
store
that
image
and
we
successfully
tested
that
it's
stored
and
retrieved.
So
celebrations
right,
cheers.
B
D
Yes,
absolutely,
and
I
mean
I
made
a
few
mistakes
in
there
and
I
had
a
cheat
sheet
so
as
you're
joining
the
community,
remember,
there's
the
troubleshooting
and
then
you
can
join
there's
a
working
group.
You
can
join
and
make
noise
in
and
yeah
oh
exciting.
I
believe
that's
all
I
had
for
the
hands-on
unless
I'm
forgetting
something
daniel.
C
Oh,
this
helps,
if
I
unmute,
we
sure
are.
We
want
to
talk
about
the
future
of
indy
here,
because
it
can
give
us
some
some
insight
into
sort
of
what's
happening.
What's
what's
coming
up,
is
new
and
and
what
we
can
look
forward
to
so
so
we
wanted
to
talk
about
some
some
concepts
as
it
relates
there
to
look
forward.
C
C
So
I
want
to
talk
about
about
a
couple
things
with
the
future
of
indy,
the
modularization
of
indie
sdk
indie
in
a
multi-ledger
world.
They
did
any
method
in
a
non-credit
standardization.
This
is
going
to
be
a
little
quick
and
we
don't
have
the
full
time
to
go
into
all
of
the
details
here,
but
can
definitely
entertain
some
questions
and-
and
your
effort
of
course,
is
invited
if
you
would
like
to
get
involved
in
any
of
these
things.
C
B
B
That
being
said,
we've
discovered,
you
know
that
it
would
be
really
nice
to
have
these
modular
components
that
we
can
pull
down
and
use
independent
of
the
other
pieces
of
the
india
sdk,
and
so
that
effort
was
started
some
time
ago
now
by
the
government
of
british
columbia
and
their
team
over
there.
So
huge
shout
out
to
all
the
efforts
that
they've
put
into
these
separate
libraries.
So
with
the
ndvdr,
we
have
ledger
communication,
independent
of
the
original
sdk
libraries.
B
C
Thanks
daniel
and
again
just
to
review
as
daniel
talked
about
that
earlier
in
the
in
the
efforts
going
on
there,
so
that's
modularization
of
the
india
sdk.
The
other
thing
I
want
to
talk
about
is
is
the
difference
between
one
ledger
and
a
lot
of
ledgers.
We
we
began
with
a
single
ledger,
oriented
sort
of
as
a
utility,
and
there
became
a
lot
of
reasons
why
different
indie
ledgers
were
were
spun
up
in
in
our
under
use,
and
so
an
early
one.
For,
for
example,
was
finland.
C
We
we
lovingly
call
findi
and
they
and
and
the
government
of
canada,
etc
and,
as
it
turns
out,
there's
a
whole
lot
of
reasons.
Why
particularly
countries
are
interested
in
in
running
different,
different
ledgers
and
part
of
it
has
to
do
with
various
regulation.
That
requires
solutions.
That
government
is
involved
in
to
not
depend
on
foreign
interests
and
the
the
while
a
very
distributed
ledger
solves
lots
of
those
issues.
C
And
the
answer
I
think
is
a
little
is
a
is
a
little
insightful
to
how
you're
thinking
about
ledgers
and
the
role
that
they
play.
So
every
ledger
offers
services
and
you
want
to
use
the
services
from
any
and
all
of
the
applicable
ledgers
that
make
sense.
For
example,
indy
does
not
contain
the
the
general
transfer
of
of
money.
That's
like
not
a
thing
an
indie
ledger
is
going
to
support.
It
will
likely
ever
support
from
a
general
purpose
perspective
right.
C
So,
but
that's
what
bitcoin
does
so,
there's
nothing
wrong
with
using
bitcoin
to
to
transfer
bitcoin
and
and
using
an
indie
ledger
for
the
identity,
components
you're
using
a
service
from
each
of
them,
and
I
think
we'll
see
the
evolution
of
more
ledger.
Services.
Nfts
are
are
an
interesting
example
of
a
type
of
service
that
a
ledger
can
offer
and
as
as
useful
applications
that
technology
you
know
present
use
cases,
there's
nothing
wrong
with
using
ledgers
with
the
services
that
they
actually
provide.
C
So
the
answer
on
which
one
do
I
use
is
you
want
to
use
as
many
as
are
useful
and
we're
moving
into
a
world
where
the
software
that
you
interact
with
will
be
will
be
able
to
reach
into
whatever
ledgers
actually
makes
sense.
So
this
it's
a
trick
question
because
there
obviously
isn't
one,
but
that's
the
that's.
The
concept
that
I
wanted
to
bring
up
is
that
the
the
the
goal
of
india
is
not
to
be
the
one
ledger
to
rule
them
all.
C
It's
to
solve
its
very
specific
problem
for
identity
in
a
way
that
allows
it
to
be
joined
with
the
services
from
others,
in
a
real,
really
useful
and
powerful
way
so
composition
here,
not
not
really
adoption
of
all
of
those
various
technologies
so
to
aid
that
effort.
One
of
the
things
that's
happening
here
is
the
indeeded
method.
B
C
So,
to
highlight
some
cool
stuff
that
daniel
just
said,
the
did
any
method.
Isn't
you
don't
have
to
make
your
own
if
you're
running
an
indie
ledger,
the
did
any
method
can
be
used
with
any
indie
ledger.
Furthermore,
it
allows
the
referencing
of
between
ledgers
of
certain
objects.
For
example,
if
you
had
a
schema
on
a
different
ledger
that
you
wanted
to
reference,
you
can
do
so.
C
There's-
and
this
is
a
really
nicely
designed
way
to
do
that
and
as
a
dco,
we're
excited
to
be
involved
here
and
grateful
for
bc.
Gov
support
there's
another
effort
that
relates
a
little
bit
to
this
there's
a
there's,
an
effort
underway
to
standardize
via
non-cred's
cl
signatures
based
credentials
as
a
as
a
standard.
This
is
basically
an
effort
to
document
and
standardize
the
de
facto
and
uncut
standard
that
exists
today
and
is
active
in
houston
in
india.
C
Ledgers
one
of
the
complaints
against
the
non-creds
is
that
it
specifically
requires
indie.
While
we
happen
to
like
indy,
we
love
the
the
concept
that
a
non-creds
could
could
gain
further
traction,
and
so
one
of
the
changes
in
the
non-cred
standardization
effort
will
be
to
remove
the
explicit
indie
ledger
requirement.
Indie
remains
a
great
thing
to
build
a
non-creds
on
top
of,
but
other
other,
either
ledgers
or
other
immutable
data
stores
can
be
used
in
place
of
indy.
C
C
The
the
the
work
for
the
anand
standardization
effort
is
being
pursued
at
the
ietf
and
will
predominantly
involve
documentation,
although
there
is
some
some
very
small
changes
to
make
to
the
the
formats
of
of
referencing
credentials
and
and
in
the
various
objects
that
they
require,
such
as
credential
definitions
and
schemas.
So
that's
underway
and
and
and
if
you're
curious
of
that
reach
out,
we
can
point
to
you
to
where
the
meetings
are
happening.
This
is
just
barely
getting
started.
C
So
part
of
the
question
is
why
this
is
a
hot
topic
that
I
get
asked
frequently
and
fast
and
in
fact,
during
during
the
the
training
session
here,
I
got
asked
by
another
party
not
attending,
but
I'm
very
interested.
So
the
we
were
hopeful
that
the
privacy
features
of
jason,
ld,
bbs
plus
signatures,
would
would
reach
parity
with
the
things
that
we
have
in
the
non-creds.
That
has
not
happened.
That's
not
been
abandoned,
but
it
isn't.
It
certainly
isn't
on
the
fast
track
that
we
were
hoping
for.
C
Seal
signatures
based
on
on
creds
are
already
widely
deployed,
which
means
that
that
seeking
that
is
a
de
facto
standard
is
a
useful
step
towards
whatever
ends
up
getting
developed
in
the
future,
and
then
it
could
possibly
also
set
stage
for
a
future
version
of
an
uncred
where
we
don't
have
to
give
up.
The
privacy
features
that
we
have,
but
we
can
use
newly
developed,
crypto
and
other
sorts
of
things
to
to
to
continue
to
innovate.
C
On
top
of
that
standard,
the
the
future
version
of
it
on
credit
is
not
a
assumed
thing.
That's
a
much
longer
development
effort,
but
the
you
know
seeking
the
the
the
de
facto
standardization
of
what
we've
already
gotten
in
on
creds
will
be,
will
be
something
coming
much
faster,
and
so
that's
that's
a
lot
of
stuff.
I
just
realized
the
chat
window
wasn't
up,
and
so
I
have
no
idea.
Oh,
I
do
have
it
up
yeah.
C
A
C
A
We
are
getting
an
email
out
to
everybody
who
is
at
the
aries
workshop
this
week
and
that's
going
to
include
all
the
links
and
a
link
to
the
video
and
we
are
going
to
work
to
send
out
a
similar
email.
Probably
on
monday,
for
this
workshop,
which
can
which
will
include
a
link
to
the
slides
as
well
as
a
link
to
the
video.
We
want
to
get
it
out
as
quickly
as
possible.
So
we'll
get
that
folks
keep
an
eye
on
rocket
chat
or
keep
an
eye.