►
A
A
A
A
A
Wonder
if
we
could
use
well,
no,
we
don't
want
to
do
that.
We're
doing
that.
We're
just
we're
doing
this.
Okay,
so
we're
okay,
so
yeah
so
url
shortener
live
so
basically
the
the
url
shortener
dot,
whatever
slash
live,
should
be
whatever
the
active
stream
link
is
and
then
basically
you
know
tweet
the
or
actually
no
we
don't
want
to
do
that.
We
don't
need
okay,
so
yeah!
Okay,
I
don't
know,
I
guess
we
don't
really
need
that.
Slash
live!
I
guess
that
was
really
if
we
were
going
to.
A
That
was
really
only
if
we
were
going
to
not
have
this
and
then
just
have
the
url
shortener.
So
originally,
I
think
I
wrote
a
thing
that
was
for
the
url
shortener,
but
then
it
turned
into
this,
which
is
basically
more
of
the
stream
approach.
Okay,
so
basically
what
does
what
was
interesting
about
this?
A
So
in
the
process
of
doing
this,
it
occurred
to
me
that
we
already
have
a
rudimentary
parser
for
shell
commands
in
the
console
test,
plugin
sphinx
extension,
which
is
in
the
the
dfml
util
testing,
console
test
and
there's
video
on
that
one.
If
you
go
to
the
readme
it's
there,
and
so
this
would
allow
okay.
So
basically
one
of
the
things
in
the
map
for
the
introduction
in
context
is,
if
you
look
at
the
to
do's,
let's
see,
I
think
we're
right
here,
actually
yeah.
A
Okay,
here
yeah:
what
is
this
okay,
so
this
is
chapter
one,
okay,
so
yeah,
and
so
we're
laying
we're
still
we're
we're
doing
so.
Basically,
I
put
the
stuff
in
chapter
one,
but
basically
we're
filtering
this
stuff
into
chapter
zero.
When
it's
you
know
core
library,
stuff,
right
and
because
core
library
stuff,
we
basically
we're
treating
chapter
one
as
first
use
case
right.
First,
deployment
of
alice
right
and
chapter
zero
is
sort
of
like
okay.
We
got
all
the
foundations
there
right.
A
A
Basically,
these
you
know
sort
of
graph
network
graph,
a
graph
of
it's
basically
think
think
of
it
like
you're,
compiling
combining
like
tcp
and
gpg,
or
something
right
like
you,
have
the
ability
to
encode
for
different
parties,
and
you
also
have
this
notion
of,
like
you
know,
streams
of
streams
of
data.
I
think-
and
at
least
the
ability
for
this,
this
synchronous
or
asynchronous
communication
to
sort
of
just
receive
one
packet
at
a
time
or
you
know
whole
stream.
A
So
I
believe
that's
what's
what
the
point
is
now,
so
this
looks
ideal
for
us
right.
So
then
we
can
choose
our
transport
layer
underneath,
and
what
we
want
to
do,
though,
is
this
implementation
that
we
found
the
spec
off
of
was
only
supports,
there's
three
layers,
and
this
only
supports
layer
two
and
one
and
two,
so
we
want
to
we
wanna
go
see
if
there's
a
layer,
three
implementation
available.
A
B
A
Okay,
so
run
the
application.
You
will
require
a
two-party
firefly
system
running
locally
on
ports
going
for
black.
The
easiest
way
to
set
that
up
is
with
firefly
cli.
Okay,
once
the
firefly
stack
is
set
up
and
run
the
sample
with
npm
npm
install
okay.
So
this
is
the
one
concern
that
I
have
off.
The
bat
is
that.
A
So
they
start
these
things
and
then
so.
They're
listening
on
ports
and
they're
yeah
they're
listening
on
ports
and
they're
talking
over
web
sockets.
So
we
want
to
so
we.
This
is
one
layer
too
high
for
us
in
a
level
of
abstraction
stack,
so
we
want
to
be
https
data
exchange
fabric,
connector
performance,
ui,
okay,.
A
A
A
A
A
A
A
So
firefly
plug-in
architecture
all
right,
so
we've
identified
the
fact
that
yet
another
layer
in
the
abstraction
stack
has
been
built
on
top
of
what
we
thought
was
the
state
of
the
art.
So
it's
firefly,
okay.
So
this
firefly
thing
it
looks
like
it
uses
pure
dids,
underneath
probably
is
my
guess
so,
basically
they're
just
gonna
they're.
They
they
have
this
blockchain,
and
this
blockchain
involves
some
data
flow
stuff.
A
A
A
Okay,
so
this
is
great.
So
we
could
definitely
leverage
this
okay,
so
we
want
to
throw
we
want
to
show.
We
want
to
throw
plugins,
okay,
ethernet
client
code,
forever,
connect,
client,
okay,
blockchain
interface
and
go
is
great
because
go
cross
compiles
to
different
platforms,
so
that's
great
on
chain:
identity,
okay,
ipfs,
so
ipfs
server,
http,
websocket,
external
microservices,
fireflight
data
exchange,
https
client
service,
connectors,
okay,
so
here's
the
connectors
infrastructure
run
times,
plugins.
A
A
We
need
this
to
work
over
more
than
just
that,
because
we
want
to
leverage
kubernetes
for
the
execution
environment
on
this
one,
which
means
that
we
need
to
work
over
like
a
kubernetes
based
kubernetes
based
messaging
system.
So
how
do
we
integrate
firefly
with
kubernetes?
So
I
wonder
if
anybody
has
done
that
so
somebody's
integrated
firefly
over
kubernetes
and
we
can
just
throw
our
ml
jobs
on
top
of
that.
A
A
A
A
Okay,
so
hyperledger
transact
is
a
platforming
agnostic
library
for
executing
transactions
with
smart
contracts.
The
hyperledger
transact
project
consists
of
several
projectors.
This
contains
the
transact
rust
library,
the
transact,
contrib
library,
contains
examples
and
reference
implementations
and
then
there's
rfcs.
So
let's
go
check
out
the
rfc,
so
we
can
understand.
A
A
You
know
the
the
contract
for
hire
that
guys
they
and
gals
and
everybody
they
go
and
they
go,
and
you
know,
write
whatever
these
projects
are.
You
know,
and
maybe-
and
in
this
case
see
they're
based
around
these
specs
that
are
being
shared
in
the
hyper
literature,
community
and
other
places.
So
so
it
looks
like
the
did.
A
A
A
A
A
A
A
A
A
A
A
A
A
A
So
basically
it
looks
like
so
so
so
the
hyperledger
foundation
has,
for
you
know
the
past
few
years,
been
building
blockchain,
stuff
and
they've,
so
they've
built
more
and
more
blockchain
projects
and
and
they
sort
of
figure
out
different
things
as
they
build
them
through
these
contractors
that
build
them
in
the
community
that
engages
with
them
via
the
corporations
that
are
funding
it
and
then
elsewhere.
But
then,
generally
the
contractors
lead
the
engagement
there.
A
It's
not
software
developers
right,
but
if
alice
is
the
software
developer
and
it's
other
copies
of
her
and
they're
all
doing
software
development
with
their
different
resources
being
the
different
computer
or
whatever
they're
attached
to
then
you're,
creating
this
giant
network
of
things
that
work
together
right
and
so
yeah.
We
want
that
to
be
on
top
of
the
did
stuff.
Now
I
can't
remember
how
we
got
there:
okay,
oh
yeah,
and
so
the
blockchain
is
good,
because
it's
all
about
interoperability,.
A
Or
like
the
the
train,
whatever
okay,
so
it
looks
like
here's
what
we
know
so
it
looks
like
they
support
this
interface
for
plugins.
We
have
a
question
mark
around.
Can
we
make
that
interface
for
plugins
connect
to
our?
You
know
arbitrary
dffml,
ecosystem
of
plug-in
stuff
right,
and
I
think
our
next
order
of
business
is
we've
confirmed
this
uses
dids,
you
know
probably
offers
support
to
the
most
complete
level
that
anybody
is
going
to
be
offering
right
now
we
need
to
go
look
for
projects
that
might
be
using
transact.
A
A
A
A
A
A
Wow
we're
back
here
good.
This
is
what
I
was
trying
to
do
like
two
years
ago
and
I
didn't
realize
what
we
were
doing
at
the
time.
I
thought
this
was
just
like
a
secondary
use
case,
and
now
it
seems
like
it's
the
primary
use
case
for
at
least
a
you
know
what
should
be
an
input
network,
because
if
every
of
all
the
data
goes
on
the
blockchain,
then
really
all
we
need
to
focus.
We
really
need
to
focus
on
supporting
the
blockchain
as
the
data
source
and
then
just
do
import
export
to
that.
A
A
So
we
are
going
to
engage
with
the
hyperledger,
whatever
the
supply
chain,
people
are
and
we're
going
to
try
to
figure
out
how
to
cross
the
open,
ssf
supply
chain
work.
That's
happening,
supply
chain
security,
work,
that's
happening
with
the
hyperledger
supply
chain,
security,
work
and
we're
going
to
add
in
you
know
our
machine
learning
on
top.
A
A
A
A
A
A
A
High
in
security
yeah,
so
yeah
exactly
so,
but
it's
not
open
source
all
right,
so
in
that
case
you
know
potentially
yeah.
Well,
I
mean
they
could
potentially
leverage
what
we
do,
because
we're
going
to
do
it
right.
So
if
they
wanted
to,
then
they
could
do
that
right,
but
this
is
very
similar
to
exactly
what
we're
talking
about
right.
A
We
want
to
integrate
across
all
of
this
right
and
allow
you
to
deploy
anything
anywhere
with
whatever
you
want,
with
whatever
configuration
right,
and
so
the
thing
that
we're
adding
on
top
of
this
is
also
like
the
end
user.
Interaction
of
that
is
the
same
thing
right
and
then
you
know
the
end
user,
writer
and
and
the
and
that
what
is
it's
not
just
like
you
know,
integrating
these
things
as
they
exist,
but
also
like
the
communication
between
them
all
becomes
this.
A
You
know
execution
environment
and
that
would
be
like
you
know,
one
of
these
smart
contract.
Executors
right,
I
believe,
is
what
we're
looking
at
and
so
now
we're
gonna
look
into
like.
Basically,
how
do
we
map,
where?
How
are
we
mapping
all
the
config
in
there?
So
we
need
to
look
at
the
executors,
for
what
is
this
so
yeah?
A
A
Newly
allowed
cactus
okay,
so
you
can
then
integrate
across
so
okay,
so,
okay,
so
there's
this
yeah.
So
this
hyperledger
cactus
function,
integration
is
going
to
securely
integrate
different
volumes,
plug
works
which
enables
execution
of
later
off
multiple
blockchain
letters.
Okay!
So-
and
what
is
this
so
when
was
this
may
2020?
Okay?
So
we
better
go
check
out
this
cactus
thing,
because
this
is
a
while
ago.
A
Because
objects
are
in
a
verifiable
presentation,
reference
hyperledger
indian
network
issued
by
their
user,
their
nddid
method,
like
the
groundwork
to
make
this
possible.
This
advancement
in
interoperability,
is
significant,
while
issuers
still
need
to
be
anchored
in
the
specific
indie
ledger
of
their
choice.
Holders
can
seamlessly
receive
verified
credentials
from
issues
rooted
in
different
hyperledger.
Ending
networks
be
able
to
create
verifiable
presentations
for
many
combinations
of
those
credentials.
Likewise,
verifiers
will
be
able
to
verify
presentations
that
include
claims
derived
from
credentials
looted
in
multiple
indie
networks.
A
The
nddid
method
paves
the
way
for
hyperledger
nd
credentials
to
scale
by
allowing
nd
networks
to
seamlessly
interoperate
with
a
global
network
of
networks
effect.
With
this
groundwork,
complete
agents
and
agent
frameworks
need
to
interoperate
with
the
nddid
method.
This
community
adoption
will
increase.
The
ability
of
entities
in
aries
stacks
of
areas
is
the
other
one.
We
were
interested
in
and
positioned
to
be
a
globally
dominant
way
to
issue
shared
verifiable
financials
in
a
multi-ledger
world,
so
this
is
perfect,
okay,
so
may
5th,
so
that
just
happened.
A
A
A
A
A
A
So
so
this
guy,
he
wrote
this
thing
wrote
the
blog
post,
put
out
the
thing
and
then
the
next
thing
we
know
so
what's
he
working
on
after
he
did
that
he's
immediately
working
on
this
aries
python
cloud
agent
right,
which
is
and
where
were
we
before
so
he
wrote
this
demo
and
this
demo
was
lauded
as
as
the
the
thing
that's
going
to
be
the
most
interoperable
right
and
then,
where
are
we
going
from
there?
Well
we're
going
to
this
aries
cloud
agent
python,
which
is
this
project.
A
A
A
A
A
Okay,
we
can
basically
close
out
of
grid.
We
can
assume,
so
we
can
assume
so
so
grid
is
the
de
facto
hyperledger
supply
chain
solution
right.
So
basically,
if
we
put
all
our
software
in
a
supply
chain
that
grid
can
we
can
basically,
so
we
looked
at
the
grafting
stuff,
that's
basically
where
you
take,
you
know
a
did
in
one's
one
chain
and
put
it
on
another
chain
right.
I've
been
really
wanting
to
get
into
this
stuff
for
years.
I
never
got
the
chance,
but
now
is
a
good
time.
A
So
so
that's
it's
gonna
get.
You
know.
I
think
my
understanding
is
that
it's
gonna
graph,
these
nodes,
basically
between
networks
by
copying
their
contents
and
reissuing
with
new
keys
or
something
like
that,
so
the
blog
post
we
found,
which
was
the
most
recent
blog
post
from
the
hyperledger
foundation,
said
that
there
was
this
state-of-the-art.
A
A
A
A
A
A
A
A
Understanding
it
under
introduction
to
super
nodes.
What
is
a
super
node?
Okay?
Over
the
last
decade,
enterprise
blockchains
projects,
architects
and
developers-
have
realized
that
they're
much
more
need
than
the
blockchain
node
for
their
projects
that
they
need
much
more
than
a
blockchain
node
for
their
products.
To
be
successful,
the
development
stack
needed
for
enterprise
grade
web3
applications,
just
as
sophisticated
as
the
stack
required
for
web
2
applications
came
before
a
raw
blockchain.
A
Node
is
simply
not
enough,
so
your
choice
of
the
development
chain
for
a
blockchain
project
becomes
whether
you
build
and
update
all
the
plumbing
or
middleware
components
underneath
okay.
So
this
is
like
the
dffml
of
blockchain
is
what
I'm
seeing
here
yeah.
This
is
like
the
dffml
of
blockchain.
This
is
great
okay,
so
private
data
exchange
way
to
might
be
okay
message,
queue
either
way.
Pwp
gateway.
Logic
said
they
support.
B
A
A
The
purpose
of
the
sandbox
is
to
provide
quick
and
easy
way
to
try
out
all
the
fundamental
blocks
that
firefly
provides.
It
also
shows
developers
through
example,
code
snippets
how
they
would
implement
the
same
functionality
in
their
own
apps
backend.
So
I
think
we're
going
to
get
start
to
get
into
the
identity.
Aware
context,
issues
stuff
here.
A
And
this
is
one
of
the
things
that
I
found
with
all
these
blockchain
things
a
few
years
ago.
Was
that
you'd
go
in
and
then,
like
all
of
the
demo,
applications
are
written
without
any
instruction
as
to
like
how
to
set
up
more
than
one
user
like
it's
like
when
there
used
to
be
all
of
the
webrtc
like.
If
you
go
to
all
these
webrtc
demos,
they're
all
pretty
much
set
up
to
be
like
single
user
web
pages,
except
for
the
ones
that
use
google's
stunner
turn
server.
D
A
A
A
A
A
Okay,
great?
So
this
is
like
a
man.
This
is
like
a
manifest
that
they're
saying
they're
telling
us
about
a
manifest
basically,
so
this
is
their
contract,
interface
and
so
list
of
methods.
The
small
events.
Okay.
This
is
a
this
is
a
data
flow.
This
is
a
data
flow
with
a
a
yeah.
It's
data
flow
with
a
manifest.
A
A
A
A
B
A
Okay,
all
right,
so
this
is
good
all
right,
so
we
may
have
found
the
state
that
the
the
edge
the
leaf
remember.
We
keep
talking
about
trying
to
find
this
leaf,
node
in
the
train
of
thought
right.
So
I'm
curious.
What
is
this
aries
cloud
agent?
Python,
decentralized,
identity,
applications
in
non-mobile
environments?
This
seems
like
something
that
would
help
us
here.
A
So
here
is
this
agent
client
part
of
a
decentralized
identity.
Ledger
did
verifiable
credentials.
Application
that
is
intended
to
be
agnostic
to
the
underlying
ledger
did
verify.
India
is
a
decentralized
identity.
Implementation,
including
support
for
a
letter,
ledger
initials.
Aries
work
was
to
move
the
agent
worked
in
from
in
indy
two
areas,
so
as
first
working
versions
of
areas
using
the
underneath
for
the
decentralized
identity
components
over
time,
those
components
will
become
plugable
and
okay.
A
A
C
C
Well,
good
news.
There
is,
and
that's
that's
what
hi
firefly
really
does
and
and
what
the
community
is
really
excited
about
and
the
purpose
of
it
it
handles
out
of
the
box
support
for
multiple
different
protocols
and
chains.
It
has
native
support
for
things
like
tokens
and
digital
assets.
It's
very
plugable,
so
you
can
bring
your
own
wallet
custody
key
management
solutions.
C
It
also
has
off
out
of
the
box
off-chain
technologies
as
well.
So
so,
depending
on
your
approach
to
data
privacy,
you
have
options.
It
has
a
robust
orchestration
layer,
so
things
like
reliable
event,
delivery,
retries
on
transaction
submission
and
so
on
or
there,
and
it
has
a
data,
a
rich
data
layer
as
well
out
of
the
box,
so
a
caching
layer
a
place
to
aggregate
your
private
data.
E
D
B
Definitely
is
the
message
that
that
resonates,
that
transparency
aspect,
the
community
aspect,
you
know
or
things
that
the
synaptic
was
built
upon
from
the
beginning.
You
know
as
well
and
then
so
saying:
hey
we're
going
to
work
with
this
open
source.
You
know
so
there's
not
that
fear
of
vendor
lock-in
and
then
also
you
know
for
our
ability
to
deliver.
We
have
to
be
very
focused
on
a
narrow
use
case.
F
A
A
A
A
A
A
A
A
A
A
A
We're
gonna,
go
encode
our
inputs
into
this
network
format
right
and
so
we're
going
to
go,
just
deploy
it
and
then
dump
it
to
see
how
it
is.
This
is
just
sort
of
you
know,
you
know
just
go,
would
just
go,
deploy
it
and
dump
it.
We
just
want
an
example
of
the
data.
We
want
a
corpus
of
the
data
right
and
then,
if
we
can,
if
we
can
dump
it,
if
we
can
dump
the
data
from
one
of
these
did
based
networks
right
and
basically
like,
maybe
one
think
of
it
like.
A
A
A
To
what
is
seen
seen
or
unseen
in
the
firefly
explorer
ui?
Okay,
so
then,
so,
basically
we
spin
up
the
did
base
chain
using
firefly.
We,
you
know
dump
example,
so
they
usually
have
examples.
Example,
d
they'll
usually
walk
us
through
an
example
of
like
here's.
How
you
set
up
our
application,
yada
yada
yada
right,
so
we're
basically
just
going
to
set
it
up
and
then
dump
it
and
we're
going
to
say
what
does
it
look
like?
So
you
know
basically
a
file,
not
memory
called
story.
A
And
this
is
just
your
basic
like
this
is
the
basic
stuff
that
you'd
be
doing.
If
you
were
reverse
engineering,
something
right
what's
the
protocol,
what
does
it
look
like
where
what
what
bits
go,
where
okay
understand
each
record
maps
to
what
is
seen
or
unseen
in
the
firefly
explorer
ui
understand
how
okay!
A
A
That
the
example
is
in
the
dumped
example
is
in
okay.
So
now,
if
we're
looking
at
this,
like
we're,
creating
our
fuzzer
when
which,
in
a
way,
we
are
we're
creating
like
this,
this
fuzzer
that's
going
to
build
code
as
well,
as
you
know,
test
code,
because
that's
what
else
is
going
to
do
when
she's
debugging,
you
know
this
is
like.
A
A
A
A
I
don't
know
what
time
it
will
say,
I'm
not
sure
what
day
it
will
say,
we'll
just
put
the
quest
for
appear,
did
layer,
3a
and
3d
compliant
lib,
okay.
So
then
we
have
basically
we
definitely
we
definitely
we
did.
We
went
far
on
that
quest.
We
got
all
the
way
to
the
point
where
there's
like
some
really
robust
solutions.
A
We
don't
have
to
build
upon
so
yeah.
Now
I
understand
what
daniel
meant
on
twitter
when
he
said
that
the
dids
are
really
the
core
when
they
said
that
they
were
really
the
chord.
You
know
he
wasn't
kidding
that
the
rest
of
the
stuff
where,
where
where
we
need
to
go
as
far
as
abstraction
layer
wise
to
actually
start
using
this
stuff,
is
pretty
far
out
that
the
ecosystem
seems
pretty
mature.
This
is
great,
so.
A
A
A
A
A
A
So
this
is
pretty
sweet,
so
this
is
pretty
sweet.
So
then
we
can
move
on
once
we've
confirmed
that
we
can
save
and
load
from
the
firefly
stuff
we're
hooked
into
the
entire
ecosystem
of
the
hyperledger
blockchain
stuff.
We
can
you
know,
leverage
that
that
infrastructure,
that
highway
of
data
and
we
can
build
our
proxy
services
to
get
you
know
in
our
proxy
services
for
basically
any
operation
you
write,
can
now
get
data
in
or
take
it
out
of
the
blockchain
just
like
that.
A
So
when,
if
we
can
get
this
working,
what
we're
gonna,
what
we
just
wrote
up
and
that's
gonna,
allow
us
you
know
to
basically
have
that
the
blockchain
as
this
this
this
merged
the
merge
command
that
we
have
between
sources.
The
blockchain
is
going
to
be
sort
of
our
our
transparent,
like
interface,
because
it
can
operate
as
this
flexible
graph
database.
So
we
won't
we'll
have
this
lossless
lossless
translation
between
sources,
okay,
great,
because
we
can
encode
as
much
metadata
as
we
need
all
right.
So
thank
you
for
watching.