►
A
On
those
legacy
infrastructures,
the
technology
of
wholesale
cbdc
is
what
we
see
from
the
project
right
now,
and
the
pilot
projects
at
this
point
is
that
it's
mostly
predominantly
dlp.
So
it
is
used
much
as
tokenized
money
as
tokenized
central
by
digital
currency,
so
it
is
accessible.
To
I
mean
the
representation
of
the
money
is
as
tokens
and
the
requirements
to
introduce
whole
sensibilities
is
that
it
has
to
be
highly
interoperable
with
other
payment
systems.
A
B
You
know,
I
think
this
looks
great.
I
want
to
watch
this
some
other
time.
So
let
me
add
this
to
the
thing.
A
The
first
approach
could
be
into
the
enhanced
compatibility
model
of
cbdc.
What
does
that
mean?
Multiple
cbds
and
transfers
are
handled
by
private
settlement
companies,
so
every
central
bank
develops
its
own
wholesale
central
bank
digital
currency
system,
and
then
they
let
the
companies
which
have
a
presence
in
each
country
to
handle
transactions,
handle
wholesale
cbdc
transactions
through
their
banks.
So
those
banks
who
have
an
international
presence
have
a
huge
advantage
because
wherever
they
are,
they
can
access
central
bank
digital
currencies
and
they
can
settle
them
with
them.
A
Interlinked
cbd
systems,
interlink
cbd
systems
can
happen
via
a
technical
interface
or
a
centralized
clearing
system
or
decentralized
cleaning
process.
What
does
that
mean?
It's
similar
to
the
previous
one?
So
every
central
bank
develops
its
whole
associability
system
to
to
like
to
replace
its
real-time
gross
settlement
system,
the
incumbent
one
and
then
via
technical
interface
or
clearing
processes.
Those
systems
are
interconnected,
so
it's
not
the
banks
and
the
bank
subsidiaries
who
are
connected
to
each
other.
A
It's
it's
the
the
whole
banking
system
of
each
central
bank's
jurisdiction
that
is
interconnected
and
the
third
one
and
the
most
integrated
one
is
the
single
system
for
multiple
cblc's.
So
it's
a
single
multi-currency
system,
a
single
rulebook
and
a
set
of
participation
requirements,
which
means
that
there
is
only
one
system
where
the
central
bank
digital
currencies
are
minted,
are
created
and
settled.
There
are
no
distinct
systems
in
place
all
right.
Why
are
horses
cbd
systems
necessary?
A
Because
there
are
a
lot
of
frictions
in
the
current
corresponding
banking
arrangements?
The
correspondent
banking
system,
as
you
might
know,
nowadays,
if
you
initiate
a
transaction,
it
has
to
go
through
a
lot
of
banks
to
reach
an
international
destination,
and
the
transaction
itself
has
very
limited
transparency.
B
B
Is
this
I
don't
want
to
watch
that
okay,
so
this
is
interesting
so
why?
Why
was
this
interesting,
so
central
bank,
digital
currency,
so
the
thing
we're
about
to
do
next
is
basically
we're
going
to
go
to
we're
going
to
go
to
our
terminal
here
and
we're
going
to
create.
B
You
know
this
unbroken
chain
of
alice's
alice's.
Is
this
and
in
doing
that,
we're
going
to
establish
first
off
we're
going
to
establish
an
identity
right,
and
so
we
there's
some
comments.
Basically,
what
we'll
do
in
the
future
is
we'll
link
web
to
identity
with
web3
identity,
but
for
now,
for
now,
what
we're
going
to
do
is
we're
going
to
focus
on
tb
dex.
As
our
you
know,
our
bid
mechanism
to
get
jobs
done
we're
going
to
focus
on
dids
as
manifests.
B
In
order
to
like
did
methods,
I
think,
is
probably
more
of
the
right
term
as
manifest
which
we're
using
tb
decks
to
bid
on
and
this
central
bank
digital
currency
thing
is
interesting
because
we're
the
way
that
we're
going
to
do
bids.
So
we
we
so
system
local
resource
management.
So
what
was
that
issue
all
about?
B
Well,
you
know
back
back
a
long
time
ago
now,
when
this
project
started,
this
was
all
about
cloning,
git
repos,
and
so,
if
you're,
cloning,
a
lot
of
gate,
repos
you're,
not
gonna,
you're
gonna
run
out
of
disk
space
right.
So
the
goal
was:
how
could
we
facilitate
somehow
you
know
this,
this
theoretical
system,
local
resource
management?
You
know
it's
going
to
help
us.
B
It's
it's
going
to
help
us
it's
going
to
help
us.
You
know
basically
manage
our
disk,
our
underlying
resource,
as
is
applicable
to
the
locality
of
what
we're
trying
to
reserve
right,
which
is
the
the
system,
local
locality,
right,
disc
or
c
groups
or
whatever
right.
You
know,
basically
we're
we're
on
this
system.
Okay,
that's
our
locality,
and-
and
so
now
we've
established
that
we're
basically
going
to
be
able
to
you
know,
use
input,
operations
and
traverse
our
graph
to
to
determine
locality
and
and
help
us.
B
You
know,
have
other
operations
with
him,
but
output.
Due
time
of
you
know,
we'll
we'll
have
to
do
some
some.
How
can
we
do
that?
Oh
well,
we
have
locking,
so
I
think
we
can
hopefully
yeah.
We
should
with
the
hierarchical
locking
stuff
that
should
help
us
with
time
of
check
time
of
use
on
this
we're
going
to
have
to
to
double
check
that,
but
it
should
help
us
with
that
yeah,
so
yeah
that
locking
stuff
will
actually
do
this
for
us.
Yes,
I
will
perfect
okay,
so
okay!
B
Well,
where
are
we
going
with
this?
So
basically
yeah?
Let's
go!
Let's
go
look
at
tb
dex
and
see
how
we
can
so
what
we're
going
to
do
is
we're
going
to
issue
a
request,
so
we're
going
to
have
multiple
types
of
system.
Contacts
right
and
we'll
probably
have
dids
for
we'll
probably
implement,
did
methods
for
each
of
them.
So
there's
the
did
here.
So
basically,
what
we
found
out
about
dids
is
that
you
know
there's
the
identifier
and
then
there's
the
method
on
the
identifier.
B
So
this
maps
perfectly
to
our
sort
of
you
know
one
always
one
level
deep
concept
right,
so
we
can
make
a
did
method
for
every
single
operation
and
the
id
will
basically
encode.
B
The
id
will
be
the
unique
id
for
the
arguments
that
we
gave
for
that
method,
and
this
way
we
can
use
you
know
these
peer,
dia
or
the
dids
in
general
and
their
associated
docs
as
the
manifest,
because
the
did,
including
the
method
encodes
the
shikima
and
then
the
you
know,
and
possibly
also
within
the
you
know,
the
the
the
could
could
potentially
be
yeah
you
you
could
you
could
encode
the
we
have
to
find
a
way
to
get
to
get
the
schema
out
of
there.
So
maybe
it's
a
mapping.
B
I
don't
really
love
that
it
doesn't
really
encode
the
schema
for
you.
So
we'll,
probably
basically,
we'll
probably
have
to
say
a
did
method
that
includes
a
schema
within
the
data
of
the
did
or
the
did
dock.
Basically,
so
things
like
that
service.
If,
if
if
it
includes
you
know
if,
if
if
it
has
like
a
little
they'll,
they'll
require
some
section,
that's
kind
of
like
service
that
we're
going
to
need
for
all
these
manifest
style
did
docks
so
that
we
can.
B
We
can
have
the
spec
the
the
the
spec
in
there
when
the
spec
should
probably
be
referenced
as
another
did,
and
then
or
this
schema
I
mean
so,
we
should
have
a
did
for
the
shima
yeah.
Okay,
let's
do
it
so
we
should
have
a
did
for
schemas
and
I
think
I
might
have
seen
a
shima
did
in
there.
B
B
B
B
Okay,
so
treat
did
methods
as.
B
Manifest
right
because
the
manifest
is
a
contract
right,
so
we
can
basically
accept
these
dids.
We
can
use
db
decks
to
bid
on
the
dids
right
and
the
dids
will
be
the
jobs
that
we're
bidding
on
doing
right
and
the
jobs
that
we're
bidding
on
doing
are
the
operations
and
the
operations,
maybe
a
whole
data
flow
right
and
so
forth.
Okay,
so
treat
the
ideas
manifest.
B
B
Yeah
and
then
maybe
the
data
flow
id
and
then
the
operation
name:
okay,
open
architecture,
the
data
flow
id
and
the
operation
name.
B
B
Use
tb
dex
to
create
bids
so
create
manifest,
did
method,
define
so
define.
So
we
need
to
define
the
manifest
did
method.
We
need
to
use
tb
dex
right.
So
what
are
we
doing
so
define
manifest
tv
did
method,
and
why
so?
Why
is
this?
Why
is
this
we're
treating
remember
we're
treating
everything
as
a
supply
chain
right?
So
if
I'm
I'm
going
to
basically
because
we're
doing
this
data
flow
based
approach
right.
B
So
if
I
blow
up
one
piece,
I
need
to
rebuild
those
pieces
to
get
back
to
where
I'm
supposed
to
be
in
the
chain
right
so
define
the
the
manifest
did
method.
So
you
know
it
will
have.
B
If
we
define
as
a
did
method-
okay,
so
did
I
I
saw
somewhere
that
basically
there's
the
way
that
the
it's
either.
Is
it
the
purity
ids
or
is
it
the
ids
conflict
resolution
followed
by
pure
deities
deltas,
do
not
make
conflicts.
B
Okay,
so
these
are
ledger
for
vacuum,
search.
B
Relax
yep,
all
we
need
is,
or
blockchain
maintained
by
pure
consensus,
yeah.
What
we
need
is
a
closer
to
the
approach
of
triple
signed
receipts
or
cri,
not
alleged
yeah
see.
This
is
why
this
is
why
this
is
different.
This
is
why
this
is
the
critical
thing
that
makes
this
different
than
the
rest
of
blockchain.
B
Okay
see
this,
and
this
is
just
okay,
so
maybe
we
need
to
build
on
pure
dids.
Can
we
build
on
pure
dids?
Is
there
sort
of
like
some
kind
of
concept
of
subclassing
so
that
we
can
treat.
B
B
B
B
B
This
is
a
free
stuff.
If
we
can
use
this
stage
keys,
let's
see
okay,
so
this
would
be
if
we
can
use
ssh
keys.
This
is
a
this
is
just
this
is
if
we
can
use
this
stage
case.
That'd
be
great.
That
would
just
simplify
things.
A
lot.
A
A
B
B
Although
creating
a
pure
did
and
the
genesis
version
of
hdid
document
done
at
any
time,
it
does
not
require
registering
a
pure
require
purity.
Id
with
another
party
relationships
requires
a
specific
protocol.
It's
the
only
protocol
that
must
be
supported
by
quotation
at
target's
layer
to
be
or
layer
two
be
support.
B
Creates
a
stored,
okay
method,
one
okay
generation
method
and
unique
numeric
bias
underline
a
pdid
must
be
generated,
one
of
the
following
ways,
so
I
think
we
need
yeah
so
inception
key
without
doc,
if
no
mal
go
equals.
Zero.
Okay,
for
example,
did
key
flank
is
equivalent
to
did
okay,
so
a
single
key,
I
don't
know
public
key
value
is
a
pair
for
a
numeric
basis
of
the
did.
The
genesis
version
of
the
did
doc
is
considered
to
be
empty.
Granting
all
privileges
to
this
key.
B
B
B
B
B
B
Okay,
so
inception
key
without
doc.
Okay,
so
we
need
to
create
okay.
So
if
we
do
not
have
an
identity,
we
are
going
to
create
an
identity
by
creating
a
new
did
key.
This
is
going
to
be
basically
our
our
root
asymmetric.
Key
right.
All
of
our
trust
relationships
are
going
to
be
based
off
of
this
you're,
going
to
be
tied
back
to
this
key
for
this
entity
or
for,
and
you
can
blow
this
up
at
any
time.
B
That's
the
thing
so
we'll
save
it
by
default
right,
so
we
can
basically
have
so
we
talked
about
in
in
the
thread.
There's
there's
some
stuff
about
basically
like
we
can
have.
We
can
just
reuse
the
concept
of
overlays
and
we
can
basically
have
this
sort
of.
Like
you
know,
location
like
you
can
have
this
thing,
that
that
runs
on
startup
right
and
you
can
configure
it.
You
know
to
to
to
use
whatever
overlays.
You
know
you
might.
B
You
might
usually
choose
for
your
user
right,
so
maybe
maybe
you'd
like
maybe
you
load
them
from
your
home
there
or
something
right.
It
doesn't
matter,
you'll.
Have
it
or
you'll.
Have
this
itself?
Will
be
a
date
flow
right
and
you
can
change
it
with
an
overlay
so
yeah
so
basically
default
overlay.
Maybe
we'll
have
default
overlay
setting
top
level
context
overlay
setting
overlay
switch
to
command
line.
B
Okay
and
then
use
this
to
pass
data
flow
which
might
load
from
dot
local
right,
so
you
might
load
some
more
stuff
from
your
home,
dir
or
somewhere
else,
always
require
arguments.
People
can
make
aliases
if
they
want
to
obscure.
B
Always
require
argument,
never
load
from
disk
a
default
right
so
basically
always
load
via
emv,
vars
or
cli
or
python
api.
Never
assume
disk.
Okay,
basically,
never
assume
you
have
a
disk
on
this
for
this
project.
Let's
just
not
so
always
assume
data
flow
right
and
that
way,
it'll
be
configurable.
Okay,
I'll
be
back.