►
Description
As enterprises increase their adoption of blockchain, digital assets, and NFTs, the overall complexity of systems is growing exponentially. The expanding reach of blockchain and digital assets is incredibly exciting, but navigating these layers of complexity to build production ready apps can be time consuming and expensive without the right tools.
In this webinar, learn how Kaleido, Hyperledger member company, makes it possible to get apps that solve real business problems into production quickly by harnessing the power of Hyperledger Fabric, Hyperledger Besu, and Hyperledger FireFly.
Nick Gaski, Kaleido’s Customer Success manager will show you how to:
-Deploy production-ready Hyperledger Fabric and Hyperledger Besu networks quickly and easily with Kaleido,
-Simplify Hyperledger Fabric development with Hyperledger FireFly’s FabConnect REST API,
-Build multi-protocol apps with fungible and non-fungible token capabilities,
-Utilize enterprise-grade features that ensure apps are ready for production,
-Accelerate development and get to production quickly and cost effectively.
In the “Hyperledger In-depth… .” series, Hyperledger members share learnings from their projects and try to answer all the hard questions about the pains of working with DLTs. It is not yet another webinar: participants will be encouraged to take part, come with prepared questions and voice opinions. Expect live demos and tutorials, stories from the battle field and hopefully some heated discussions. Let's get out of the zoom fatigue and engage to share experiences and build a stronger community.
----
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
A
Okay,
let's
go
ahead
and
get
started
so
welcome
to
hyperledger
foundations
in
depth
with
collido.
We
have
nick
gaske
here
today.
Who's
the
customer
success
manager
at
collido
he's
going
to
share
a
lot
of
really
useful,
helpful
practical
information
with
you,
and
I
hope
you
all
look
forward
to
the
session.
My
name
is
karen
o'toney,
I'm
a
director
of
ecosystem
here
at
hyperledger
and
I'll,
be
the
host
for
today
I'll
be
monitoring
the
chat
and
the
q
a
box.
A
A
A
We
encourage
these
sessions
to
be
very
interactive
and
engaging
so
feel
free
to
post
questions
in
the
chat,
the
q,
a
box.
If
it
feels
like
relevant
to
what
nick
may
be
discussing
at
that
time,
we
may
even
ask
you
to
come
off
of
mute.
If
that's
something
you
want
to
do
and
ask
your
question
live
as
well,
so
we're
here
to
make
this
this
hour
really
useful
and
productive
for
you.
B
B
I've
been
with
collido
for
a
little
over
four
years.
Prior
to
that,
I
was
at
ibm
working
on
hyperledger
fabric
in
the
open
source
community
and
also
with
the
product
offerings
for
the
ibm
blockchain
platform.
So
about
six
years
of
enterprise,
blockchain
experience
for
me.
Let
me
actually
stop
sharing
real
quick.
So
what
I'm
going
to
start
with
I'm
going
to
take
you
guys
through
collido.
I
just
want
everyone
to
know
that
what
I'm
going
to
be
showing
you
you
guys,
can
actually
do
this.
B
Alongside
with
me,
you
don't
need
to
be
a
programmer.
You
don't
need
to
be
a
coder.
It
is
like
intuitive
as
straightforward
as
it
gets.
So
the
only
thing
you
have
to
do
is
just
create
a
free
collido
account.
So
if
you
visit
collido.io
you'll
see
this,
try
it
for
free
button.
It'll.
Take
you
about
30
seconds
to
create
an
account,
and
then
you
can
follow
alongside
me
with
exactly
what
I'm
doing.
So
I
just
want
everyone
to
be
aware
of
that.
B
B
Our
platform
is
radically
simple
both
for
using
the
you
know,
graphic
user
interface
also
for
developers
who
want
to
use
apis.
So
we
put
a
rest
api
behind
every
single
piece
of
functionality,
whether
that's
doing
admin
crud
operations
or
whether
it's
just
talking
to
the
blockchain
and
issuing
transactions.
B
And
then
the
third
thing,
which
is
really
important
for
this
community,
is
we're
built
for
the
enterprise.
So
you
know
really
hardened
constructs
like
high
availability,
disaster,
recovery,
enterprise,
key
management,
etc.
Those
are
all
either
built
in
as
first
class
citizens
or
they're,
pluggable
or
integratable
components.
B
So
collido
we
offer
a
breadth
of
different
blockchain
orchestrations,
so
we
can
see
down
here
at
the
bottom
that
we
have
a
number
of
hyperledger
projects
sort
of
under
our
umbrella.
So
we
support
hyperledger
fabric
hyperledger
basu,
additional
ethereum
variants
like
quorum
and
geth
alongside
r3
corda.
One
thing
that
makes
collido
really
unique:
is
we
don't
pigeonhole
you
into
a
specific
protocol
or
a
specific
cloud
or
even
a
specific
region?
So
the
orchestrations
are
as
flexible
and
configurable
as
you
want.
You
can
create
multiple
blockchain
environments
across
different
protocols.
B
You
can
have
your
nodes
running
in
aws
and
in
azure,
or
you
could
have
a
super
hybrid
orchestration
with
one
node
in
aws
onenote
in
azure,
and
maybe
another
node
running
on
premise.
You
know
behind
your
dmz
what
we've
noticed
and
we'll
get
into
kind
of
what
I
mean
by
full
stack
blockchain.
But
you
know
over
the
last
six
years,
working
with
these
myriad
different
customers,
we've
seen
that
blockchain
is
incredibly
important
right.
B
Everyone
on
this
call
knows
that,
but
it's
a
really
small
fraction
of
the
overall
piece
that
you
need
when
you
build
an
app
there's
tons
of
additional
components,
you
want
to
integrate
with
your
back
office
systems
that
you've
made
big
investments
with
you
need
apis.
You
need
interfaces,
you
need
questions
and
answers
around
privacy
around
encrypted
data,
and
you
need
to
be
able
to
deal
with
an
ethereum
things
like
digital
assets
or
maybe
even
sort
of
bleeding
edge
constructs
like
zero
knowledge
proofs.
B
We
have
you
know
great
security,
certifications,
iso,
27k,
sock,
2
type,
2,
really
cool
key
management
constructs
like
keeping
your
private
keys
in
a
cloud
hsm,
for
example,
and
then
all
those
other
things
h,
a
d
r
answers
for
business
continuity
or
running
your
you
know,
blockchain
nodes
or
other
processes
on
premise
or
in
your
own
private
cloud.
So
that's
it
for
the
slides.
I
promise
this
will
be
all
interactive
from
this
point
on,
so
let's
go
ahead
and
hop
into
collido.
B
So
the
first
thing
we're
going
to
do
is
we're
going
to
go
ahead
and
create
a
business
network,
we're
going
to
create
a
fictitious
consortium
here
right.
So
I'll
just
call
this
example:
business
consortium-
and
the
first
thing
we'll
be
asked
to
do-
is
select
a
home
region.
This
is
collido,
saying
I
need
you
to
white
list,
a
specific
cloud
in
a
specific
underlying
region
so
that
you
can
deploy
nodes
and
deploy
services
into
this
availability
zone
right
here.
So
I'll
choose
aws
in
the
states,
since
that's
where
we're
located
on
the
east
coast.
B
But
now
I
see
the
option
to
bring
on
additional
regions
or
even
additional
clouds.
So
I
could
turn
this
into
a
multi-region
multi-cloud
network
and
accommodate,
for
you
know
a
very
diverse
consortia.
Not
everyone
uses
aws,
not
everyone
uses
azure,
not
everyone
uses
aws
or
azure
right,
hence
private
stack
and
hence
all
the
integrations
that
we
provide
I'll,
keep
it
simple
and
just
use
aws
in
the
states
today.
B
But
it's
that
easy
to
sort
of
onboard
and
whitelist
additional
clouds
and
additional
regions
so
boom,
there's
a
namespace
for
our
business
network
and
we
can
choose
to
expand
this
business
network
in
one
of
two
ways.
So
my
organization,
org
abc,
is
attributed
the
first
membership
inside
of
this
business
network
and
for
early
stage
projects
or
for
sort
of
a
proxy
operating
approach.
B
What
we've
seen
as
a
useful
technique
is
just
creating
multiple
membership
objects
right,
so
you
can
mock
out
how
your
network
is
ultimately
going
to
look
or
you
can
create
a
membership
for
another
participant
and
you
can
be,
you
know,
quote
unquote
a
benevolent
dictator
and
you
can
operate
those
resources
on
their
behalf.
Once
you've
hardened
out
the
topology
hardened
your
source
code,
your
application
tiers
looking
good,
then
you
can
actually
decentralize
your
network.
You
can
bring
on
additional
organizations
that
have
their
own
collido
accounts
to
own
and
operate.
B
You
know
their
own
collider
resources
autonomously
under
their
own
control.
So
we'll
say,
example,
external
organization,
admin,
email.com
and
now
collide
is
going
to
allow
you
to
implement
role-based
access
control.
So
when
you
found
a
network
and
you
onboard
another
participant,
you
have
the
ability
to
choose
what
they
can
do
or
what
they
can't
do.
Should
they
be
able
to
create
basic
nodes
that
are
validators.
B
Should
they
be
able
to
onboard
other
participants,
should
they
be
able
to
manage
your
blockchain
environments
and
upgrade
the
releases
and
the
versions
all
right,
so
you
can
allocate
and
rescind
these
permissions,
as
you
see
fit
right,
so
we'll
offload
that
invitation
and
boom
we've
done.
You
know
all
of
our
housekeeping
at
the
network
level.
Now,
if
we
drill
down
a
level
underneath
our
network,
we
have
a
construct
called
environments
and
in
collido
you
can
have
many
many
many
environments
right.
B
B
So
let's
go
ahead
and
create
an
environment
now,
so
we
see
two
doors
to
go
through,
I'm
going
to
come
back
to
firefly,
but
at
a
high
level.
Firefly
is
an
orchestration
layer
that
encapsulates
a
lot
of
the
features
that
I'm
going
to
show
you
rest
apis
events,
tokens
encrypted
private
data
transfers,
etc.
So
it's
just
like
this
macro
api.
That's
very,
very
easy
to
program
against
lets
you
get
data
into
the
blockchain
lets
you
keep
data
off
of
the
blockchain,
do
stuff
with
digital
assets,
etc.
B
B
Do
we
want
to
go
through
the
hyperledger
fabric
door,
or
do
we
want
to
go
through
the
corridor
and
on
this
webinar
we're
going
to
go
through
both
of
these
doors
today
we're
going
to
take
a
look
at
ethereum
and
we're
going
to
take
a
look
at
hyperledger
fabric.
So,
let's
start
by
going
through
the
ethereum
door
and
providing
a
name
for
our
environment
and,
as
I
said,
you
can
have
many
many
environments
right,
so
development,
sandbox
user
acceptance,
testing,
pre-prod
production,
etc.
B
I'm
going
to
go
with
a
cloud
only
orchestration,
but
we
see
their
support
for
a
hybrid
orchestration
where,
if
I
wanted,
I
could
have
you
know
a
node
running
on
my
local
laptop
right
here
that
could
securely
tunnel
and
securely
connect
back
to
fully
hosted
nodes.
Okay,
so
we've
gone
through
the
ethereum
door,
we've
chosen
a
name
for
our
environment.
Now
collider
is
saying.
Okay,
now
tell
me
what
kind
of
configuration
you
want:
choose
your
node
client
your
ethereum
variant
and
choose
a
corresponding
consensus
algorithm.
B
So
since
this
is
a
hyperledger
webinar,
we're
of
course
going
to
choose
the
hyperledger
client
and
I'm
just
going
to
go
with
vesu
and
proof
of
authority,
but
we
also
see
that
ibft
2.0
is
also
an
option
here.
There
are
some
advanced
settings
that
you
can
choose
to
input
here.
So
we
have.
You
can
choose
a
custom
chain
id
if
you
want.
B
You
can
manipulate
the
block
period,
poa
defaults
to
five
seconds,
but
you
can
raise
that
up
to
10
seconds
if
you
want,
and
every
blockchain
every
environment
actually
gets
bootstrapped
inside
of
the
genesis
block
with
a
billion
ether.
This
is
a
private
permission
blockchain,
so
that
ether
has
no
intrinsic
value.
But
as
we'll
see
here
in
a
second,
you
can
choose
to
charge
gas
prices
for
your
transactions
or
you
could
use
the
you
know
that
ether
as
effects
similarly
of
a
fungible
token
or
for
just
other
utility
inside
of
your
network.
B
It's
there
for
your
convenience
more
than
anything
else.
So
we'll
click
finish,
and
now
we
have
the
namespace
for
this
basu
poa
environment
and
we'll
go
ahead
and
bring
it
to
life
by
creating
some
nodes.
So
I
have
two
memberships
abc
and
xyz,
so
we'll
bind
the
first
node
to
membership,
abc
we'll
click.
Next,
I
could
choose
to
integrate
with
a
bunch
of
existing
cloud
services
that
I
have
so
maybe
I
have
a
kms
instance
or
I
have
an
s3
bucket
or
I
have
a
cloudwatch
login
group
or
I
have
bpcs.
B
Based
on
you
know
how
much
throughput
our
application
needs,
how
much
horizontal
scale
our
application
needs,
and
then
we
just
want
to
choose
if
this
node's
going
to
be
a
validator
or
just
a
replicator,
so
I'll
click
finish
and
boom,
we've
brought
this
blockchain
to
life,
so
I'll
very
quickly,
go
ahead
and
add
another
node
for
our
other
membership
right
here.
Just
call
this
node
two
and
we'll
fire.
Through
this
click
finish,
and
now
we
have
a
three
node
network.
I
say
three
nodes
because
in
collido
you
actually
get
a
free
validator
by
default.
B
You
have
a
system,
monitor
node,
that's
going
to
do
all
of
this
rich
indexing.
It's
going
to
expose
data
and
metrics
so
that
we
can
dive
deeper.
You
know
into
transactions
into
smart
contracts
into
you,
know,
rich
block
information,
so
we'll
give
these
guys
a
few
seconds
to
come
up
and
while
they're
coming
up,
let's
take
a
look
at
how
we're
going
to
teach
collido
about
a
smart
contract
so
I'll
scroll
over
to
some
slides
here.
B
So
we
have
a
service
called
smart
contract
management
and
again
this
is
going
to
fit
directly
in
with
your
existing
change
management
systems,
whether
you
sort
of
have
a
local
orchestration,
whether
you're,
using
you
know,
sort
of
github,
for
example,
collider
will
allow
you
to
import
your
source
code.
However,
you
want
you
can
go
from
a
private,
github
public
github.
You
can
go
directly
from
your
machine
with
a
you
know,
solidity
file,
or
even
if
you
want,
you,
can
actually
compile
the
code
and
just
give
us
the
byte
code
in
the
binary
interface.
B
The
takeaway
is
that
once
you've
done
this,
your
entire
network
will
have
line
of
sight
into
the
business
logic
into
the
smart
contract,
that's
being
executed,
but
the
real
real,
valuable
thing
is
that
as
soon
as
you
teach
collido
about
a
smart
contract,
we
will
expose
rest
apis
for
all
of
those
exercisable
methods
inside
of
the
solidity
right.
So
we
don't
need
to
use
sdks
like
web3,
javascript
or
ethers
or
netherium
anymore.
B
We
just
do
waste
basic
web
development
here
and
we
can
fire
in
you
know:
async
json,
payloads
and
kaleido
will
do
all
of
the
translation
to
turn
that
into
a
properly
signed
and
sequenced
ethereum
transaction
object.
We
have
apache
kafka
as
the
message
bus,
so
you
get
reliable
delivery
into
the
system.
It's
just
a
really
really
straightforward
kind
of
easy
interface
to
you
know:
send
transactions
into
the
network
without
having
to
become
an
ethereum
or
blockchain
expert.
So,
let's
dive
back
into
collido,
we
can
see
that
our
nodes
are
joining
and
coming
up.
B
So
I'm
going
to
call
this
simple
storage
and
I'm
just
going
to
import
this
source
code
from
github
right
here
and
we'll
see
how
easy
this
is
to
do
on
collido.
So
I've
created
the
namespace
for
this
application
project.
It's
not
really
interesting.
All
I've
said
is
it's
ethereum
and
it's
going
to
be
coming
from
github.
So
what
I
need
to
do
now
is
actually
need
to
create
a
compilation.
A
new
version
of
this
source
code
right
and
collido
is
asking
me
okay.
Well,
where
is
the
source
code?
You
said
this
is
coming
from
github.
B
I
need
the
url
now,
so
let's
go
ahead
and
give
collido
the
url
and
we're
going
to
give
it
a
very
trivial
smart
contract.
We'll
do
some
stuff
with
tokens
here
in
a
second,
which
is
a
bit
more
interesting,
but
this
is
a
very
basic
contract
that
makes
it.
You
know
really
easy
to
make
sense
of
these
rest
apis,
so
it
has
a
single
invokable
method
called
set
right
here
which
will
change
the
state
of
this
global
variable
stored
data
to
some
positive
integer,
that's
less
than
100..
B
That's
that's
about
it
and
then
there's
a
couple
getters
again
and
a
query
right
here
to
say:
hey:
what's
the
current
world
state
of
this
variable,
so
let's
grab
this
url
and
let's
go
ahead
and
import
it
into
collider
and
collider
will
do
all
the
other
auto,
detecting
up
the
soul.
C
of
your.
You
know,
sort
of
ethereum
versioning
as
well.
B
B
So
we
can
go
back
here,
give
this
a
few
more
seconds
to
compile,
and
then
we
can
go
ahead
and
teach
our
kaleido
environment
that
I
named
development
about
these
available
apis
right
here
and
when
this
actually
does
completely
finish.
What
we'll
see
is
we'll
see
the
byte
code
and
we'll
see
that
abi
that
binary
interface-
and
this
is
really
what
collido
needs
to
expose
those
rest
apis
right
here,
and
so
we
can
see
how
easy
this
would
be
to
you
know,
say:
hey
here's
sort
of
like
where
we're
doing
our
change
management.
B
I
want
to
iterate
on
the
smart
contract
logic,
and
I
want
to
upload.
You
know
a
new
version
with
you
know
an
additional
object
or
an
additional
you
know,
variable
inside
of
it
or
an
additional
method
becomes
really
really
easy.
To
kind
of
you
know,
promote
these
up
into
collido
push
them
into
your
dev
or
staging
environment,
make
sure
they're
working
once
it's
hardened.
You
can
go
straight
into
production
without
changing
your
code,
so
I'll
promote
this
into
that
environment.
B
I'll
choose
a
name
for
the
apis,
call
them
ss
and
just
click
finish
right
here
and
what
this
does
is.
This
gives
this
development
environment
that
I've
created
a
definition
of
the
rest
apis
inside
of
that
simple
storage,
smart
contract,
I
will
have
a
open
api
interface.
That's
accessible!
That's
exercisable,
inside
of
this
environment
that
I
can
use
to
speak
to
the
blockchain
genuinely,
so
we
will
simply
just
deploy
this
smart
contract
and
then
I'll
hop
into
an
environment
with
a
lot
more
going
on.
B
So
let's
go
ahead
and
view
this
api,
we're
viewing
it
through
the
interface
on
node
number
one
and
the
other
cool
thing
I
guess
I
should
mention,
is
that
you
know
when
you
promote
this
source
code
to
the
environment.
Every
single
node
gets
taught
about
these
apis.
So
you
don't
need
to
transfer
source
code
out
of
band.
You
don't
need
to
upload,
you
know
any
binaries
or
any
files.
B
B
B
If
this
comes
up
today,
okay,
here
we
go
sorry
for
the
slowness,
okay,
so
we're
going
to
take
this
root
post
method.
And
what
we'll
see
is
I'm
doing
this
inside
of
collido,
but
everything
I'm
doing
you
can
very
very
easily
do
programmatically
right.
So
here's
the
request,
url
that
we
would
be
posting
to
to
deploy
this
smart
contract
and
we
just
need
to
give
it
an
initial
value
to
that
constructor
right.
So
I'll
give
it
one
two
three
right
here
and
then
we
have
another
query
parameter.
So
we
have
the
query.
B
Parameter
that
says
hey.
This
is
the
address
that's
going
to
sign
the
smart
contract.
This
is
the
default
account
on
node
number,
one
that
I'm
viewing
this
api
through.
But
then
we
have
another
parameter
here
that
says:
hey.
Do
you
want
to
apply
like
a
human
friendly
name
to
this
smart
contract
versus
dealing
with
hexadecimal
strings
and
yeah?
Of
course,
we
do
so
I'll
call
this
ss123.
B
We
can
go
ahead
and
execute
that,
and
this
will
be
our
first
actual
blockchain
transaction.
This
will
be
an
instantiation
of
this,
this
source
code
and
this
will
be
a
deployment
into
the
network
and
what
we'll
notice
when
this
actually
finishes.
This
is
a
synchronous
call,
so
it's
waiting
for
it
to
execute
before
it
returns
the
receipt.
B
Is
that
we're
going
to
have
an
instance,
so
we
had
a
gateway.
We
had
a
definition
of
this
smart
contract,
which
was
these
apis,
but
now
we're
going
to
have
a
specific
instance
right,
we're
going
to
have
a
smart
contract
endpoint
that
we
can
actually
call
again
going
real
slowly
today.
So
I'm
going
to
do
a
quick,
refresh
and
we'll
hop
out
of
this
environment
and
go
into
a
different
one.
But
the
idea
is
that,
okay,
so
let's
hop
into
the
different
environment,
I've
already
done
this
and
another
one.
B
So,
let's
go
here,
go
to
smart
contracts,
go
to
simple
storage
and
we
see
that
I've
deployed
an
instance
onto
the
blockchain
right
here.
So
rather
than
calling.
You
know
this
full
hexadecimal
string
right
here,
which
is
a
basic
ethereum,
smart
contract
address.
We
can
use
the
collider
rest
apis
and
we
can
just
call
this
convenient
endpoint
right
here,
ss123,
okay,
so
let's
go
ahead
and
invoke
this
real
quick.
B
So
we
can
view
this
instance.
Api
we'll
view
it
through
node
number.
One
right
here
looks
like
this:
environment
is
going
way
faster,
which
is
awesome.
So
let's
go
ahead
and
call
this
set
method
right
here
and
we'll
just
change
the
existing
value
to
99
right
here
again
signing
with
this.
This
identity
on
node
number
one
submitting
the
transaction
synchronously
and
we
can
just
go
ahead
and
click
execute.
So
we'll
do
this
and
I'll
take
you
into
postman
and
we'll
get
a
little
closer
to
how
this
would
be
done.
Programmatically
right
here!
B
B
That
you
care
about
whether
it's
on
your
machine
or
in
github,
if
it
compiles,
we
will
expose
rest
apis
for
you,
so
just
making
life
easy
for
developers
to
speak
to
speak
to
these
endpoints
right
here.
Okay,
so
let's
talk
to
it
from
postman
now,
so
we
can
go
into
a
postman
terminal
and
we
can
go
ahead
and
say:
hey.
What's
the
current
status
of
this
smart
contract
right
here
right,
so
what
we
want
to
do
is
we
want
to
call
instances
ss123
and
then
we
can
just
call
this
query
method
right
here.
B
Okay,
so
we
can
do
a
quick
query
and
we
should
get
back
a
value
of
99
which
we
just
abserted.
Okay,
so
very
straightforward
there,
every
endpoint
in
collido,
conscious
I'm
giving
everyone
a
lot
of
information
about
the
platform
is
very
rich.
It
has
a
lot
of
functionality
and
sophistication
every
ingress.
Every
endpoint
in
collido
has
boundary
security.
So
if
you're
programmatically,
you
know
speaking
to
your
node
or
trying
to
call
a
service
endpoint
like
ipfs,
for
example,
those
calls
are
protected
over
tls,
so
you
need
strongly
generated.
B
You
know
username
password
credentials
and
passed
over
basic
off
and
those
are
accessible
inside
of
the
security
tab
inside
of
your
environment.
Right
here
you
can
cycle
these.
However,
often
as
you
want
right
make
them,
as
you
know,
short-lived
credentials,
or
they
can
be
static,
long-lived
credentials
as
well.
Okay,
so
pressing
forward.
Now,
let's
go
ahead
and
use
postman,
use
these
programmatic
apis
to
change
the
value.
So
let's
change
it
from
99
to
98,
for
example,
okay
and
the
other
parameter
that
we
want
to
look
at
the
query
parameter.
B
Is
this
thing
called
kld
sync
right,
x-collider
sync,
so
that's
us
telling
collido
hey!
I
want
you
to
wait
for
this
transaction
to
actually
get
executed
before
you
return
me
the
transaction
receipt.
Well
that
doesn't
make
a
whole
lot
of
sense
in
high
throughput
scenarios
right.
We
need
to
send
thousands
or
tens
of
thousands
or
hundreds
of
thousands
of
transactions
into
the
network.
It's
not
tenable
for
us
to
wait
five
ten
eleven
seconds
for
that
receipt
to
come
back,
so
we
support
firing
in
async.
B
B
So
let's
go
ahead
and
fire
that
one
in
and
it
comes
back
pretty
much
in
real
time
right
about
50,
100
milliseconds
right
here
and
then
what
we
can
do
is
we
can
take
this
unique
id
right
here
and
we
can
query
this
guy
downstream.
So,
instead
of
calling
slash
instances,
we're
going
to
call
slash
replies
right
here
and
provide
that
unique
id
that
kafka
threw
back
to
us
right.
If
we
do
this
query
too
quickly
before
the
transaction
is
actually
mined
right,
we're
going
to
get
we're
going
to
get
a
null
response
right.
B
So
you
just
need
to
write
some
logic
into
your.
You
know,
sort
of
into
your
server
side
code
to
say
you
know.
If
null
then
back
off,
retry
wait,
you
know
100
milliseconds,
500,
milliseconds,
etc
and
then
retry.
This
call.
So
that's
sort
of
the
approach
for
synchronous
versus
asynchronous,
really
really
straightforward.
B
All
you
need
to
do
again
is
just
upload
that
source
code
into
collido
cool
okay.
So
I
said
we
would
do
some
stuff
with
tokens
and
we
will
so
now,
let's
hop
down
here
to
this
digital
asset,
section
go
ahead
and
click
on
our
dashboard
and
what
I've
done
is
I've
deployed
an
erc20,
mintable
and
burnable
token,
and
the
cool
thing
in
collido
is
that
you
don't
need
to
bring
your
own
tokens.
We
provide
token
templates
brought
in
from
open
zeppelin.
B
Obviously,
where
you
can
say
hey,
I
just
want
a
vanilla,
erc20
or
I
want
a
vanilla,
erc,
721
or
I
want
it
to
be
mintable
or
I
want
it
to
be
mintable
and
burnable
right,
and
so
what
I've
done
is
I've
created
an
erc20
right
here
with
multiple
and
burnable
characteristics
and
I've
applied
the
majority
of
the
balance
to
node
number
one
right
here.
His
default
account.
B
So
if
I
go
ahead
and
select
that
account
inside
of
the
dashboard,
I
see
that
I
have
close
to
a
million
tokens
right
here,
but
what
we
can
do
again
is
we
can
use
these
rest
apis
to
do
stuff
with
these
tokens
right.
So
maybe
I
want
to
transfer
some
tokens
to
another
recipient
in
the
network
right.
So
this
is
the
default
ethereum
account
on
the
other
node
inside
of
my
environment.
Node
number
two:
zero,
eight
1
6
6..
B
So
if
we
go
to
that
node
and
take
a
look
at
it,
we'll
see
that
it
has
some
allocation
of
this
hlt
token
that
I
deployed
right.
So
we
can
go
and
view
the
details.
We
can
view
account
details
right
here.
We
saw
that
it
has
no
ether
balance
from
the
ether
pool,
but
as
soon
as
this
loads
right
here
we'll
see
that
it
has
a
balance
for
this
hyperledger
token
and
a
balance
of
200
right
there
and
what
we
can
do
with
our
apis
is,
we
could
say,
hey.
B
I
want
to
transfer
100
more
of
these
tokens
from
this
holder,
the
guy
that
had
close
to
a
million
tokens,
and
I
want
to
send
them
to
this
other
participant
inside
of
the
network.
This
identity
and
these
addresses
can
be
anything
right.
They
can
be
in
your
meta
mask,
they
can
be
in
a
hd
wallet.
They
could
be
held
in
a
cloud
hsm
right.
This
just
needs
to
be
a
standard,
ethereum
hexadecimal
string
right
here,
all
right,
so
we
can
go
ahead
and
fire
this
off
right
here,
transfer
100
additional
tokens.
B
This
is
a
synchronous
call
again,
so
it's
going
to
wait
for
it
to
fully
execute.
There's
the
receipt
came
back
in
about
five
seconds
right.
Proof
of
authority
is
five
second
intervals,
and
now
we
can
just
do
a
quick
query.
We
can
say
hey,
mr
account,
you
just
transferred
100
tokens.
Your
balance
was
999
800.
What's
your
current
balance
right
now,
right,
that's
what
the
balance
was.
It
should
be
100
less
than
that,
and
it
is
right
here
right
and
so
the
dashboard
is
really
friendly
right.
B
The
dashboard
is
an
admin
utility
very
easy
to
kind
of.
Like
stand
up
resources
and
do
some,
I
guess
lightweight
blockchain
transactions,
but
obviously
as
you're
getting
closer
to
building
out
an
application
you
want
to
get
into
postman,
then
you
want
to
start
getting
into
you
know,
sort
of
node.js
or
whatever
your
favorite
language
is
on
server
code
and
actually
calling
these
rest
apis,
synchronously
or
asynchronously
cool,
okay,
pressing
forward.
Let's
look
at
another
feature
inside
of
collido
and
these
are
not
collider-specific
features
by
the
way.
B
I
don't
want
to
make
this
sort
of
a
collido-centric
sort
of
webinar.
They
are
encapsulated
inside
of
collido,
but
everything
I'm
showing
you
has
actually
been
open
sourced
into
a
hyperledger
project
called
firefly.
So
this
rest
api
gateway,
for
example,
that
we
call
ethconnect.
That
is
a
firefly
project,
this
outbound
portion
of
event
streamings.
This
is
part
of
firefly
the
ability
to
plug
you
know
different
blockchain
orchestrations,
whether
it's
baysu,
whether
it's
geth,
whether
it's
fabric
right
those
are
all
encapsulated
inside
a
firefly.
So
let's
take
a
peek
at
how
events
work
inside
of
collido.
B
Think
you
know
a
lambda
function
sitting
behind
the
api
gateway
on
aws
and
the
takeaway
of
events
is
that
you
never
have
to
query
the
blockchain
for
the
current
world
state.
You
never
have
to
do
websocket
polling
on
your
nodes
to
start
listening
for
events,
but
perhaps
your
most
valuable
is
you're
going
to
have
an
off-chain
local
cache
of
all
of
the
historical
events
and
all
the
current
state
information.
B
So
you
can
choose
to
automate
logic
and
react
to
these
events,
but
you
also
have
that
local
database
that
will
support
hyper
efficient,
super
rich
queries,
so
events
are
especially
valuable
and,
let's
take
a
look
at
how
one
of
them
looks
so
from
postman.
I
was
invoking
my
first
note.
I
was
invoking
node
number
one
with
those
transactions.
B
B
So
what
we
want
to
do
is
we
want
to
invoke
this
smart
contract
from
node
number
one,
but
we
want
to
have
node
number
two
configure
an
event
stream
execute
this
transaction
and
emit
an
event
right,
and
so
that's
an
example
of
right,
a
multi-party
system
where
you
have
different
participants,
sending
data
into
the
network
right,
think
supply
chain,
think
health
care.
Think
trade,
trade
finance
whatever,
where
you
know
different
disparate
participants,
need
real-time
notification
of
state
changes
that
are
happening
in
the
network.
B
So
let's
go
to
node
number
two
and
go
ahead
and
create
an
event
stream.
So
I
will
call
this
simple
storage,
since
that's
the
smart
contract
that
we're
gonna
use
and
I'm
gonna
deliver
it
via
web
hook,
but
web
sockets
are
supported
as
well.
I'm
going
to
click
next
and
now
collide
is
saying:
okay,
cool,
you've
defined
an
event
stream.
B
B
So
that's
what
I'll
teach
collido
about
right
here
if
you're
doing
this,
you
know
in
production,
you
know
put
a
bearer
token
and
protect
these
calls.
Obviously
so
I'll
click
finish
and
now
collider's
saying
cool,
you
defined
an
event
stream.
Here's
your
unique
event
stream
id
and
you've
told
us
where
you
want
it
to
go
now
tell
us
what
data
you're
actually
interested
in.
If
we
go
back
to
the
smart
contract
that
we
use
simple
storage,
we
see
that
we
have
an
event
defined
right
here.
Right
and
all
this
event
is
going
to
do.
B
Is
it's
going
to
tell
us
what
was
the
argument
that
we
passed
to
this
set
method
right?
What
was
the
argument
that
we,
you
know?
Clarifi
declared
the
unsight
integer
to
be
transitioned
to
we'll
get
a
bunch
of
additional
rich
information
like
the
smart
contract
address,
the
transaction
hash,
you
know,
block
number
time
stamp,
etc,
but
specifically
we'll
get
the
signature
and
we'll
get
the
inputs
right
here
right.
So
we
can
think
of
this.
As
you
know,
interesting
financial
information
or
state
changes
inside
of
supply
chain
right.
B
So
we'll
call
our
event
for
the
description
data
stored,
we'll
choose
a
gateway
api
right.
We
got
to
tell
collido
all
right
where,
where
are
you
supposed
to
find
this
signature,
we're
going
to
go
ahead
and
find
it
inside
of
that
simple
storage,
api
and
now
clyde
is
saying:
oh
cool.
Here's
that
data
stored
event
that
you're
interested
in
so
we
can
take
all
the
events
we
can
take
them
from
a
specific
block
number.
B
B
So
I'll
just
say:
hey
give
me
all
the
events
right
here
so
we'll
finish,
that
and
that'll
create
the
subscription
and
then
what
we
should
be
able
to
do
is
go
back
into
postman.
We
should
be
able
to
invoke
the
smart
contract
coming
from
node
number
one,
and
then
this
event
stream,
that's
been
configured
on
node
number.
Two
should
omit
the
event
to
this
endpoint
that
we
just
configured
so,
let's
give
that
a
go
see
if
it
works.
So
let's
change
this
value
down
to
97
this
time.
Okay,.
A
B
We'll
fire
this
in:
let's
fire
it
in
synchronously
this
time,
so
we'll
change
this
from
false
to
true
and
we'll
fire
away,
and
so,
if
we're
lucky,
if
we
got
this
close
enough
to
the
new
block
interval,
this
can
execute
in
three
seconds.
Sometimes,
if
you're
far
enough
away
from
the
block
interval,
you'll
miss
a
specific
block
and
you
may
have
to
wait
six
or
seven
seconds.
So
this
took
about
four
and
a
half
seconds
for
that
to
execute.
We
go
back
to
request
catcher
right
here.
B
We
see
that
ingested
an
event
right,
so
some
interesting
blockchain
information
around
the
number
around
the
transaction
hash.
But
if
we
scroll
to
the
end
here,
we
see
the
signature
that
it
matched
and
then
we
see
the
inputs
right,
and
so
this
is
like
the
real,
valuable
piece
right,
you're
able
to
see
you
know
what
was
the
smart
contract.
B
Logical
was
the
method
that
was
invoked,
but
what's
the
state
change
that
you
know
my
business
or
my
application
actually
cares
about
and
that's
event
streams
in
a
nutshell,
so
sprinting
forward,
because
I
do
want
to
show
fabric
and
I
want
to
show
a
little
bit
of
firefly
as
well.
Let's
just
take
a
peek
at
some
of
the
other
pieces
inside
of
the
dashboard,
so
we
have
a
very
rich
block
explorer
where
you
can
drill
deep
into
specific
transactions.
So
here's
the
one
I
just
sent,
we
can
see
the
method
exposed
right
here.
B
We
can
see
the
inputs
we
can
see
who
signed
it,
what
smart
contract
it
went
to.
If
we're
a
system
admin
we
have
rich.
You
know
health
and
monitoring
dashboards.
Where
we
can,
you
know,
have
you
know:
scoped
views
of
different
resources
different
run
times
across
different
intervals
and
different
time
frames
right
here
we
can
dive
into
you
know.
You
know
one
specific
runtime,
node
number
one.
B
For
example,
if
we
wanted-
or
we
can
see
the
macro
view
of
the
network,
so
just
kind
of
like
a
really
useful
thing,
for
you
know
sysadmins
kind
of
like
the
root
users
of
the
system.
If
we
go
back
up
to
the
dashboard
for
our
network,
we
can
also
see
an
audit
log
right
of
everything.
That's
happened
so
kind
of
like
all
of
the
interesting
crud
operations
that
have
happened
in
the
system.
B
So
you
know
this
becomes
valuable
when
you
truly
decentralize
your
network-
and
maybe
you
have
you
know
six
or
you
know
a
dozen
different
participants
that
are
doing
stuff
in
your
network.
You'd
like
to
have
you
know
unequivocal,
cohesive
line
of
sight
into
what's
actually
happening
inside
of
the
system.
B
Last
thing
we'll
look
at
is
we'll
just
take
a
look,
a
little
deeper
onto
a
specific
node
right
here,
so
we
can
go
into
the
logs
and
we
can
see
you
know
kind
of
the
core
bay
zoo
logs
right
here.
It's
happily
humming
along
mining
blocks
executing
transactions,
but
we
can
switch
the
context
here
and
we
can
actually
see
the
rest
api
gateway
logs.
So
this
will
show
us
transactions
coming
into
the
network,
for
example,
and
it'll
show
us
event
streams
coming
out
of
the
network
right.
B
So
we
could
arbitrarily
inflate
or
deflate
this
the
same
for
the
gas
cap
we
can
choose.
If
we
wanted
to
run
our
node,
you
know
as
a
full
archive
node.
We
can
change
the
logging
levels
etc.
We
can
choose
our
tune,
our
rest,
api
gateway,
etc.
And
these
are,
you
know,
not
binary
choices.
You
can,
you
know,
add
these
configurations.
B
Last
thing
I'll
show
you
is
the
security
tab
right
here,
so
this
is
what
we
needed
in
order
for
my
postman
calls
to
successfully
authenticate
into
collido,
and
you
do
that
via
app
creds,
app
creds
are
bound
to
a
membership.
Just
like
your
node
was
bound
to
a
membership
or
a
service
was
bound
to
a
membership.
Those
need
to
have
sort
of
a
one-to-one
correlation
right.
B
So
if
I
tried
to
call
node
number
one
with
app
creds
from
xyz
that
wouldn't
work,
if
I
tried
to
call
node
number
two
without
credits
from
abc
that
wouldn't
work
right,
so
we
can
just
say:
example:
threads
right
here
and
we'll
see
sort
of
an
ephemeral
view
of
this
username
password.
This
is
the
only
time
you'll
see
the
secret,
so
you
either
need
to
jot
this
down
or
you
need
to
just
regenerate
the
secret
kaleido.
Obviously,
for
security
reasons
doesn't
persist
this
on
your
behalf.
B
B
If
I
can
find
wherever
I
put
it,
I
just
want
to
show
the
architectural
diagram
super
quickly.
Verify
samples
verify
fab
connect
okay.
So
this
is
the
open
api
specification
for
all
of
the
apis.
The
api
surface
of
fab
connect
so
dealing
with
the
certificate
authority
dealing
with
events
dealing
with
transactions.
B
This
is
all
open
sourced
under
the
hyperledger
umbrella,
so
you
can
go
grab
these
apis
chuck
them
into
swagger
hub
or
whatever
your
favorite.
You
know,
yaml
conversion
tool
is,
and
you
can
program
directly
against
these
right
here.
I
have
a
little
cheat
code
in
our
dev
environment,
where
I'm
going
to
use
swagger
just
for
sort
of
ease
of
use
inside
of
this
demo,
but
every
call
that
I'm
making
everyone
else
can
make.
A
B
Yeah
I
mean
I,
I
think
it
may
be
better
to
take
that
one
offline,
specifically
with
the
whoever
asked
that
question,
but
I
think
the
takeaway
is
that
you
know
what
I'm
trying
to
show
you
with
all
of
these
services,
and
all
these
interfaces
is
that
your
existing
systems
of
record
your
existing
e-commerce
systems,
your
existing
back
office
systems,
you
don't
need
to
reinvent
the
wheel
to
be
able
to
layer,
collido
and
layer
blockchain
functionality
into
there
right.
It's
it's
a
simple
integration
with
with
rest
apis.
B
You
know,
with
hashing
private
data,
from
your
existing
data
stores,
with
using
our
event
streams
to
ingest
data
from
different
participants
inside
of
your
network.
So
it
really
becomes
a
matter
of
if
you're,
creating
a
marketplace.
You
know
sort
of
using
blockchain
as
the
beating
heart
of
it.
You
know
what
are
the
assets
that
we're
dealing
with
right?
Are
we
dealing
with
real
world
assets?
Are
we
talking
digital
twins
and
nfts
of
you
know
actual
you
know
tangible
constructs.
Are
we
talking
about
tokens?
Are
we
talking
about?
B
You
know
something
else
you
know.
So
I
think
it's
you
know
not
a
not
a
black
and
white
conversation.
It
really
depends.
You
know
specifically
on
the
use
case
on
the
requirements
of
the
customer,
but
what
I
can
say
is
having
worked,
you
know
with
you
know.
A
wide
variety
of
you
know
huge
enterprise
customers
in
health
care
in
banking.
You
know
in
insurance,
in
retail,
it's
it's
really
really.
A
lightweight
lift
to
you,
know
kind
of
extend
the
functionality
of
your
existing
systems
with
collido
and
with
whichever
blockchain
sort
of
orchestration.
A
B
Our
business
is
a
sas
business,
so
you
pay
for
what
you
use,
namely
your
nodes.
So
if
your
nodes
are
up
and
running,
then
you
pay
an
hourly
fee
for
those
nodes.
If
your
environment
is
paused,
your
nodes
are
paused,
you
don't
pay
collido
anything,
but
you
do
have
the
ability
to
manipulate
your
blockchain
right.
So
if
you
do
want
to
use
that
ether
pool
and
charge
for
transactions,
you
have
that
you
have
that
possibility.
You
have
that
availability
to
you,
but
by
default
everything
is
a
guess.
Price
is
zero.
A
B
I
I
don't
know
that,
there's
anything
out
of
the
box
on
bay
su
that
quorum
doesn't
have
you
know.
Quorum
has
a
private
transaction
manager.
You
know,
basico
is
a
private
transaction
manager.
You
know
the
majority
of
the
parameters
that
we're
talking
about
is
sort
of
like
the
the
type
of
node.
You
want
to
run,
whether
it's
you
know
full
node
archive
node,
whether
you
know
you
sort
of
want
to
up
your
logging
level.
B
You
know
info
debug,
etc,
but
the
real
parameters
you
can
tune
are
sort
of
like
those
gas
prices
in
that
rpc
gas
cap,
which
are
the
same
defaults
as
quorum
and
desu.
But
if,
if
we
looked
a
little
deeper
down
onto
those
protocol
configs,
we
could
see
that
we
could
do
some
really
really
valuable
tuning
right
on
that
rest,
api
gateway
and
on
that
underlying
kafka
tier.
But
no,
I
think
the
the
answer
to
that
question
is
they're
more
or
less
apples
to
apples
kind
of
on
the
protocol.
Configs.
B
Options:
yeah,
that's
super,
so
what
we're
going
to
take
a
look
at
is
the
same
interface
and
we're
going
to
talk
to
fabric
the
easy
way
now.
So
what
I
showed
you
there
was
the
whole
footprint
of
firefly
projects
under
the
hyperledger
umbrella.
So
there's
at
least
half
a
dozen
of
those,
and
this
is
really
similar
to
sort
of
what
you
just
saw
right
here.
But
what
this
means
is
you
don't
need
to
have
a
client
wallet?
You
don't
need
to
do
certificate,
signing
requests
going
into
a
ca.
B
You
don't
need
to
collect
signatures
for
endorsement
policies
and
be
responsible,
for
you
know,
reliably
submitting
transactions
up
to
an
ordering
service
or
subscribing
to
events
again.
All
of
this
is
dealt
with
for
you
in
collido,
with
apache
kafka
as
the
message
bus.
So
let's
just
take
a
quick
look
at
how
easy
this
is
to
do
with
fabric.
B
So
I
have
a
web
ui
here
which
I'll
open
real
quickly
and
what
I've
done
is.
I've
just
deployed
another
fairly
basic
piece
of
chain
code
into
this
environment.
So
again,
hyperledger
explorer.
Okay,
that's
acting
up
so
we'll
just
skip
that
right
there,
but
I
was
just
going
to
show
you
that
we
have
a
chain
code
deployed
and
what
we're
going
to
do
is
we're
just
going
to
go
ahead
and
access.
B
B
Okay,
it
doesn't
like
the
creds
and
the
url,
so
it
just
needs
a
refresh
and
we're
good.
So
I'm
just
going
to
go
down
the
line
here
and
do
all
of
the
logical
steps
inside
of
fabric
we're
going
to
register
an
identity,
we're
going
to
enroll
an
identity,
we're
going
to
invoke
our
smart
contract
and
make
a
state
change.
B
So,
let's
start
by
creating
an
identity
in
the
system,
so
I'll
create
one
for
user
two
and
we'll
enroll
him
as
a
client.
So
click
execute
and
I'll
be
returned
the
secret
right
here.
So
I
can
grab
this
secret
and
then
I
can
do
the
enroll
call
so
we'll
post
to
this
enroll
endpoint
right
here
so
we'll
say:
try
it
out
user
two
provide
the
secret
and
we'll
go
ahead
and
enroll
this
guy
and
then
what
we
can
do
is
we
can
actually
query
this
user.
B
We
get
back
the
200
response
and
we'll
be
able
to
see
the
enrollment
certificate
and
we'll
be
able
to
see
the
ca
certificate
and
all
those
otherwise
terribly
unpleasant
things
that
you
have
to
do
with
certificate,
signing
requests
and
dealing
with
certificate
authorities.
So
this
was
all
of
two
api
calls
which
took
you
know,
probably
eight
total
lines
of
json
right
there
to
properly
enroll
a
user
and
this
this
sort
of
embeds
your
wallet,
your
client
identity,
too.
So
you
don't
have
to
worry
about
signing
you
don't
have
to
worry
about.
You
know
endorsement
collection.
B
Again.
All
of
this
is
encapsulated
robustly.
Inside
of
this
layer,
so
what
I
have
inside
of
my
network
is
I've
deployed
this
asset
transfer
basic
chain
code.
So
what
I
did
is
I
just
compiled
the
go
binary
for
this
chain
code.
I
uploaded
it
into
the
smart
contract
management
system
on
collido
and
I
pressed
a
couple
buttons
and
it
deployed
it
into
my
environment.
It
instantiated
that
smart
contract
again,
that's
also
backed
by
a
rest
api
just
like
ethereum.
B
So
back
to
swagger
and
let's
open
transactions
right
here,
so
we're
going
to
say,
send
transaction
the
signer
is
going
to
be
user
2.
The
channel
is
going
to
be
the
default
channel
that
collido
created
for
free
for
us,
so
you
don't
even
have
to
bother
creating
a
channel
in
collido
either
right,
we'll
do
the
bootstrapping
of
the
default
channel
for
you
by
default,
so
that
you
just
have
a
ready
to
use
channel
to
you,
know,
deploy
chain
code
onto
and
immediately
send
transactions
into
the
network.
B
B
B
I
need
to
put
the
quote
right
here
so
we'll
make
this
blue
we'll
give
it
a
size
of
one
we'll
give
it
to
myself
since
I'm
doing
the
demo
and
we'll
give
it
a
value
of
100
right
here,
so
we
can
fire
this
in
and
again
this
came
in
synchronously
right
here,
so
we
see
the
transaction
receipt
and
now
we
see
the
transaction
id
which
we
can
track
downstream.
So
let's
go
ahead
and
do
that
so
we'll
grab
this
transaction
id
right
here.
B
B
B
So
we
can
execute
that
and
immediately
it
returns
right.
It's
just
this
fire
and
forget
more
or
less
to
that
kafka
topic.
So
we
can
take
this
receipt
id
right
here
and
similar
to
each
connect,
we'll
just
call
the
receipts
endpoint.
So
we
can
go
to
get
receipts.
Id
click.
Try
it
out,
give
it
that
receipt
id,
and
this
will
return
us
the
transaction
id
which
in
turn
we
can
go
and
call
that
transaction
id
endpoint
and
we'll
see
all
that
information
about
karen's
new
asset
that
we
just
created.
B
So
finally,
we
can
just
overwrite
this
right
here,
click
execute
and
we'll
see
the
new
asset
that
we
just
created:
asset
o2,
which
is
purple
super
okay,
so
1051
we're
doing
okay,
let's
press
forward
and
let's
create
an
event
stream
for
fabric.
So
just
like
we
did
on
ethereum.
We
just
need
to
tell
collido
where
we
want
this
data
to
be
delivered,
so
I'm
going
to
say,
try
it
out,
we'll
just
say.
B
B
Tls
skip
verify
host
is
true
just
for
simplicity,
okay,
so
that
all
looks
good.
We
can
define
this
event
stream
object
right
here
and
now
we
have
this.
So
this
is
the
actual
event
stream
that
kaleido
knows
about,
and
this
is
what
we're
going
to
tell
our
subscription
about
right.
This
will
redirect
all
the
way
into
that
endpoint
that
we
defined
right
here
this
webhook.site.
B
We'll
click.
Try
it
out.
I'll
just
say:
asset
transfer
subscription
we're
going
to
give
it
that
stream
id
we're
going
to
give
it
the
default
channel,
we're
going
to
give
it
user,
1
or
user
2.
Rather
we're
going
to
go
from
block
0,
we're
going
to
say
the
payload
type
is
stringify
json
and
we're
going
to
skip
the
chain
code
id
and
the
event
filter.
B
I
don't
have
events
defined
inside
of
that
chain
code,
but
if
you
want
your
events
to
be
a
bit
more
granular
and
a
bit
more,
I
guess
ingestible
I'd,
encourage
you
to
define
these
chain
code
ids
and
that
event
filter
as
well.
So
we
can
just
go
ahead
and
click
execute
right
here.
That
should
be
happy,
and
now,
if
we
see
my
webhook.site
right
here,
we
see
a
bunch
of
stuffs
happening
right.
It
was
sitting
at
zero
and
now
we
have
five
transactions
that
came
through
so
again.
B
A
lot
of
these
are
the
system
transactions.
But
if
we
go
to
the
most
recent
one
right
here
and
we
actually
take
that
transaction
id,
we
can
go
query
that
on
collido-
and
this
should
be
the
most
recent
asset
that
was
created
for
caring.
So
if
we
go
back
to
the
transaction
ids
right
here
and
overwrite
this,
we
should
see
that
that's
the
actual
same
asset
or
a
transaction
id.
B
So
we
look
at
this
and
that
was
karen's
asset
and
again,
that
would
have
made
a
bit
more
sense
if
it
had
been
defined
with
an
event
and
defined
with
the
chain
code
id
as
well.
So
that's
fab
connect
in
a
nutshell,
and
if
I
have
karen
do
I
have
three
or
four
more
minutes.
I
can
show
firefly
super
quickly,
yeah.
B
Cool
okay,
so
let's
take
a
look
at
firefly,
then
this
stuff
is
amazing
and
there's
actually
a
community
call
happening
in
five
minutes.
So
I'm
going
to
paste
this
in
the
chat.
This
is
just
a
link
to
the
firefly
wiki,
where
you
have
the
calendar.
That's
available,
so
there's
some
really
cool
stuff
happening
today,
around
token
interfaces
and
around
on
chain
logic
and
a
lot
of
extensions
into
the
firefly
community.
So
if
any,
if
any
of
this
was
you
know,
even
you
know
had
a
modicum
of
interesting
information.
B
I'd
encourage
you
to
you
know,
join
these
bi-weekly
community
calls
with
you
know
the
engineers
that
actually
built
the
guts
of
this
system
right,
I'm
just
a
talking
head.
That
knows
how
to
press
a
couple
buttons,
but
these
are
the
through
subject
matter:
experts
that
you
know
if
you
have
low
level,
you
know
networking
or
interface
questions
or
want
to
contribute
to
this
community
hint.
This
is
a
fantastic
place
to
sort
of
engage
and
interact
with
you
know
other
firefly
folks
and
a
bunch
of
bunch
of
people
on
the
collido
team.
B
So
and
as
I
mentioned,
there's
a
huge
footprint
of
firefly
repositories,
many
of
which
would
love
you
to
give
them
a
star
if
you're
able
to
use
any
of
these.
So
let's
just
take
a
look
at
how
it
works.
So
what
I'm
going
to
do
is
I'm
going
to
create
my
own
firefly
stack
right
and
this
is
heavily
heavily
documented
if
you
just
go
to
the
firefly
docs,
so
I'm
just
going
to
say
firefly
init.
This
is
how
you
create
a
new
stack
and
I'm
going
to
call
make
one
called
data
transfer
right
here.
B
It's
going
to
say:
hey
nick.
How
many
members
do
you
want?
Well,
I
want
to
show
private
transactions.
I
want
to
show
off
chain
private
messaging,
so
I'm
going
to
create
three
members
right
here:
okay,
so
saying:
okay,
cool!
Now
now
I
understand
this.
I
have
a
doctor
composed
that
I'm
ready
to
stand
up,
go
ahead
and
say
start
this
start
this
stack.
So
I'm
going
to
say
ff
start
data
transfer
right
here
and
this
will
take
about
a
minute
or
so
for
this
to
come
up.
B
But
what
we'll
see
inside
of
inside
of
firefly
is
we'll
see
the
ability
to
do
a
lot
of
high-level
things
that
proxy
down
into
the
blockchain
layer.
So
a
lot
of
the
things
that
get
pinned
onto
the
blockchain
in
firefly
are
simply
just
references
to
hashes
right,
the
number
of
hashes
inside
of
the
system-
it's
probably
it's
probably
layered
like
three
or
four,
maybe
even
five
layers
deep
right.
So
you
have
a
lot
of
this
nested
logic
and
a
lot
of
you
know
sort
of
elegant
wrappers.
B
You
know
with
messages
with
transactions
with
data
attachments
with
unique
ids,
for
you
know
everything
that
stays
off
chain
and
then
you
just
pin
references
of
this
data
onto
the
blockchain,
and
you
have
all
of
those
rich
interfaces
that
I
showed
you
ethconnect
fabconnect
the
ability
to
ingest
events,
the
ability
to
subscribe
to
events.
You
have
the
ability
to
publish
data
to
all
of
the
network
or
say
hey.
You
know
we
have
a
network
with
you
know,
nick
kevin,
karen
tomas,
etc.
B
I
just
want
to
do
a
private
data
transfer
from
nick
to
karen
right
here
and
we'll
put
you
know,
an
indecipherable
message
of
that
onto
the
blockchain.
That
is
proof
of
that
transfer,
but
that
no
one
else
can
decrypt
or
make
sense
of
so
we'll
show
you
that
and
I'll
show
you
a
kind
of
a
very,
very
easy
to
use.
Bootstrapped
application,
that's
also
open
sourced
in
the
firefly
samples
which
will
expose
a
user
interface,
allow
us
to
sort
of
toggle
through
the
different
participant
views
and
choose.
B
If
we
want
to,
you
know,
send
public
data
or
if
we
want
to
send
private
data
as
well.
So
we
can
see
that
firefly
is
coming
along
right
here,
it's
unlocking
the
smart
contracts.
It's
writing
those!
You
know,
data
exchange
search
so
that
we
can
have
encrypted
transport
of
our
private
messages
and
as
soon
as
this
is
almost
ready,
I
can
hear
my
fans
humming
right
now.
It's
going
to
expose
the
the
local
host
ports
for
us
to
access
right.
So
we
see
I
can
go
to
5000,
5001
and
5002
right
here.
B
So,
while
those
are
up,
let's
go
ahead
and
kick
off
this
application
right
here,
too
so
I'll
just
say:
npm
start,
and
this
guy
will
take
about
a
minute
too.
So
while
that's
coming
up,
let's
go
ahead
and
open
up
some
of
these
user
interfaces,
so
we
can
go
to
localhost
5000
ui
right
here
here
we
see
the
firefly
dashboard.
We
can
go
to
host.
B
B
What
we'll
do
is
we
will
send
a
private
transaction
using
this
application
from
org
number
org0
to
org
one
and
we'll
prove
that
this
org
right
here
or
two
is
not
going
to
have
any
line
of
sight
into
that
transaction.
So
pretty
straightforward!
So
let's
go
back
here
this
guy's
up
and
running
so
let's
open,
localhost,
3000
and
get
after
it.
So
let's
go
to
3000
boom.
B
Okay,
so
first,
let's
just
send
a
message
to
the
whole
network.
Say
hello
world
right
here:
okay,
so
all
of
these
organizations
are
going
to
get
this
network
a
hash
of
that's
going
to
get
pinned
onto
the
blockchain
right
there,
hello
world
right,
so
we
can
go
that
was
sent
from
org
number
zero
right
here,
localhost
5000!
So
we
can
go
to
this
guy.
B
The
third
org
in
our
system
go
to
the
data
explorer
right
here,
go
to
the
messages
and
see
that
hey
he
got
a
broadcast
message
right
here.
We
can
click
on
it.
We
can
see
that
hey
hello
world
and
this
hash
right
here,
99
or
9
dde
right
there
we
went
into
some
sort
of
you
know,
shaw,
emulator
right
here.
We
would
see
that
that's
the
exact
same
hash
that
we
have
right
hello,
world
right
there,
nine
dd
right
there.
So
that's
the
hash
of
that.
B
Okay,
so
pretty
straightforward,
let's
go
ahead
and
send
a
private
transaction
now
and
again,
conscious
that
we're
at
the
top
of
the
hour.
But
this
is
pretty
cool,
so
I'll
just
say
private
info
right
here
and
we're
going
to
send
it
from
org0
right
here.
The
org
number
one
org
number
two
is
not
going
to
have
any
line
of
sight,
so
that
will
come
back
in
here.
We
see
the
message
right
here:
private
info.
We
can
go
to
org
number
two
or
number
one.
Sorry.
We
have.
A
B
One
and
two,
so
I'm
missing
missing
some
of
these
so
go
to
the
data
explorer
again.
We
can
go
in
here
and
see
that
he
has
two
transactions
and
three
messages.
The
first
message
right
here
is
defining
the
group
right,
so
this
is
saying
like
hey.
This
is
you.
This
is
org
number
one
right
here.
This
is
your
identity,
and
this
is
org
number
two
right
here.
B
So
if
we
click
on
this
guy
right
here,
we
can
see
sort
of
this
json
object
of
who's
inside
of
the
inside
of
this
system
of
this
private
message
right
here
right,
this
is
org0,
and
this
is
work
one
right
here.
We
go
into
the
second
data
attachment
right
here.
We
can
actually
see
the
private
information,
and
now,
if
we
go
to
org3,
we
go
back
to
its
dashboard,
we'll
see
that
it,
it
does
have
two
transactions
right.
B
It
has
a
reference
of
that
transaction
that
we
just
sent
into
the
network
right
there,
but
it
can't
make
any
sense
of
it.
All
it
knows
is
the
identity
of
the
node
that
sent
it
into
the
network
right.
But
if
we
go
back
to
work
number
two
right
here
or
org
number
one
or
org
number
zero,
then
we
have
full
line
of
sight
sort
of
into
that
private
message
and
into
that
transaction
as
well.
So
that
gives
you
an
idea
sort
of
how
firefly
works.
B
You
have
a
a
network
map
view
right
here.
That's
you
know
pretty
useful
to
see
organizations
you
can
find
the
associated
ethereum
account
that's
associated
with
that
org
identity
right.
So,
if
we
looked
at
that
transaction
we
saw
who
it
was
from
a4a
right
there.
That
was
actually
board
zeros
organization
right.
So
if
we
go
to
that
transaction,
we
click
on
it.
It
came
from
a4a,
which
was
word
through.
B
So
that
was
a
whirlwind
tour.
Conscious
that
I
gave
you
guys
a
lot
of
information,
but
I
hope
the
majority
of
it
was
interesting.
This
is
all
again
everything
I
did.
You
can
do
yourself.
It's
documented,
there's!
You
know
a
ton
of
videos
that
I've
recorded
out
on
the
collido
youtube.
Our
team
is
accessible.
You
know,
via
our
product
and
via
the
firefly
community.
A
Thank
you
nick.
This
was
wonderful.
You
went
through
so
much
information.
A
lot
of
it
is
so
helpful
for
all
kinds
of
use
cases
or
people
trying
to
use
different
protocols
trying
to
do
private
transactions.
So
very,
very
helpful,
appreciate
your
time.
Thank
you
so
much
and
anyone
if
you
want
more
information,
please
feel
free
to
reach
out
to
us
or
reach
out
to
the
collido
team.
A
Just
have
a
couple
things
to
share
with
you
before
we
finish
today,
we
do
have
more
webinars
coming
up
so
stay
up
to
date
on
our
events
page
more
immediately,
though
we
have
a
workshop,
this
is
actually
several
hours.
Long,
so
really
goes
into
a
deep
dive
into
hyperledger
indie.
So,
if
you're
looking
to
do
anything
in
digital
identity,
learn
more
about
how
to
use
hyper
ledger
indie,
we
highly
recommend
this.
It's
going
to
be
a
very
interesting
session.
A
Please
get
involved,
there's
many
ways
in
which
you
can
do
that
attending
more
of
our
events,
checking
out
our
wiki
or
our
website
joining
our
many
community
groups
that
talk
about
use
cases
or
talk
about
our
different
projects
and
technologies.
Thank
you.
So
much
for
watching
and
for
joining
us
today,
thank
you
to
nick
and
the
collido
team
as
well,
and
please
have
a
wonderful
day.
Stay
safe
and.