►
From YouTube: Demo: How to Connect to Public and Private Chains with Hyperledge... Andrew Richardson & Nicko Guyer
Description
Demo: How to Connect to Public and Private Chains with Hyperledger FireFly - Andrew Richardson & Nicko Guyer, Kaleido
For Enterprises looking to build a web3 strategy, it’s critical that they have a gateway to connect to the multi-chain, multi-protocol web3 world. In this demo, we’ll show you how Hyperledger FireFly makes it possible to build apps that connect to both public and private chains and integrate with existing back office systems.
Sessions Details & Slides (if available): https://sched.co/1AFqL
Access All Sessions: https://events.linuxfoundation.org/hyperledger-global-forum/program/schedule/
----
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
Discord: https://discord.gg/rVCn4j7UFd
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
License
Creative Commons Attribution license (reuse allowed)
A
A
You
know
in
a
controlled
way
and
then
we'll
talk
about
the
new
functionality
in
1.1
with
connecting
to
public
chains,
so
I'm
going
to
use
the
same
workspace
that
I
used
for
the
tokens
demo,
just
a
reminder
that
we
have
three
Firefly
nodes
here:
I
have
node
zero
I
have
node
one
and
I
have
node
two
and
they
are
on
their
default
namespace.
They
are
sharing
a
Consortium.
A
So
the
the
point
of
these
multi-party
consortiums
is
that
you
can
create
certain
things,
such
as
token
pools
such
as
data
type,
schemas
and
they'll
be
shared
with
everybody.
So
everyone
can
agree
on
them
and
reference
the
same
copy
of
those
in
this
case
I'm
going
to
go
back
to
the
sandbox
and
show
something
that
you
may
have
seen
before.
So
we'll
Breeze
through
this
quickly,
but
I
think
one
of
the
coolest
things
that
Firefly
does
in
talking
to
private
chains.
Is
this
marrying
of
on
and
off
chain
data?
A
Right
so
say
you
know:
I
have
a
use
case
where
I'm
in
a
Consortium
and
I
need
to
tell
everyone
that
a
shipment
has
been
received
and
broadcast
that
you
know
so
that
everyone
sees
that.
There's
proof
that
you
know
I
got
shipment
X
right,
so
I
can
send
a
broadcast
message.
Shipment
100
was
received
and
then
send
that
broadcast
message.
This
is
going
to
again
be
a
combination
of
on
and
off
chain
messaging
right.
A
The
actual
body
of
the
message
is
going
to
go
into
ipfs
and
then
a
blockchain
transaction
will
be
written
to
point
to
it.
If
I
go
to
my
timeline,
I
can
see
here
messages
always
batched
up
for
efficiency,
because
obviously
the
blockchain
is
not
great
at
high
throughput
of
messages.
So
we're
going
to
batch
a
bunch
of
messages
up
if
we
were
sending
a
lot
at
a
time.
Here's
just
going
to
be
a
batch
of
one,
but
then
that
that
hash
of
the
contents
of
that
batch
is
going
to
be
written
to
the
blockchain.
A
So
here's
the
initiation
of
it
and
then
the
message
is
confirmed.
I
can
see
everyone
receives
this
shipment
100
was
received
blockchain
event,
Was
Written
in
Block
18
right.
So
the
hash
of
that
message
is
written
in
Block
18
and
everyone
can
compare
the
contents
of
the
message:
compute
the
hash
and
check
it
against
the
hash
that
was
written
on
the
blockchain,
and
then
you
know
that
these
two
pieces
go
together
and
because
this
was
a
broadcast
everyone's
going
to
have
exactly
that
same
blockchain
event
for
Block
18..
A
This
right
here
shows
the
the
block
number
and
the
transaction
and
log
within
that
block.
So
block
18
and
the
same
here
and
of
course
they
all
get.
The
message
confirmed
that
they
can
all
see
this
piece
of
data
right
so
just
makes
it
really
really
easy
to
marry
the
on
and
off
chain
data
and
Firefly
guarantees
that,
regardless
of
how
fast
or
how
your
off-chain
storage
works,
the
events
will
always
be
delivered
in
the
order
that
they
are
on
the
blockchain.
So
it's
a
really
powerful
guarantee.
A
You
can
order
your
applications
based
on
that
and
know
that,
okay,
we're
all
going
to
get.
You
know
if
everyone's
sending
these
different
shipments,
that
they
got
we're
all
going
to
process
them
in
exactly
the
same
order,
regardless
of
how
reliable
or
slow
or
fast
our
off-chain
messaging
is.
The
blockchain
is
the
Authority
for
how
to
order
and
process
those
messages.
A
But
if
I
wanted
to
send
a
private
message,
you
know
and
tell
just
one
of
the
recipients
the
contents
of
that
shipment,
because
they're
privy
to
that
right
I
can
also
send
a
private
message.
Maybe
the
contents
of
the
shipments,
a
100,
Firefly
t-shirts
I,
think
that's
wishful
thinking.
I,
don't
I,
don't
know
if
we
even
have
any
Firefly
t-shirts
left,
but
you
could
always
check
the
booth
just
to
be
sure,
so,
maybe
only
org.
A
A
I
have
some
new
events
so
because
I'm,
the
cinder
or
zero
I
see
both
the
initiating
operation
and
then
I
see
the
blockchain
event
and
the
message
itself
with
the
contents
of
that
message,
which
again
consists
of
the
message,
could
be
text
Json,
binary
files,
lots
of
blobs,
you
know
anything
you
want,
can
go
in
there,
they'll
all
be
chunked
and
sent
across
off
chain
org
one
because
they
are
privy
to
this
message.
They
have
a
blockchain
event
and
a
message
confirmed
right.
A
Here's
my
details
exactly
the
same
but
or
two
since
they
were
not
there,
they
get
the
blockchain
event,
but
that's
it
right.
They
see
that
something
was
written
to
the
blockchain.
It
has
a
hash
of
a
message
in
it,
but
they
don't
know
what
it
means
right.
They
were
not
privy
to
the
message:
they
are
not
sent
the
off
chain
portion,
so
they
can't
reconstruct
that
right.
All
they
have
is
the
hash.
A
They
know
something
happened,
but
they
don't
know
what
they
don't
even
know
who
sent
it
to
who
right,
we
obfuscate,
even
the
cinder
and
the
receiver
of
the
off
chain
portion.
So
you
cannot
do
anything
with
the
hashes
that
are
on
the
blockchain.
Unless
you
also
have
the
data
and
then
you
can
compare
to
see
that
it
was
the
right
data.
So
that's
one
way
that
Firefly
helps
in
a
Consortium
I'm,
going
to
show
one
other
way
that
to
talk
about
consortiums
and
I'm,
going
to
move
to
public
chains
as
well.
A
I've
interacted
with
a
couple
different
tabs
here
in
the
sandbox
and
I'm
going
to
go
to
the
last
one,
and
this
is
for
smart
contracts.
We
talk
a
lot
about
kind
of
the
three
pillars
of
firefly
being
digital
assets
and
on
and
off
chain
messaging
flows
and
apis
for
building
applications,
because
obviously
most
blockchain
applications
will
end
up
having
some
sort
of
smart
contract
work
right.
A
Firefly
has
this
built-in
single
smart
contract
for
the
on
and
off
chain
messaging,
but
that's
the
only
smart
contract
that
it
prescribes
and
we
provide
an
implementation
of
that
on
both
ethereum
and
fabric,
but
you
can
also
write
your
own
custom
contracts
in
ethereum
and
fabric
and
Firefly
makes
it
really
really
easy
to
interact
with
those
as
well.
So
the
first
step
with
these
contracts
is
to
define
a
contract
interface.
A
Firefly
comes
with
a
interface
format
that
we
created
called
ffi
just
Firefly
interface.
We
needed
a
blockchain
agnostic
way
of
describing
smart
contracts.
You
know
what
are
all
the
methods
on
them.
What
are
all
the
events
on
them?
So
this
is
the
format
that
we
use,
but
we
also
support
since
ethereum
has
a
well-defined
ABI
standard.
We
also
support
ethereum
API
fabric,
not
so
much,
maybe
not
a
single
standard
format
there.
So
we
don't
have
one,
but
you
know
again:
it's
pluggable
any
other
format
that
makes
sense
to
support.
A
We
could
take
that
in
as
well
I'm
going
to
use
the
ABI
format
and
I'm
going
to
use
a
contract
called
simple
storage.
You
might
have
run
into
it.
It's
just
basically
a
git
method
of
set
methods.
You
can
set
a
single
value.
You
can
query
the
current
value
and
we've
extended
it.
So
you
get
events
when
it
changes
right.
So
two
methods.
One
event:
it
just
so
happens
the
sandbox
pre-populates
that,
because
we
do
demos
of
it
so
often
so
I'm
going
to
create
a
interface
definition
for
the
simple
storage
interface.
A
It's
going
to
go
in
I,
see
I
asynchronously
get
my
events
to
say
that
it
was
confirmed,
and
then
everyone
can
see
it.
If
I
go
to
blockchain
dash,
I
won't
see
it
yet
I
got
to
do
step
two.
They
all
got
the
message.
They
know
about
the
interface,
but
they
can't
really
interact
with
the
interface
I.
Do
need
to
actually
deploy
a
contract
that
conforms
to
that
interface,
I'm,
going
to
use
the
Firefly
CLI
for
that
I
haven't
shown.
A
So
an
API
is,
you
know,
a
concrete
endpoint
that
I
can
use
to
interact
with
a
particular
interface
and
so
I'm
going
to
build
this.
Maybe
we'll
do
a
snippet!
I
haven't
done
this
yet
here,
so
we'll
do
a
snippet
in
the
code
editor
just
to
show
you
how
easy
it
is
to
take
things
from
the
sandbox
and
go
directly
to
actually
building
a
real
application
right,
so
I'll
do
create
API,
not
polygon,
we're
going
to
the
default
Consortium
right
now,
all
right!
A
So
this
is
my
code:
snippet
I
got
it
directly
from
the
sandbox
I'm,
going
to
run
it
as
a
typescript
application,
and
there
we
go.
So
what
that's
going
to
do?
Is
it's
going
to
send
a
message
to
everyone
very
similar
to
how
we
did
custom?
You
know
broadcasts
and
private
messages,
but
it's
going
to
send
a
definition
of
this
contract
API
and
if
I
go
to
each
node
and
refresh,
they
are
now
each
going
to
know
about
the
API.
A
So
this
is
a
really
nice
way
to
kind
of
advertise.
Okay
to
everyone
in
the
Consortium.
Here's
a
new
API
that
we're
going
to
share
this
is
the
address
on
chain
where
you
can
interact
with
it.
You
can
see
who
deployed
it
and
you
can
see
the
interface
that
it
conforms
to
and
very
cool
as
well.
You
can
open
a
generated,
Swagger
API
for
it,
so
it
takes
it
takes
that
ABI
and
it
parses
it
into
post
methods.
A
You
know
it's
not
really
rest,
it's
more
RPC
style,
but
it's
a
really
really
easy
way
for
sort
of.
You
know
traditional
web
developers
to
interact
with
a
smart
contract
that
defines
whatever
logic
you
like
I'm,
going
to
do,
one
more
step
before
I
interact
with
it
and
that's
to
register
a
contract
listener,
so
I'm
going
to
say,
I'm
interested
in
the
changed
event,
I'm
going
to
create
a
new
topic,
called
changes
and
I'm
just
going
to
add
that
event,
so
I'll
get
notified
every
time
that
event
happens.
A
This
tells
Firefly
okay,
I'm
interested
in
this
event,
please
catalog
it
every
time
it
happens.
Give
me
a
queryable
database
record
of
every
time
that
event
happened
and
what
the
parameters
were
so
now
that
I
have
that
in
place.
I'm
going
to
go
back
to
my
Swagger
I'm
on
member
member
one
or
node,
two
sorry
node
two
here
so
I'm
on
node,
two
and
I'm
going
to
have
him
set
this
value,
we'll
set
it
to
55..
A
A
If
I
look
at
blockchain
events,
because
on
node
0
I
told
Firefly,
listen
for
change
events,
it's
listening
for
change
events,
so
it
cataloged
that
this
change
event
came
in
and
came
from
the
ethereum
blockchain,
and
this
was
the
output
right
from
this
address
value
was
changed,
55.
so
and
then
what
you
can
do,
then,
in
your
application
is
add
a
websocket
that
subscribes
to
these
and
Firefly
will
save
your
checkpoint.
You
can
act
each
message
right,
so
it
takes
this.
A
A
We
want
to
be
able
to
subscribe
to
each
other's
events
and
see
what
everyone's
doing
in
the
network
slightly
different
in
a
public
context,
but
a
lot
of
the
same
operations
apply
so
I'm
going
to
switch
on
my
node
0.
Only
this
node
has
got
two
namespaces.
He
has
not
only
the
Consortium
namespace,
but
he
has
a
separate
namespace
that
I've
called
polygon.
We've
talked
a
little
bit
about
the
role
namespaces
play
in
Firefly
1.1,
where
you
can
have
as
many
namespaces
as
you
want.
A
A
Looking
at
my
polygon
namespace
here,
which
is
again
pointed
to
polygon
Mumbai
test
net
and
we're
going
to
go
ahead
and
deploy
a
contract
to
Mumbai
I
preloaded
a
little
bit
of
Matic,
so
I
can
put
a
contract
out
there
and
you'll
see
you
can
interact
with
exactly
the
same
way
I'm
going
to
do
this
in
Postman
for
some
variety
but
I'm,
going
to
start
by
posting
I'm
going
to
use
the
layer
under
Firefly,
because
Firefly
is
unopinionated
about
how
you
deploy
contracts.
It's
kind
of
up
to
you.
A
If
you
like
to
use
hard
hat
or
truffle
or
anything
else,
it
provides
the
FF
tool,
but
that's
really
a
little
bit
limited
to
certain
scenarios,
but
you
can
use
things
like
evm
connect
which
sits
under
Firefly
and
as
a
part
of
the
Firefly
Project.
Evm
Connect
also
provides
a
rest
based
way
for
deploying
smart
contracts.
So
that's
what
I'm
going
to
use
here,
just
to
kind
of
give
you
a
flavor
of
some
of
the
different
tools
in
the
toolbox.
A
A
I'll
skip
the
deploy,
step
and
we'll
use
a
pre-deployed
contract,
so
I'll
go
straight
over
to
the
the
next
step
of
defining
the
interface.
This
is
the
same
thing:
I
did
in
the
sandbox
for
saying,
okay,
you
know
here's
all
the
the
methods
I've
got
here,
I
pasted
in
an
ABI
just
to
show
you
there's
kind
of
a
two-step
process,
there's
a
generator
that
will
convert
it
to
the
ffi
format,
because
Firefly
always
kind
of
deals
in
ffi.
A
It
gives
me
a
body
down
here,
that's
now
in
ffi
format,
and
then
I
can
paste
that
back
in
here
to
do
a
creation,
so
I'm
posting
to
Firefly
on
my
polygon
namespace
to
contracts,
interfaces
which
is
going
to
define
the
interface
now
it
looks
a
lot
like
what
I
did
in
a
multi-party
system,
but
the
difference
here
is:
there's
no
broadcast
right,
there's
no
sharing,
so
you
use
the
same
API,
but
it
behaves
differently.
It
just
defines
it
locally,
it
shoves
it
into
your
database
and
it
doesn't
send
anything
to
anybody
else.
A
So
that's
you
know
when
you
have
multi-party
mode
off,
it's
just
a
local
storage.
So
here
I
have
it
created
this
interface.
It
gave
me
an
ID
I,
called
it
simple
storage
version,
one
same
as
I
did
on
the
other
namespace
everything's
isolated,
so
it's
a
new
construct
and
then
I'm
going
to
go
to
the
apis
right,
so
I
create
the
interface
I
created
the
API
and
I've
pre-populated
this
with
the
address
of
an
instance
of
this.
This
is
this
is
already
out
there
on
Mumbai.
A
So
this
is
I'm
saying
it
conforms
to
this
interface.
Here's
the
address
where
I
deployed
it
onto
the
public
chain
and
I'd
like
you
to
create
an
API
called
simple
storage.
So
there
we
go
it's
there
and
if
I
go
back
to
the
blockchain
page,
I
can
see
now
member
zero
in
their
polygon.
Namespace
knows
about
this
simple
storage:
that's
out
on
polygon
Mumbai
again!
Nobody
else
would
know
about
it
because
nobody
else
is
participating
in
this
namespace,
so
I
can
open.
It
up
looks
exactly
the
same:
I
can
get
the
value.
A
A
A
A
You
can
call
you
Firefly
can
call
it
through
either
way.
Maybe
let
me
come
back
to
it
because
I
think
we're
running
low
on
time
and
I
do
want
to
show
this
piece,
but
I
don't
want
to
forget
that
either
and
I'm
I'm
afraid,
I'm
misunderstanding
the
question
so
we'll
see
we'll
give
this
one
more
try
and
see
if
the
Swagger
works
this
time
so
see.
If
I
can.
A
A
A
A
A
I
can
run
it
on
the
polygon.
Namespace
and
I
should
have
a
contract
listener.
That
starts
indexing.
Those
events
from
the
public
chain.
We
shall
see
if
we
get
them
it'll
take
a
minute.
Let's
see,
I
think
you
just
got
one
and
there
I
got
change
events
all
right.
So
there
that's
listening
to
a
public
chain,
creating
a
contract
listener.
So
just
the
same
way,
it's
all
private.
To
my
node
right
I
say
these:
are
the
events
I'm
interested
in
index
them
from
this
block
and
it'll?
A
Listen,
you
know,
and
I
can
interact
with
the
rest
API
and
and
see
the
events
as
they
come.
Yes,
these
might
be
the
first
ones,
because
I
used
this
contract
yesterday
as
well.
So
this
one
yeah
there's
set
it
to
10.,
not
sure
if
that
was
the
exact
one
I
just
did
or
when
I
tested
yesterday,
but
it's
it's
going
through
and
it'll
catch
up
to
the
Head
to
whatever
the
events
are
see.
If
this
is
also
that
one
is
also
10.
A
A
You
can't
okay,
I,
think
I,
understand
you're,
asking
if
you
can
trigger
a
call
on
one
contract
on
one
chain
from
a
call
on
a
different
chain:
Firefly.
Wouldn't
it's
not
so
much
triggered
directly
on
chain,
but
at
the
business
layer
you
could
definitely
listen
to
events
from
one
contract
and
execute
things
on
another
contract,
and
you
would,
you
would
have
to
you
know,
Implement
whatever
layer.
It
is
that
you
know
kind
of
ties.
Those
together,
Firefly
doesn't
directly
provide.
You
know
that
connection,
but
exactly
exactly
and
that
that
is
common
right
to
have.
A
You
know
these
two
streams
of
information,
oh
and
based
on
something
that
happened
over
here.
On
my
you
know,
Consortium
chain,
I'm,
going
to
trigger
something
you
know
on
this
fabric
chain
gave
me
an
event
that
means
that
I
need
to
as
a
business
application
trigger
something
out
on
this
public
chain.
Right
and
I
need
to
roll
something
up,
or
things
like
that.
A
All
right:
well,
if
there
are
no
other
questions
or
if
you
think
of
one
later,
come
and
see
us
at
the
booth,
sorry
for
the
slight
hiccup
in
restarting
a
Docker,
but
I
think
we
got
through
everything.
I
wanted
you
guys
to
see.
So
thank
you
very
much
for
attending
and
hope
to
meet
you
out
on
the
floor.