►
A
A
Okay,
so
can
we
are?
We
live
all
right,
okay,
so
the
state
of
the
art
so
we're
thinking
here
about.
I
was
writing.
I
was
finishing
the
summary
and
I
wanted
to
say
you
know,
provide
a
little
synopsis
for
people
on
on
what
what
we're
thinking
so
that
they
can
quickly
see
you
know
what
we're
up
to
so
I
I
thought
you
know.
Maybe
we
should
use
this
tag
state
of
the
art,
and
that
way
you
know
we
can.
A
A
A
This
example
did
base
blockchain
using
firefly,
we're
going
to
dump
it
to
cold
storage,
which
is
a
file
we're
going
to
inspect
all
the
records
in
the
chain
and
then
we're
going
to
understand
how
each
record
maps
to
what
is
seen
or
unseen
in
the
firefly
explorer
ui
right.
So
basically,
where
was
the
firefly
stuff
right,
so
tutorials
work
with
custom,
smart
contracts,
firefly
interface,
phone.
A
Okay,
so
basically-
and
then
I
just
I
was
looking
around
and
then
I
basically
found
this
thing
which
says
this
firefly
thing
which
says
you
know,
this
is
how
you
I
have
a
a
create
a
blockchain
event
listener.
So
we
might,
you
know,
use
this
event
listener
endpoint
from
firefly
to
basically,
then,
you
know
run
this
within
kcp
within
dffml
within
kcp,
to
then
practice
a
proxy
to
the
kcp
api
and
the
kcp
and
kubernetes
as
the
api
server.
A
There
is
the
web
2
interface,
and
then
this
you
know,
then
we're
we're.
Communicating,
also
we're
basically
bridging
the
the
kcp
we're
bridging
the
kubernetes
api
server
to
the
did
based
blockchain,
so
that
we
can,
you
know,
issue
our
jobs
on
top
of
kcp,
which
we'll
you
know,
use
for
the
orchestration
right.
A
A
A
So,
basically,
there's
this
concept
of
the
super
node
right
so
from
for
our
basic
implementation,
we
might
say:
hey,
you
know,
let's
just
run
the
super
node
and
then
we
could
plug
in.
You
know,
whatever
framework
that
we
want.
You
know
so.
Basically,
this
proxy
service
just
run
supernote
to
start
write,
operation
to
start
supernode.
A
A
So
write
operation
to
play
supernode
on
kcp
cluster
start
so
listen
within
slash
alongside
kcp
acts
as
web
2
web3
proxy,
where
web
2
is
the
kubernetes
cci.
Api
server
is
proxy
server,
which
you
know.
Maybe
we
run
this
the
super
node
to
start,
but
basically
we're
going
to
write
an
operation
to
play.
Supernote
kcp
cluster
looks
so
this
operation
looks
at
incoming,
so
either
either
listens
and
itself
looks
at
incoming
dids
and
does
something
with
them.
A
A
A
A
A
A
A
Okay,
so
basically
yeah.
We've
then
found
in
the
process
of
me
trying
to
show
you
the
ui,
but
basically
we're
just
going
to
start
a
blockchain
we're
going
to
dump
it
to
cold,
and
hopefully
they
have
some
example
ones
where
we
just
jump
in
and
use
some
of
the
example
data
they
already
have,
and
then
we
will
dump
it
to
a
file.
A
If
it
does
map
to
this
format,
then
we're
going
to
do
you
know-
and
this
is
just
the
triple
still
typical
stuff,
where
you
do
when
you're
reverse
engineering,
your
fuzzing
right,
you're,
going
to
look
at
the
data
format
and
then
you're
going
to
sort
of
you
know
map
to
how
do
I
reconstruct
that
data
format
with
my
potentially
malicious
inputs
if
you're
fuzzing?
In
our
case,
we
want
our.
A
You
know
correct
inputs
right
because
we're
re-implementing
essentially
based
on
we're
we're
implementing
interoperability
by
communicating
through
this
format
right
and
we're
going
to
see.
If
we
can
then
reload
the
format
using
what
we
tried
to
do
to
we're
basically
just
going
to
make
some
stub
operations
which
return
the
static
values
which
are
the
same
values
we
found
from
the
dumped
contents
of
the
blockchain,
and
you
know
obviously
we're
going
to
accept
that
the
ids
are
going
to
differ
and
maybe
the
keys
are
are
going
to
differ.
A
But
as
long
as
when
we
import
it
into
firefly,
it
can
see
all
of
the
nodes
and
all
the
relations,
and
we
can
then
you
know
maybe
still
add
some
things
and
and
use
the
the
data
right.
Then
we're
going
to
assume
that
okay,
we
can
have
interoperability
as
long
as
we
serialize
this
format,
and
we
have
already
serialized
this
format.
So
then
the
next
thing
we
need
to
worry
about
is
import
from
that
format
right.
But
we
don't
have
to
tackle
that.
A
Yet
we
would
tackle
that
after
we
do
the
dataflows
class
stuff
and
then
we
looked
and
we
we
saw
that
that
there's
this
thing
about
custom
contracts
and
that
you
know
you
can
they
have
this
event
listener.
And
so
we
were
thinking
down
the
line
as
we
go
to
do
this
deployment
where
we
want
to
use
our
orchestration
via
kubernetes
through
the
kubernetes
api
server
and
therefore
kcp.
A
Potentially
even
you
know,
makes
that
that
that
that
maybe
that
thing
that's
in
your
edge
deployment
situation,
maybe
you're
running
kcp
on
your
it
device
right
and
then
you
say:
hey
you
know,
I'm
gonna
need
a
connection
to
a
super
node
right,
and
so
then
you
communicate
over
via
you
know:
you're
you're,
communicating
via
your
did
baseball
protocol
over
something
like
you
know,
just
like
the
local
wi-fi
right
and
you
say:
hey
you
know,
I'm
I'm
I'm
I'm!
You
know
you
send
this
the
id
out
over
the
local
wi-fi.
A
You
know
I
need
to
make
a
connection
to
this
machine
locally
and
it's
kind
of
like
this
discovery
protocol
and
once
you
have
the
discovery
protocol
going,
you
can
say:
okay,
like
hey,
you
know,
we
talked
did
on
this
discovery
protocol,
and
so
then
you
just
send
a
did
over
to
it
and
it
might
be
running
a
kubernetes
cluster
on
it
internally
and
it
could
spin
up.
It
could
say
it
could
say
hey.
You
know
I
want
to
deploy
super
node,
but
I'm
resource
constrained.
A
So
I
need
somebody
I'm
communicating
out
to
this
network
of
devices.
That's
nearby
me
and
I'm
saying
I
need
super
node.
Does
anybody
have
a
running
super
node
that
they
can
communicate
over
this
channel,
which
might
be
this
underlying
channel,
which
is
like
this?
You
know
tcp
that
we
discovered
on
the
on
the
local,
the
the
local.
You
know
the
the
maybe
the
local
lan
right,
where
we
did
some
udp,
the
multitask,
the
multi
multicast
or
the
broadcast
the
udp
broadcast,
there's
a
multicaster
broadcast.
A
I
can't
remember
to
find
this
this
local
service
that
talks
did
so
basically
as
soon
as
you
find
something
that
talks
did,
then
you
act
as
a
bridge
right
and
then
you
sort
of
work
together
right.
The
devices
work
together
because
they
send
out
the
pieces
of
the
strategic
plans
that
they
want
the
other
devices
to
help
them
with
right,
and
so,
if
these,
if,
if
you're
an
iot
device
and
you're
like
hello,
hello,
you
know
I
just
came
online.
I
need
a
wi-fi
network
right.
I
think
there's
some
stuff
going
on
about.
A
Basically,
look
at
the
did
and
they
decide
you
know:
okay,
based
on
the
properties
of
it
and
what
it's
requesting
you're,
applying
the
appropriate
sandboxing
before
you
actually
issue
the
request
right
to
the
kubernetes
api
server
to
launch
that
job
right,
and
that
is
sitting
within
this
little
this
little
that
you
know
whatever
this
container
is
that's
running
or
you
know
or
whatever.
Maybe
it's
not
a
container,
maybe
it's
just
a
little
web
assembly
process,
or
maybe
it's
just
a
little.
You
know
c
processor
rust
process
on
this
little
iot
device.
A
That's
just
sitting
there
and
it's
like
you,
know
awaiting
dids
and
then
doing
method
calls
right,
and
it's
doing
so
it's
rpc,
but
it's
rpc.
So
it's
rpc
on
everything
asynchronously,
with
sort
of
the
assumption
that
you're
going
to
be
having
some
ml
models
run
in
there
and
you're
doing
these
configurable
asynchronous
event:
loop
based
rpcs,
so
it
really
is
like
you're
running
all
this
little
web
you're
really
you're
running
all
this
little
web
assembly.
A
But
you
know
all
of
that.
You
would
be
calculated
when
you're
sending
this
stuff
out
and
then
communicating
back
and
so,
okay
and
so
okay,
so
yeah,
so
that's
kind
of
just,
and
so
in
that
proxy
you
know.
Basically
you
can.
You
can
sit
your
this
is
where
you
can
sit
your
input,
validation,
and
this
is
where
you
consider
trust
boundary,
really
nicely
right
so
and
you
can
have
those
different
inputs
as
they
get
decoded
out
of
these
different
dids
or
sources
before
they
go
into
the
kubernetes
api
server.
A
You're
validating
them
and
then
you're,
maybe
validating
and
splitting
off
and
running
and
instantiating
new
kubernetes
api
servers,
which
are
going
down
and
building
and
calling
into
these
synthesized
crds,
which
are
then
calling
into
the
you
know
underlying
operations
which
are
actually
the
little
python
functions
right
or
whatever
functions
in
whatever
language
right.
And
so
you
can
then
leverage
your
data
flows
and
your
overlays
and
all
of
that
to
make
sure
that.
A
That
you
can
leverage
your
data
flows
and
overlays
and
all
that
to
be
sure
that,
before
anything
calls
any
api
because
you're
allowing
arbitrary
people
to
do
remote
code
execution
just
like
kind
of
a
browser-
you've
sandboxed
the
permissions
within
your
user's
degree
of
comfortability
right.
So
this
is
basically
like.
A
A
You
know
like
timing,
side
channels,
and
all
this
like
forget
that
we're
gonna
give
you
a
set
of
defined
interfaces,
sort
of
like
the
browser
api
right
and-
and
we
can
come
to
agreements
as
ad
hoc
groups
of
devices
and
individuals
working
to
different
sort
of
in
different
sort
of
areas.
What
these
interfaces
are
right
and.
A
And
so
basically,
then
we
overlay
those
and
we
apply
those
as
like.
You
know
the
cross
between
the
truss
boundary
and
the
input
validation,
and
then
you
can
also
bake
in
your
system
of
reward.
I
believe
using
some
of
these
did
things
and
and
and
the
smart
contracts
aspect
of
that.
But
then
you
basically
yeah
you,
then
you
add
in
all
the
provenance
information
also.
So
this
has
been
another
video
and
I've
said
the
same
thing,
a
different
way,
a
few
more
times,
so
you
know
give
give
give
some
feedback.
A
If
you
will,
if
you,
if
you
feel
that
I'm
sure
things
are
not
clear,
please
let
me
know
what
is
not
clear.
I
think
I
appreciate
sahil
coming
on
today
and
talking
that
was
fun.
It's
good
to
to
to
hear
some
some
some
more
feedback
talk
to
a
few
people.
I
think
we're
getting
more
feedback
on
this,
but
you
know
we
gotta
come
together
and
you
know
collaborate
on
that
on
on.
You
know,
throwing
some
ideas
at
the
wall
here
and
see.