►
A
All
right,
okay,
so
what's
the
title
of
this
video,
a
web3
software
supply
chain,
okay,
so
yeah,
so
basically,
the
thing
is
all
we
have
to
do
is
all
we
have
to
do
is
just
encode
to
this
format
and
we
get
a
web3
software
supply
chain
for
free.
We
don't
have
to
do
anything
other
than
save
to
this
format.
Like
that's
the
beauty.
That's
that's
that's
part
of
that's
part
of
why
this
is
so
exciting,
with
these
dids
right
so
yeah.
A
So
this
is
part
of
why
it's
so
exciting
with
these
dids
right,
because
if,
if
we
we
had
to
implement
caching
right
going
around
looking
for
some
caching,
you
know
like
looking
for
what
to
do
there
right.
Finally,
this
did
stuff
becomes
clear
in
in
working.
You
know,
with
other
developers,
on
our
project,
realizing
we're
going
to
need
to
share
the
information
that
we're
work,
we're
caching,
right
and
lo
and
behold
this.
This
did
stuff,
looks
perfect
and
then
realize
what
if
this
is
web,
3
stuff?
A
What
about
the
interoperability
with
the
other
blockchain
ecosystems?
Well,
it
turns
out
there's
this
hyperledger
cactus
project
and
it
might
be
able
to
help
us
with
that.
So
yeah
so
excited
about
that
and
excited
about
all
this
stuff.
So,
let's
see
okay,
what
else?
Well
we're
looking
at
some?
Oh
looking
at
some
some
yeah
more
of
the
remember
the
s-bomb
right,
so
we're
going
to
go
and
generate
a
bunch
of
s-bombs
with
cbe
bend
tool
and
then
in
the
process
of
generating
them.
We're
going
to
you
know
run.
A
So
what
we're
going
to
do
is
we're
going
to
integrate
with
cv
bin
tool.
We
are
going
to
then
run
cv
bin
tool
on
the
integration,
with
cv,
bend
tool
itself
by
running
a
the
job
in
a
workflow
right
and
so
we're
gonna
use
our
kubernetes-based
executor
to
run
the
job
in
a
workflow
or
run
the
workflow
as
a
kubernetes
job,
and
then
we're
going
to
snapshot
the
environment
when
it's
done
right.
A
Take
that
container
before
it's
spun
down
run
through
our
cv,
bend
tool,
checker
right
now,
data's
on
chain,
okay,
so
where's
the
chain.
I
have
no
idea
yet
all
right,
probably
a
bunch
of
json
files
or
something
who
knows
we'll
figure
it
out.
Maybe
the
mysql
connector,
we'll
put
it
in
my
sql,
we'll
put
it
in
my
sql
blockchain
now
on
mariadb
didn't
see
that
one
coming
did
you,
so
that's
the
beauty
of
these
things.
You
can
put
them
wherever
you
want
so
yeah.
We
have.
A
A
Now
we'll
have
our
centralized,
but
at
the
same
time
distributed
database
and
the
other
thing
is
so
we
can
do
basically
we're
just
going
to
throw
the
did
objects
in
there
right
now,
right
we're
going
to
throw
the
whole
blob
now.
Why
are
we
going
to
do
that?
Why
are
we
going
to
throw
the
whole
blob
because
we're
going
to
be
lazy
right
now,
we're
just
going
to
whole
blob
now.
The
thing
is
because
everything
is
a
data
flow.
A
You
can
have
these
arbitrary
little
translation
layers
here
and
there
and
you
can
apply
them
all
as
overlays
over
whatever
you
want.
You
know
so:
oh
hack,
the
box
yeah,
oh
we're
going
to
spin
up
a
bunch
of
hack,
the
box
stuff
later
that'll
be
months
from
now.
Let's
see
I
forgot
to
do
that,
okay
and
we
can
close
this
yeah
so
basically
and
then
and
then,
and
and
and
and
we're
going
to
so
so
so
we're
also
going
to
build
this
this
this.
A
A
You
know
better
for
ourselves
right,
because
this
is
our
developer,
tooling,
that
we're
making
here
right,
and
so
she
needs
to
know
about
our
development
process
and
environment
and
and
and
you
know
how
things
evolve
in
order
to
really
you
know
in
order
to
really
understand
us
as
a
developer
and
help
us
right.
So
so
what
are
we
going
to
do
we're
going
to
leverage
key
base?
A
So
if
you're
not
familiar
with
key
base,
go
check
it
out,
so
we're
going
to
go
leverage
key
base
and
we're
going
to
leverage
key
base
as
an
oracle
and
in
my
understanding,
so
once
again
you
know
I'm
not
not
the
world
expert
on
blockchain
by
any
means
at
all.
So
but
my
understanding
of
the
term
oracle
as
it
relates
to
blockchain
stuff,
is
that
the
oracle
is
sort
of
this
thing
that
you
trust,
and
so
we
are
going
to
say
that
we
trust
key
base
to
link
people's
identities
for
us.
A
A
A
So,
let's
see
so
and
remember,
we
can
overlay
so
we're
going
to
make
data
flow
as
class,
which
means
each
of
these
is
going
to
be
a
data
flow
itself,
each
block
and
we
can
overlay
and
we
can
have
different
instances,
different
places,
and
so
what
we
can
do
is
we
can
have
prioritization,
so
prioritization
can
simply
be
an
overlay
which
you
apply
to
every
operation
right
or
maybe
in
front
of
the
instantiator
right.
So
the
thing
that
instantiates
your
operations-
maybe
you
apply
this
overlay
wrapper
in
front
of
it.
A
So
then
every
every
operation
is
going
to
get
wrapped
via
whatever
data
flows
that
you
overlay
that
may
wrap
it
as
well
right.
So
this
is
how
we
can
add
prioritization.
So
by
default
the
operation
will
get
executed.
If
it's
picked
up
right,
but
the
first
thing
that
will
happen
is
it
will
be
prioritized
right
before
it
gets
executed,
because
the
prioritizer
is
essentially
like.
You
know
it's
like
subclassing
the
operation.
If
the
operation
is
a
single
method
interface-
and
that
brings
us
to
dids,
which
are
basically
this.
A
As
far
as
I
can
tell
like
this
single
method-
interface,
which
is
perfect,
so
the
did
is
the
manifest
the
did
is
the
manifest
they're
they're
like
that
is
we
can
basically
every
manifest.
Is
the
dock
and
there's
the
d
id
and
the
dock,
so
the
manifest
is
the
dock
and
the
d
id
is
the
id
the
unique
id
for
that
doc.
It's
perfect.
This
did
stuff,
they
have
done
a
beautiful
job
and
so
okay,
so
it's
it's.
It's
like
a
primitive
that
we
can
use
that.
A
That
gives
us
both
trust
and
encryption
if
we
need
it
and
communication-
and
you
know
this
extensibility,
it's
this
manifest
format.
It's
this
format
right
that
the
odap,
odap
and
dids,
a
part
of
that
are
this.
They
make
up
this
format
right
and
the
way
that
we
get
the
data
on
and
off
the
chain
right
and
now
how
how
we
deal
with
these
off
chain
contracts
right.
This
is
how
we
introduce
you
know
this
architecture
of
of
of
sort
of
saying
you
know,
here's
what
you
could
do
with
the
data.
A
That's
on
the
chain,
like
here's,
how
you
here's,
how
you
link
the
ids
together,
basically
like
to
do
programs.
You
know,
like
that's,
that's
what
we're
saying
right,
we're
saying:
here's
how
you
can
use
these
did
methods
right.
Here's
a
set
of
did
methods
which
you
can
use
to
construct
this
open
architecture,
the
standard
architecture,
whatever
this
alice,
this
execution
environment
for
alice
right,
because
if
we
all
speak
this
execution
environment,
then
we
all,
then
we
all
can
execute
these
versions
of
alice
which
are
out
on
the
chain.