►
From YouTube: Hyperledger in-Depth: Tokens in Hyperledger Fabric: What’s possible today and what’s coming
Description
Tokenizing the physical world is a hot blockchain topic in the industry, especially as it relates to the trade of tokens as a basis of new forms of commerce. In this Hyperledger Foundation member webinar, the IBM Research team will describe what tokenization use cases are possible with Hyperledger Fabric today, and what enhancements are in the works.
----
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
C
C
C
Okay,
welcome
everybody.
We
are
delighted
to
present
with
you
our
next
hyperledger
foundation,
in-depth
webinar,
with
ibm
talking
about
tokens
and
hyperledger
fabric.
What
is
possible
and
what's
coming
down
the
line
we
have
angelo
ellie
and
actually
two
additional
panelists
joining
us
today,
with
dave,
enyart
and
also
kautar,
so
they'll
be
leading
the
discussion
and
the
presentation
today.
C
We
also
at
the
start
of
all
our
meetings
in
the
hyperledger
committee,
point
your
attention
to
our
anti-trust
policy
that
you
can
find
on
our
website
and
on
our
wiki
as
well.
This
session
is
being
recorded,
so
don't
worry
about
missing.
Anything
and
slides
will
also
be
available
on
the
events
page
our
website
and
the
webinar
page
of
our
website
for
you
to
download
afterwards
as
well.
C
We
encourage
questions,
so
please
raise
your
hand
depending
on
the
time
or
how
many
people
we
have
joining.
I
may
invite
you
to
come
off
mute
to
ask
your
question.
Otherwise,
please
post
them
in
the
q,
a
box
or
even
in
the
chat.
I
will
be
monitoring
them
and
we
will
address
some
of
the
questions
throughout,
but
certainly
save
time
at
the
end
as
well.
A
A
So
we
are
gonna
first
start
to
introduce
what
what
what
made
us
start
working
on
building
token
extensions
for
a
hyperledger
fabric,
then
we
are
going
to
give
an
overview
of
what
is
possible
on
hyperledger
fabric
today
and
then
discuss
the
main
session
of
this
main
topic
of
this
session
on.
What's
coming,
what's
already
there.
A
So
next
slide,
please
so
most
of
the
people
in
this
seminar
are
the
webinar
are
a
part
of
ibm
blockchain
research
team,
which
is
essentially
a
team
very
much
focused
on
enhancing
the
state
of
the
art
on
blockchain
system
for
us,
blockchains
or
transaction
processing
systems,
allowing
mutually
distrusting
participants
in
a
business
network
to
do
business.
Looking
at
one
system
of
records
and
in
that
sense,
distribution
of
trans
transparency,
automation
comes
as
a
very
prominent
set
of
value
propositions
of
this
technology
to
business
networks.
A
A
Promises
of
the
system
itself
as
a
way
to
address
real
use
cases,
while
at
the
same
time
we
want
do
not
want
to
have
unconditional
privacy.
We
wanted
to
marry
it
with
some
level
of
regulatory
compliance
enforcement
and,
in
particular,
audit
support
this
becoming
quite
challenging
when
one
needs
to
consider
the
variation
of
regulation
across
different
countries.
A
A
blockchain
system
is
to
operate
next
slide.
Please
so
clearly
in
this.
In
this
talk,
our
focus
is
asset
exchange
and
tokens
are
the
representation
of
digital
lessons
in
blockchain
systems
of
different
incarnations
of
different
types
of
digital
assets,
depending
on
the
industry
you're
looking
for,
but
the
most
prominent
use
of
the
token
asset
we
are
going
to
present
today.
The
token
capabilities
are
going
to
present
today
is
in
the
context
of
central
bank
digital
currency
and
not
because
they
cannot
be
used
elsewhere.
A
On
the
contrary,
it's
pretty
generic
the
capability
that
we've
put
in
place,
but
it's
rather
that
they
have
been
already
been
integrated
into
a
very
mature
central
bank,
digital
currency,
experimentation
that
I
will
elaborate
on
in
that
bit
next
slide,
please
so.
Central
bank,
digital
currency,
architectures,
a
very
typical
one,
is
the
one
separating
this
into
multiple
tiers
on
the
top
tier.
We
have
the
the
the
wholesale
networks
where
central
banks,
commercial
banks,
engage
into
transactions
among
them
and
they
can
be
either
locked
dlt
based.
A
Clearly,
as
as
I
mentioned
before,
requirements
on
the
privacy
side
and
regulation
enforcement
side,
as
well
as
interoperation,
become
sits
at
the
very
top
of
the
list
and
their
next
slide.
Please,
and
then
we
have
worked
with
a
set
of
a
set
of
entities
from
the
banking
industry,
central
banks,
as
well
as
big
commercial
banks
into
building
central
bank
digital
currency
systems
on
the
wholesale
side
and
the
way
the
assets
that
we
produce.
A
A
A
D
Okay,
thanks
a
lot
ellie
next
slide.
Please
there
you
go
so
I'm
going
to
go
very
quick
before
we
get
to
the
main
event
here
with
angelo
just
to
baseline
everybody
about
what's
their
current
fabric
and
everything
I'm
talking
about,
you
can
see
in
the
fabric,
documentation
the
fabric
tutorials
and
the
fabric
samples,
so
fabric
naturally
aligns
very
well
to
non-fungible
tokens
with
its
state
model,
being
a
key
value.
D
State
maps
very
nicely
to
a
non-functional
token,
where
there'd
be
some
type
of
identifier,
unique
identifier
for
a
token,
along
with
some
attributes
of
that
token,
such
as
a
current
owner,
and
maybe
some
properties
like
I
have
here
in
the
slide,
color
size
and
appraised
value
as
examples,
but
those
properties
might
be
in
the
clear
they
might
be
hashed.
They
might
be
represented
off-chain
by
some
some
reference,
url
link
or
something
like
that.
D
E
D
The
in
the
hyperledger
fabric,
samples
repository-
basically,
there
are
variations
on
this
theme
with
different
showcasing
different,
typical
token
patterns.
So
you
can
think
about
different
styles
of
ownership,
different
styles
of
endorsement
multi-party
agreement
and
privacy
as
being
some
of
the
key
patterns
that
we
see
in
the
token
space,
especially
around
non-fungible
tokens.
D
So
for
ownership,
it
could
be
a
certain
enrolled,
client
identity
that
owns
a
token
or
it
could
be
a
certain
organization
level
that
or
that
owns
a
token
for
endos
and
for
endorsement
it
could
be
some
static
set
of
endorsers
that
are
required
for
a
certain
smart
contract
or
it
could
based
be
based
on
the
asset
itself.
Typically,
that
might
be
the
the
owner
of
the
asset,
or
maybe
some
custodian
of
the
asset
multi-party
agreement.
D
So
we've
got
samples
here
that
talk
about
when
a
buyer
and
seller
of
a
token
might
want
to
come
to
terms
on
that
transfer
before
the
actual
transfer.
So
maybe
they
have
to
agree
on
some
price
or
some
other
specifics
about
the
token,
and
they
can
manage
that
that
agreement
in
the
chain
code
prior
to
the
actual
transfer
and
then
finally
privacy.
D
So
many
people
use
the
the
fabric,
private
data
collections
to
manage
privacy,
so
this
will
keep
hashes
on
chain
as
opposed
to
the
actual
token
data
and
the
actual
token
data
will
be
shared
amongst
authorized
parties
by
fabric
or
you
could
manage
the
assets
on
your
own
application
and
just
post
hashes
or
a
url
link
or
something
like
that
to
the
to
the
fabric.
Blockchain
next
slide,
please,
okay
and
then
it's
not
just
non-functional
tokens.
D
So
a
lot
of
our
tutorials
talk
about
an
asset
transfer
model
which
is
really
a
non-fungible
token
model,
but
really
the
fabric
states.
You
can
model
anything
really
in
a
smart
contract,
and
so
we've
got
samples
of
how
to
model
erc,
20
and
and
erc
1155
and
721
tokens
along
with
a
typical
utxo
token.
So
in
a
utxo
model
you
might
think
of
the
states
as
being
the
unspent
transactions
in
an
erc20
model.
D
You
would
think
of
the
states
as
being
accounts
that
might
have
ownership
of
a
certain
number
of
tokens
and
then
similar
for
non-functional
tokens
and
erc
1155
tokens.
So
we've
got
examples
of
how
to
do
all
these
things
with
fabric
chain
codes,
so
I'll
leave
it
there
for
in
terms
of
the
base
fabric
capabilities,
you
can
look
at
more
in
into
more
details
in
the
fabric
docs
and
the
fabric
tutorials
and
samples,
but
I'll
pass
it
over
to
angela
to
talk
about.
What's
coming.
B
E
E
So
when
it
comes,
this
is
description
of
the
transfer
when
it
comes
to
the
issue.
The
issue
is
just
a
transaction
where
we
have
output.
We
do
not
have
input,
because
we
assume
that
there
is
some
sort
of
entity
that
introduces
that
is
allowed
to
introduce
token
into
the
system,
and
we
check
just
whether,
whoever
if
the
origin
of
this
transaction
is
allowed
to
perform
this
operation
or
not
so
this
is
seems
to
be
nice.
This
is
something
that
would
allow
us
to
do
token,
operation
name
the
issue
and
transfer.
E
We
could
also
do
redeem
to
some
extent
by
thinking
that
a
redeem
is
just
a
transfer
where
the
owner
is
empty.
However,
we
could
see
that
there
is
an
issue
here,
which
is
the
lack
of
privacy,
so
whoever
is
actually
whoever
has
access
to
the
ledger.
Could
just
look
into
the
legend
and
check
and
see
that?
Okay,
there
is
a
transaction
between
a
and
b.
This
is
the
value
of
the
transaction.
E
This
is
the
type
of
transaction
that
are
being
the
type
of
asset
that
are
being
transacted
and
based
on
that
they
could
actually
derive
some
sensitive
information.
It
could
be
in
the
case
of
payment,
it
could
be
the
behavior
of
user,
and
if
we
are
talking
about
business
or
banks,
it
could
be
the
business
relationship
between
banks.
E
We
would
hide
the
identities
of
the
transacting
parties
in
a
way
that
the
validator
would
be
able
to
check
whether
the
transactions
are
valid
or
not,
without
knowing
the
parties
behind
the
transaction
or
accessing
the
content
of
the
transaction,
and
this
is
done
using
very
standard
cryptographic.
Techniques
that
are-
and
I
think
you
are
familiar
with
it-
zero
knowledge
proofs
and
with
the
combination
with
anonymous
signatures
and
zero
knowledge.
E
Proofs
allows
us
to
do
this
magic
things,
which
is,
I
could
verify
whether
something
is
correct
or
not,
without
really
knowing
actually
much
information
about
whatever
I
am
verifying.
I
just
know
that
this
transaction
is
valid,
but
I
will
not
really
know
who
is
behind
it
or
what
is
being
transferred
or
how
much
is
being
transferred.
E
However,
when
it
comes
to
for
privacy,
there
is
an
issue,
especially
if
we
are
talking
about
regulated
industries.
So
if
we
talk
about
financial
industries,
these
are
regulated
one
where
you
have
to
have
some
level
of
accountability
and
auditability
so
for
privacy.
Full
privacy
is
good
like
if
we
hide
all
the
information
of
all
the
transactions.
This
is
good,
but
this
is
also
gives
rise
to
another
problem.
E
If
you
take
the
case
of
payments
like
how
would
we
ensure
that
there
is
no
money
laundering,
how
would
we
ensure
that
there
is
no
financing
of
criminal
criminal
activity,
so
these
are
applications
that
require
some
level
of
auditing
by
authorized
parties,
and
this
means
that
some
parties
should
be
able
to
learn.
Thank
you.
Some
parties
should
be
able
to
learn
the
content
of
the
transactions
when
the
need
arises.
E
E
If
there
is
some
suspicion
that
this
transaction
is,
let's
say,
malicious,
there
is
some
sort
of
bad
behavior
happening
and
we
need
maybe
to
detect
it.
Sometimes
we
want
to
prevent
it
in
the
sense
we
want
to
do
this
inspection
before
the
transaction
is
even
committed,
because
sometimes
it's
easier
to
prevent
transaction
from
being
committed
than
doing
something
like
a
roll
back.
E
So
this
is
was
one
of
the
goals
of
our
of
the
token
sdk
or
our
work
on
tokens
on
top
of
hyperledger
traffic.
So
we
put
this
at
the
center
of
the
solution.
We
were
designing
in
the
sense
that
there
is
privacy.
Privacy
is
important.
There
were
already
solutions
in
the
literature.
The
most
famous
one
is
zero
cash,
where
you
could
have
all
how
what
we
might
call
for
privacy
guarantees.
But
there
was
this
lack
of
auditing
capabilities
and
our,
and
we
placed
ourselves
in
this
space.
E
In
the
sense
we
will
give
you
privacy,
but
will
also
allow
authorized
parties
to
inspect
transaction
and
detect
bad
behavior
next
slide.
Please
can
you
can
you
go
like?
Can
you
go
through
the
yeah,
the
animation?
Sorry?
So
the
token
sdk
comes
with
very
basic
functionalities
that
we
believe
cover
most
of
the
token
operations,
and
these
are
issue
transfer,
redeem
and
so
on.
So
the
issue
would
allow
authorized
entities
to
introduce
tokens
in
the
case
of
central
bank
digital
currency.
E
These
are
the
central
bank,
then
we
have
transfer,
and
this
would
allow
parties
to
transfer
tokens
between
among
themselves.
We
have
redeemed,
that
is,
it
could
be
privileged
operations,
depending
on
the
use
case,
where
some
entity
could
actually
remove
tokens
from
the
the
blockchain
like
it
is
like
they
will
be
out
of
circulation,
and
then
we
have.
We
have
a
swap-
and
this
is
mostly
when
do
operation
or
two
token
operation
need
to
take
place
automatically.
E
So,
for
instance,
if
I
am
sending
usd
dollars
against,
let's
say
euros,
and
I
want
this
operation
either
to
happen
both
of
them
happen,
or
none
of
them
happens
here.
Of
course,
we
are
assuming
that
both
assets
are
exchanged
on
the
same
blockchain.
But
if
this
is
not
the
case,
then
we
would
need-
and
this
is
something
that
was
mentioned
at
the
beginning,
which
is
the
interoperability.
So
this
is
something
where
you
would
need
across
network
asset
exchange
and
asset
transfer
and
in
some
cases,
asset
transfer.
E
So
the
fabric,
token
sdk
or
the
model
that
the
fabric
token
sdk
relies
on
to
kind
of
have
token
transaction
is
the
utex
or
model
so
the
model
I
spoke
about
at
the
beginning,
and
the
reason
for
this
is
that
ctxo
is
more
privacy
friendly
when
it
comes
to
accounts.
Even
if
you
hide
all
the
information
you
want,
even
if
the
transaction
itself
you
look
at
it
and
you
do
not
see
okay,
what
is
actually
or
how
much
it's
being
transacted
or
the
identities.
E
The
moment
this
transaction
is
committed,
you
would
see
that
there's
been
a
right
into
like.
If
this
is
a
transfer
between
addison
between
a
and
b,
you
don't
know
who's
a
and
b,
but
at
the
time
of
the
at
the
time
this
transaction
will
be
written
into
the
ledger.
You
would
see
that
there
was
a
right
at
position
alpha
and
right
at
position
beta,
and
then
you
say:
okay,
I
mean
I
don't
know
who
transfers
to
whom.
E
But
I
see
that
this
is
a
transfer
between
this,
this
state
and
the
state
it
could
be
from
alpha
to
beta
but
or
beta
from
alpha.
But
I
see
this
so
every
time
there
is
an
account,
let's
say
transfer.
You
would
see
that
there
is
like
this
right,
that's
happening
between
the
same
states,
so
this
is
why
we
adopted-
or
we
opted
for
utex
or
motor,
because
we
believe
that
this
is
something
that
utex
or
model
kind
of
does
with
that.
So
it
actually
prevents
this
leakage.
E
Another
thing
that
the
token
sdk
does
is
that
we
have
this
key
management
that
is
handled
by
wallet,
so
anyone
who's
going
to
use
the
token
sdk
to
develop
application.
They
don't
need
to
worry
much
about
how
they
do
key
management,
because
this
is
something
that
the
token
sdk
offers
for
them.
So
we
have
these
wallets
that
wallets
that
allow
the
developers
to
kind
of
design
their
application
and
in
sort
of
very
transparent
way.
So
the
the
wallet
take
care
of
this
thing.
E
Another
thing
that
the
token
sdk
also
takes
takes
care
of
is
supporting
multiple
privacy
levels,
and
this
is
similar
to
all
it
happens
in
a
transparent
manner.
So
we
want
the
developers
just
to
focus
on
the
business
logic.
They
don't
really
need
to
care
about
the
cryptographic
implementation
that
they
could
track.
Sorry,
hippographic
primitives,
that
underlying
the
privacy,
the
privacy,
preserving
implementation.
E
E
You
don't
really
need
to
kind
of
worry
about
how
to
preserve
privacy,
because
the
token
sdk
would
do
that
for
you
and
back
to
the
point
that
I
mentioned
earlier,
which
is
what
we
believe
is
kind
of
one
of
the
differentiator.
For
the
token
sdk
is
auditability
support,
so
here
we
kind
of
allow
auditors
to
inspect
transaction
and
we
do
it
beforehand.
So
before
transactions
go
to
the
ledger,
we
allow
auditors,
who
are
these
kind
of
predefined
parties
to
access
the
content
of
the
token,
the
transaction
and
sign
them
off.
E
So
if
they
are
okay
with
the
content
of
the
transaction,
the
transaction
will
go
through
if
they
are
not
okay
with
the
content
of
the
transaction,
the
transaction
will
be
stopped
also,
and
one
more
thing-
and
maybe
the
last
thing
I
would
say
on
the
slide-
is
that
we
have
also
support
for
and
non-functional
circles,
and
the
reason
of
this
is
that
our
apis
are
simple
enough
and
kind
of
flexible,
so
they
they're
very
intuitive
that
we
see
that
like
when
it
comes
to
asset.
We
have
like
three
main
operations.
E
This
issue
transfer
redeem
and
to
do,
for
instance,
the
transfer.
You
just
need
to
specify
in
the
case
of
fungible
tokens
that
quantity
and
the
recipients
in
the
case
of
non-fungible
tokens,
you
just
need
to
specify
the
recipient
and
this
by
having
apis
that
are
very
close
to
what
happens
in
the
real
world.
The
token
sdk
allows-
and
you
I
mean
the
token
I
mean
when
we
implemented.
E
We
realized
that
also
the
support
for
mandrel
for
non-fundable
tokens
kind
of
come
for
free
next
line,
and
this
is
one
of
the
and
the
reason
for
this
is
that
the
token
definition
we
started
with
was
also
intuitive.
It
was
very
simple,
so
we
said
a
token
is
defined
by
its
owner
and
the
owner
here
is
an
array
of
fights,
so
it
could
be
a
public
key,
but
it
could
also
be
a
script
that
defines
the
conditions
under
which
a
token
can
be
transferred,
so
it
could
like
in
the
script.
E
You
could
say
I
want
this.
I
want
multiple
public
keys
for
this
token
to
be
transferred.
We
need
the
signatures
of
abc.
It
could
be,
for
instance,
saying
that
this
this
this
token
can
only
be
transferred
after
certain
deadline.
So
this
is
how
flexible
the
ownership
is.
It
gives
you
this
kind
of
ability
to
either
assign
the
ownership
to
a
public
key,
but
also
assign
it
to
a
script.
E
The
token
also
comes
with
the
type,
and
here
the
type
could
be
the
denominator.
For
instance,
in
the
case
of
digital
currency,
it
could
be
the
denomination
it
could
be
usd,
it
could
be
borrowed
for
this,
like
swiss
franc,
but
it
could
also
be
a
unique
identifier,
and
this
is
the
way
we
are
able
to
support
non-punjabi
tokens,
because
if
non-functional
tokens
have
the
thing
where
they
can
like
I
mean
they
are
unique,
that
you
have
the
type
which
is
or
you
have,
they
have
unique
identifiers.
E
The
way
we
support
them
is
that
actually,
these
unique
identifiers
go
into
the
time,
and
this
is
in
this
and
this
because
in
our
token
sdk
we
say
that
tokens
are
fundable
as
long
as
they
have
the
same
type.
So
if
tokens
in
the
system,
if
two
tokens
in
this
system,
they
don't
have
the
same
type,
this
means
that
these
tokens
are
not
fundable.
E
D
E
And
kind
of
defines
like
the
the
the
value
of
the
token,
so
the
tokens
as
long
as
like
the
tokens
that
have
the
same
type,
they
can
be
emerge
and
stick
unless
we
specify
it
like
explicitly
saying.
Okay,
these
tokens
cannot
be
immersed
or
these
tokens
cannot
be
split,
but
if
the
type
is
different,
the
token
cannot
be
merged
or
split.
B
Thank
you.
Thank
you,
carter,
okay,
back
to
me,
let's
let
let's
go.
Let's
do
a
deeper
dive
now
into
the
core
of
the
the
token
sdk.
Let
me
let
me
let
me
say
first
that
probably
I'm
pretty
sure
that
some
of
you
already
know
I
already
already
dealt
with
zero
knowledge
and
know
the
complexity
of
dealing
with
these
cryptographic
primitives,
especially
if
you
put
them
in
a
very
complex
in
the
context
of
a
very
complex
protocol.
So
our
fundamental
our
key
design
principles
have
been
very,
very
few
but
very
clear.
B
First,
hide
the
complexity
of
handling
very
complex
cryptographic,
cryptographic
primitives
in
such
a
way,
the
developer
doesn't
have
to
know
directly
that
zero
knowledge
is
employed
or
any
other
cryptographic
techniques
technique
is
used.
The
belief
is
just
that.
The
the
token
sdk
knows
what
to
do
at
what
time
and
it
delivers
a
private
private
institute
private,
secure
experience.
B
Then
we
wanted
to
to
say
the
following.
We
would
like
to
write
our
token
application
once
and
then
decide
later,
which
kind
of
privacy
guarantees
we
want.
From
our
token
system
example,
for
example,
in
some
cases
we
might
not
need
to
hide
anything
about
the
tokens
if
the
fact
that
they
are
in
clear
is
fine
for
the
application
for
other
things,
we
prefer
to
have
certain
to
hide
certain
piece
of
information.
B
In
other
cases,
we
want
to
go
full
scale
and
hide
as
much
as
much
as
possible,
but
in
in
doing
this
we
don't
want
the
developer
to
write
again
and
again
and
again
the
same
application
just
adjusting
the
api.
The
calls
to
the
api,
depending
on
the
privacy
level,
so
bright
once
adjust
later
set
later,
the
privacy,
the
the
privacy,
the
privacy
level.
Therefore,
we
designed
a
family
of
stacks
that
deliver
this
experience
to
to
the
developer,
to
implement
token
based
application
token
based
application.
B
Today,
we
focus
mostly
on
the
token
sdk
on
on
the
token
sdk
itself,
but
it
sits
on
top
of
what
it's
called
the
fabric:
smart
client,
that
is
another
component,
it's
another
hyperledger
project,
labs
that
delivers
peer-to-peer
infrastructure
and
other
facilities
and
connection
into
blockchains
and
so
on
and
so
forth.
That
are
that
are
useful
for
for
the
token
sdk.
But
let
me
now
answer
the
question:
how
do
you
run
this?
This
stack?
Where
do
you
run
this
stack?
There
are
two
ways,
essentially
the
first
one.
B
You
can
run
this
stack
as
a
standalone
network
node.
Let
me
give
you,
let
me
show
you
pictorially,
what
the
what
does
it
mean?
So
you
can
have
all
at
the
center
of
the
p
of
these
of
these
slides.
You
see
these
nodes
that
we
call
fabric
smartline
nodes.
They
run
the
entire
stack
up
to
the
token
and
sdk
they
are
able
also
to
connect
in
a
peer-to-peer
fashion.
B
It's
a
more
centralized
solution
that,
with
with
blockchain
with
some
blockchain,
some
blockchain
flavors.
That
might
be
very,
very
useful
for
certain
for
certain
use
case.
So
that's
a
possible
instantiation,
but
you
can
also
embed
this
stack
in
the
application
in
your
existing
application.
So
if
you
already
have
an
application
server,
then
you
can
just
use
you
can
just
embed
the
token
sdk
and
of
the
the
entire
setting
your
existing
application,
no
need
to
to
introduce
forcefully
new
nodes
in
in
your
network,
your
network
topology.
B
So
this
was
very
convenient
because
it
allowed
us
to
adjust
as
we
go
depending
on
the
specific
use
case.
But
let
me
go
now
a
little
bit
more
into
the
details
of
the
power
of
the
of
this
of
the
token
sdk
stack
and
why
it
allows
the
developer
to
not
have
to
worry
about
the
complexity
of
zero
knowledge
or
the
other
cryptographic
primitives
like
anonymous
credential.
B
I
think
ali
mentioned
that
at
the
beginning,
which
is
a
primitive
that
allow
allow
us
to
sign
transactions
anonymously
and
unlinkably.
So
that's
it's
also
very
important
to
for
the
privacy
of
the
for
the
privacy
of
the
transaction.
So
everything
starts
with
the
token
api.
It's
in
the
middle.
It's
this
dark
blue
box.
It's
a
it's
essentially
a
layer
that
is
blockchain
agnostic,
so
the
open
the
token
api
talks
speaks
about
tokens.
B
You
know
using
a
meta
language,
so
it
talks
about
operations
over
tokens
and
so
on
and
so
forth,
without
any
reference
or
any
dependency
to
the
to
any
underlying
blockchain
on
top
of
the
token
api,
so
the
light
blue
boxes.
These
are
what
we
call
services,
which
are
library
that
can
be
the
some
of
them
are
already
are
ready
to
go
into
token.
B
Other
networks
to
actually
persist
the
token
operations
in
the
back
end
below
the
token
api.
Now
there
is
the
the
magic
I
I
told
you
that
we
want
to
write
once
the
application,
so
you
have
the
token.
The
developer
has
the
token
api.
He
uses
the
open
api,
the
token
api
and
the
services,
and
then
it
doesn't
have
to
worry
about
how
the
actual
tokens
are
described
on
the
back
end.
Why
is
this?
B
Because,
at
the
time
of
the
setup
of
the
system,
the
the
administrator
of
the
system
can
decide
which
driver
to
use
for?
For
the
specific
token
implementation?
What
does
it
mean
that
they
took
that
the
the
we
have
a
driver?
The
driver
layer
allow
us
to
separate
the
token
api
for
from
the
actual
representation
and
implementation
of
the
tokens
into
the
back
end.
B
This
means
that,
by
by
by
having
a
stable
token
api,
we
can
use,
then
a
driver
api
that
either
does
not
hide
anything
or
use
zero
knowledge,
proof
or
use
a
trusted
execution
environment
or
can
use
any
other
technology
to
provide
a
specific
private
privacy
guarantees
by
default.
In
the
in
the
token
sdk
that
you
find
in
the
open
source
version,
we
we
released
two
drivers,
one
that
we
call
fab
token,
that
it's
essentially
doesn't
hide
anything
everything
is
in
the
clear.
B
D
B
Already
play
with
the
with
this
zero
knowledge,
this
zero
knowledge
gadgets
without
having
to
worry
about,
what's
happening
behind
the
scenes,
so
you
develop
your
token
application
and
then
you
decide.
Okay,
I
need
zero
knowledge.
Poof.
You
set
up
zero
knowledge
and
you're
good
to
go.
So
that's!
What's
the
this?
Is
the
magic
of
this
separation
of
this
of
this
of
these
layers?
How.
C
B
Oh,
that's
a
very
good
question.
Indeed,
it
should
be
possible.
I
think
that's
a
it's
a
very
good,
it's
a
very
good
question
and
definitely
a
feature
that
the
token
sdk
should
deliver
it's
not
currently
available.
Why
is
this
because
it's
anywhere
complex
scenario,
let
me
give
you
a
scenario
of
what
this
can
be
useful.
B
Therefore,
you
must
be
able
to
switch
the
driver
configuration
of
as
you
go
at
some
point
in
a
especially
in
a
moment
of
a
safe
state.
This
is
a
definitely
a
great
feature
that
I
I
really
would
like
to
see.
If
you
want
to
to
jump
in,
please
reach
us
and
we,
let's
start
a
discussion
on
on
on
discord
or
in
any
other
channel,
and
how
to
see
how
to
do
this
effectively
but
beautiful
question.
Thank
you
anything
else.
B
B
So
we
need
a
structure.
We
need
to
be
able
to
represent
this
token
in
a
very
flexible
way,
and
we
came
out.
We
came
out
with
a
this
concept
of
token
token
request.
Let
me
go
through
the
anatomy
of
a
token
request.
We
have
essentially
three
sections.
The
first
one
is
called
anchor.
It's
a
way
to
link
all
the
operations
all
together
in
such
a
way.
They
cannot
be
extracted
and
moved
to
another
to
another.
Together,
requests,
that's
phenom,
that's
very,
very
important.
B
So
you
see
the
complex
that
there
are
so
many
details
that
one
needs
to
be.
One
needs
to
take
care
of
that.
It's
very
handy
to
have
a
framework
that
does
everything
for
you.
You
don't
have
to
worry
about
the
about
the
rest.
Then
we
have
the
action
sections.
This
action
section
is
actually
carries
the
representation
of
the
issue
and
the
transfer
operations.
B
Redeem
is
a
sort
of
transfer
operation.
So
we
don't.
We
don't
explicitly
speak
about
the
redeemer,
because
for
us
it's
just
a
transfer
operation.
It's
a
special
transfer
operation.
Therefore
we
just
we
just
talk
about
issue
and
transfer,
and
then
we
have
the
witnesses
the
with
what
what's
what's
a
witness.
The
witness
is
something
that
is
needed
to
assert
the
validity
of
this.
Of
this
of
these
operations,
imagine
if
alice
is
transferring
her
tokens.
B
She
must
sign
the
the
toga
request
in
order
to
the
to
to
to
deliver
the
belief
that
she
really
wants
to
transfer
this
this
token,
so
the
signature
from
alice
will
go
inside
the
inside
the
witnesses.
Now
the
sections
it's
it
can
contain.
This
action
section
can
contain
multiple
actions,
so
we
can
have
multiple
issues,
multiple
transfer.
B
B
This
is
also
very
important
because
remember
counter
showed
us
the
model
where
everything
is
obfuscated
on
the
ledger.
So
when
you
look
at
the
action
section
there,
you
find
commitments.
If
you
are
using
zero
knowledge,
you
find
commitments.
Everything
is
sophisticated
so
when
alice
transfers,
something
to
bob
or
if
any
symbol
are
arranging
a
business
process,
bob
needs
to
have
a
way
to
understand
what
alice
did,
because
what
bob
needs
to
check
that
dallas
did
correctly
her
part
and
and
vice,
and
vice
versa.
B
So
with
the
metadata
alice,
can
transfer
all
the
secrets
information
or
for
who.
You
know
more
about
the
commitments,
what
we
call
the
day
commitments,
so
the
private
information
that
would
allow
bob
to
inspect
the
to
inspect
the
actions
and
get
the
belief
that
alice
it's
it's
performing
the
right.
The
right
thing
notice
that
this
private
information
should
not
be
given
to
the
validators.
The
validators
to
do
should
not
be
seen.
B
They
should
be
able
to
assess
the
validity
of
auto
requests
just
by
looking
at
the
actions
and
the
witnesses,
no
more
than
that.
Indeed,
if
we
are
using
zero
knowledge
there,
you
have
the
zero
knowledge
proofs
in
the
action
section,
and
you
just
verified
these
proofs
and
you
are
good
to
go
so
now
that
we
are
talking,
we
have
described
what
it
means
to.
B
So
what
happens
then
in?
Let
me
give
you
more
now
and
a
sense
of
what
is
what
it
means
to
perform
a
token
transaction
if
we
have
fabric
as
a
backend.
So
on
the
left-hand
side,
you
see
you
see
this,
but
the
the
business
parties
they
are
together.
They
can
connect
and
appear
to
be
fashioned.
They
can
arrange
the
terms
of
the
the
operations
that
they
want
to
perform
on
the
right
hand,
side
we
have
web
web
fabric
with
that
with
a
chain
code
installed
there.
B
I
will
tell
you
in
a
second
what
the
chango
does
so
the
business
part
is
that
they
collect.
Then
they
assemble
essentially
doing
the
token
request,
so
they
describe
the
operations
that
they
want
to
perform.
I
just
gave
you
an
example
of
a
swap.
The
swap
will
contain
a
transfer
from
alice
to
bob
a
transfer
from
bob
12,
plus
the
signatures
from
alice
and
from
bob
to
represent
that
they
want
to.
They
want
to
perform
this.
This
transfer.
We
might
have
additional
witnesses
like
signatures
from
auditing.
B
If,
if
you
set
up
the
system
to
have
auditing
capabilities,
then
we
might
have
additionally
additional
signatures
that
might
be
required
in
in
that
specific
use
case.
The
beauty
is
that
the
toggle
requests
can
contain
anything
that
is
needed
for
for
your
use
case.
So
if
you
have
a
use
case
that
requires
a
different
kind
of
auditing
that
also
can
be
adjusted.
You
just
you
just
need
a
driver.
B
B
Checking
that
the
zero
edge
proofs
are
correct
so
on
and
so
forth
notice
that
this
is
not
the
time
for
double
spending
resistance,
because
that
the
this
is
not
the
right
time
to
check
double
double
spending.
Double
spending
is
checker
committing
time.
The
second
piece
that
needs
to
be
done
is
exactly
the
translation.
Remember,
the
token
request
is
a
meta
language,
a
meta
description
of
the
operations,
and
they
need
to
be
converted
to
a
read
write
set,
because
this
is
the
language
that
fabric
speaks
and
chencon
can
do
that.
B
So
that's
the
life
cycle
of
a
token
transaction,
and
I
know
what
you're
thinking
this
is
very
complex.
I
know
the
the
interactions
seems
very
complex
and
indeed
they
they
need
to
be
complex
because
it's
complex
what
we
are
doing,
but
this
doesn't
mean
that
the
api
must
be
complex.
Let
me
give
you
a
sketch
of
an
example
of
what
it
means
to
write
business
logic
for
a
transfer,
so
the
first
step
suppose
that
alice
wants
to
transfer
something
to
bob,
then,
is
the
first
thing
that
alice
can
do.
B
This
is
just
an
example.
It
can
be
rearranged
in
many
in
many
in
many
ways.
We
are
very,
very
flexible
for
this
for
this
from
this
point
of
view,
so
just
to
give
you
an
example
in
the
first
step
alice
asks
bob,
please
bob.
Can
you
give
me
a
a
recipient
identity
that
that
you
won't
use
to
receive
these
tokens?
B
This
is
very
important
because
bob
needs
to
if,
if
bob
wants
privacy
bob
needs
to
use
every
time
a
different
pseudonym
that
is
not
linkable
to
the
others,
so
alice
connects
to
bob
bob's
gives
back
the
pseudonym
and
then
alice
can
at
this
point
create
the
transaction,
an
anonymous
transaction
notice.
There
is
no
reference
to
fabric,
but
because
we
are
targeting
fabric
behind
the
scene.
The
anonymous
transaction
means
that
the
transaction
will
be
signed
with
identity
mix
server.
B
You
don't
have
to
care
about
the
complexity,
the
identity
mix,
the
token
sdk
does
everything
for
for
you.
We
then
extra.
We
then
instruct
the
transfer
that
alice
wants
to
do.
Let
me
translate
for
you
this
to
english,
so
transfer
from
this
wallet,
this
type
of
tokens
for
this
amount
to
the
recipient.
B
So
that's
the
way
you
translate
this
single
line
and
then
remember
all
the
complexity,
all
the
steps,
so
the
ping-pong
between
for
collecting
the
witnesses
for
collecting
the
auditor
signatures
for
collecting
the
endorsements
from
the
chain
code
forming
the
fabric
transaction,
just
a
single
line.
Us
you
collect
in
the
endorsements-
and
you
are
good
to
go,
you
are
everything
is
done
in
automatically
all
the
parties
are
contacted
behind
the
scene
fabric
is
conducted
behind
the
scene
to
to
get
the
endorsement.
B
B
So
I
hope
that
you
get
from
this
small
piece
of
software,
this
small
piece
of
business
logic,
the
fact
that
we
are
able
to
with
the
token
api
and
the
services
we
can
build
a
token
a
token
application
without
having
to
know
about
the
privacy
guarantees
the
complexity
of
zero
knowledge
without
having
to
care
about
which
kind
of
backhand
we
are
using.
Of
course,
most
of
the
time
it
will
be
fabric
because
it's
it's
such
a
great
system.
Now
right.
B
I
think
you
agree
with
me
such
a
great
system
and
that's
the
beauty,
so
you
write
once
then
you
use
whatever
you
want
samples.
There
are
samples.
So
if
you
go
to
the
fabric
token
sdk,
we
are
pushing
new.
We
are
pushing
as
much
as
we
can
in
the
open
source
repository.
We
are
improving
the
we
are
improving
the
capabilities.
There
are
samples
that
you
can
use.
We
pushed
the
recently
also.
B
Okay,
take
away
this
is
the
last
slide
for
for
today
and
and
gladly
will
we
like
all.
We
will
have
also
some
time
for
for
questions
so
the
fabric
token
sdk
delivers
this
set
of
apis
and
services
that
let
developers
create
token-based,
distributed
application
on
hyperledger
fabric
and
more
without
having
to
care
about
the
complexity
of
the
back
end.
The
complexity
of
the
general
knowledge
proofs
and
so
on
and
so
forth.
It
adopts
the
utxo
model
for
the
reason
that
counter
well
explained
it.
B
C
Thank
you
so
much
angelo
for
covering
a
lot
of
information.
We
actually
do
have
quite
a
few
questions.
We
actually
have
andy
martin,
who
has
raised
his
hand
so
andy.
If
you
want
to
come
off
mu.
Let
me
know
if
you're
ready,
if
not
I'll,
cover
another
question
while
you're
getting
ready
while
andy
comes
on,
can
you
answer
this
question
about
the
drivers
again,
so
andrew
coe
asks?
Can
we
enhance
the
driver
to
direct
specific
tokens
to
selected
endorsement
policy
panel.
B
That
doesn't
need
to
be
that
doesn't
need
to
happen
at
the
driver,
but
at
the
service
layer.
So
when
you
assemble
the
token
api,
so
when
you
build
your
token
request
at
that
point,
you
can
use,
you
can
implement
a
third-party
service
that
uses
the
sense
the
the
proposal
to
fabric
in
a
certain
way
different,
maybe
for
from
what
the
default.
Yes,
you
don't
need
to
touch
the
driver.
B
The
driver
is
mostly
interested
on
how
the
tokens
are
represented
and
what
it
means
to
generate
a
zero
knowledge
proof
that
makes
a
transfer
valid.
This
kind
of
it's
more
still,
everything
that
is
from
the
token
api
below
it's
blockchain
agnostic.
What
is
up
the
services?
This
is
blockchain
specific.
B
Very
good
we
have,
we
didn't
release
numbers,
but
again,
that's
keep
in
mind
that
the
drivers
that
are
available
there.
They
are
not
state-of-the-art
that
just
for
you
to
use.
They
will
not
reach
the
the
maximum
throughput
that
that
that
they
are
able.
But
you
know
that's
it's
open,
so
the
you
you
can
implement
your
own
driver
that
uses.
I
don't
know
a
super
duper.
Zero
knowledge
proof
system
that
has
very
fast,
very
fast
performance
and
you
are
good
to
go.
B
B
C
B
That's
taking
us
thinking
it's
a
very
specific
thing
to
a
specific
use
case,
so
I
will
need
to
have
more
information
of
what
do
you
mean
exactly
for
that?
Please
join
us
on
discord.
We
can
go
off
offline
and
have
a
full
full
discussion
on
that.
Yes
yeah.
I
would
love
to
to
hear
about
that.
Maybe
this
is
a
feature
that
we
can
implement
together.
C
B
Not
sure
what
what
does
it
mean
that
exactly
maybe
this
was
the
a
probably
if
it's
related
to
auditability,
that
that
might
make
sense
there
or
the
ability
saying
that
the
acl
saying
who
can
access
what
that
might
be
an
interesting
concept
to
a
more
complex
auditability
policies.
Of
course,
we
don't
also
that
part
is
sky,
it's
quite
customizable,
so
we
can.
You
can
build
a
third-party
service
that
delivers
a
new
kind
of
editability.
For
the
token,
the
token
sdk,
but
that's
actually
a
very
good
idea.
C
B
Maybe
please
also
feel
free
to
jump
in
the
the
this
one,
the
samples,
the
fabric
samples
they
use
directly
fabric.
So
you
need
to
know
exactly
what
you
are
doing.
You
need
to
know
if
you
are
using
state-based
endorsement
or
the
specific
that
specific
capabilities
you
can
you
that's
the
problem.
You
have
to
deal
directly
with
fabric.
You
need
to
know
what
you
are
doing,
which
is
okay,
it's
totally
fine
and
also,
if
you
want
actually
it's
a
good.
B
If
you
want
an
account
based
model
and
you
don't
need
privacy
or
you
need
certain
sorry,
you
need
certain
certain
privacy
features
that
are
available
with
fabric
directly
with
fabric
like
they
were
saying,
with
hashing
you're
good
to
go.
You
use
directly
that
one,
and
if
you
know
that
you
are
not,
you
don't
need
to
migrate
to
any
system
totally
fine.
If,
instead,
you
wanted
these
capabilities
of
multiple
privacy
levels,
the
full
zero
knowledge
stack
auditability,
then
you
go
to
the
token
sdk.
C
B
B
So
that's
not
what
we
target,
but
what
I
can
say
is
that
definitely
there's
an
interest
for
off-chain
transaction
for
payment
system
for
sorry,
for
payment
channels
to
to
avoid
to
go
continuously
for
continues
to
the
ledger,
which,
anyway,
as
a
cost,
but
that's
a
great
discussion
discord.
Please
join
us
the
discussion
there.
Maybe
this
stuff
we
can
shape
together
what
what
to
do
off-chain
transactions
for
for
the
token
sdk.
I.
C
If
you,
if
you
could,
let
me
share
my
screen,
I'm
going
to
just
wrap
it
up
here,
real
quick,
thank
you
so
much
angelo
ellie,
keltar
and
dave
for
joining
us
today.
You
covered
a
lot
within
an
hour.
We
want
to,
let
you
all
know
about
our
upcoming
workshop
series,
which
is
somewhat
related
with
tokens
on
building
your
own
nft
with
hyperledger
fabric.
So
please
visit
the
events
page
on
our
website
to
register.
C
We
also
have
our
hyperledger
global
forum
coming
up.
The
registration
is
open,
as
is
the
call
for
proposals,
so
we
may
very
well
have
topics
like
these,
where
you
can
get
deeper
into
the
questions
and
also
meet
some
of
the
people
that
are
working
on
these
projects
that
are
even
on
this
call
as
well.
C
So
please
register
and
also
submit
a
proposal.
If
you
have
something
that
you'd
like
to
share,
as
angelo
mentioned
several
times
in
the
call,
we
have
a
discord
community
here
at
hyperledger,
so
please
join
the
discard.
You
can
continue
all
your
questions
there.
You
can
see
how
you
can
maybe
participate
and
contribute
to
these
projects
as
well
and
help
us
advance
tokenization
and
hyperledger
fabric.