►
From YouTube: Hyperledger FireFly 1.0 Demo
Description
See how easy it is to get up and running with Hyperledger FireFly: the first open source SuperNode, a complete stack for enterprises to build and scale secure web3 applications.
FireFly 1.0 features a full suite of APIs and microservices that simplify the plumbing layers of blockchain development. This lets developers focus on the good parts of building a web3 app, making it possible to get to production much, much faster!
In this demo, Nicko Guyer will show how building an app on FireFly SuperNodes can radically speed up your development time and help you set up your own functional blockchain network in minutes.
Join us on the Hyperledger FireFly Discord:
https://discord.gg/Fy7MJuqw86
Download the Hyperledger FireFly CLI:
https://github.com/hyperledger/firefly-cli
Hyperledger FireFly GitHub:
https://github.com/hyperledger/firefly
Hyperledger FireFly Wiki:
https://wiki.hyperledger.org/display/FIR/Hyperledger+FireFly+Home
----
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
Oh
nobody's
complaining,
okay,
great
all
right,
so
just
want
to
start
off
briefly
with
talking
about
what
we're
going
to
see
when
we
built
firefly,
we
wanted
to
create
a
really
easy
to
use
developer
experience.
We
wanted
it
to
be
quick
and
easy
for
people
to
get
started
with.
We
wanted
the
experience
to
be
powerful
enough
to
meet
the
needs
of
experienced
web
3
developers,
but
also
kind
of
you
know
help
people
get
started,
who
maybe
this
is
their
very
first
web3
project.
A
We
wanted
to
use
tools
that
felt
familiar
and
we
also
wanted
it
to
be
able
to
run
everything
offline
on
a
laptop.
Even
if
you
are
you
know,
on
an
airplane,
you
can
you
can
work
on
building
an
app
against
fireflies
api
completely
offline,
once
you've
downloaded
everything
ahead
of
time.
So
that's
the
developer
experience
that
we're
going
to
see
so
here's
what
we're
going
to
run
today,
I'm
going
to
run
the
firefly
cli
and
I'm
going
to
create
a
local
developer
environment
on
my
machine.
A
This
is
using
all
open
source
tools.
These
are
all
you
can
find
the
source
code
for
all
these
tools
in
the
hyperledger
firefly
get
repos,
so
that
the
cli
behind
the
scenes
will
use
docker
compose
to
run
all
the
components
of
a
super
node
right
on
my
laptop.
So
what
does
that?
Look
like
here's
a
little
picture.
This
is
a
picture
of
two
different
super
nodes
that
we're
going
to
be
running.
I'm
actually
going
to
be
running
three.
A
I
didn't
show
the
third
one
here
just
for
the
sake
of
space,
but
within
our
super
node
there
is
a
firefly
core,
and
this
is
the
brain
that
peter
was
talking
about
earlier.
This
is
the
the
orchestration
engine
that
and
it
also
provides
the
api
layer
and
it
also
hosts
the
web
ui
layer
that
we'll
be
looking
at
as
well.
A
The
firefly
core
talks
to
a
lot
of
different
systems.
Each
of
these
is
going
to
be
running
in
a
different
docker
container
on
my
machine,
including
a
database
data
exchange,
a
blockchain
node,
a
tokens
connector
and
a
variety
of
other
things
outside
the
supernode.
We
are
also
going
to
be
running
an
application
called
the
firefly
sandbox
for
each
member
of
this
firefly
network
that
we're
going
to
be
building
here
now
the
firefly
sandbox
you
can
think
of
as
an
application,
an
end
user
application,
that's
written
to
use
fireflies
api.
A
A
So
we're
going
to
look
at
the
firefly,
dashboard
and
and
the
firefly
sandbox,
those
are
screenshots
of
them,
but
even
better
than
a
screenshot
is
actually
seeing
the
real
thing.
So,
let's
hop
over
to
my
other
desktop
here,
this
is
the
firefly
explorer
or
the
firefly
ui.
This
is
a
web
front
end
that
is
being
hosted
by
firefly
core
and
it's
sort
of
an
inspector,
a
view
into
the
system.
A
A
Just
so
we
can
visually
compare
so
here's
our
network
map.
Right
now,
I
haven't,
run
any
transactions
on
this
network.
So
that's
why
you're
seeing
no
activity,
but
let's
do
some
transactions.
Now,
I'm
going
to
open
a
new
tab
and
I'm
going
to
open
the
firefly
sandbox.
Actually,
what
before
I
do
that?
A
What
I
didn't
show
you
is
that,
while
before
I
started
sharing
my
screen
on
my
other
desktop
here,
I
have
I've
run
the
firefly
cli
and
I've
started
a
network
of
three
members
and
it
prints
the
urls
for
the
web
ui
and
for
the
sandbox
for
each
of
these
members-
and
that's
that's-
those
are
the
urls
that
I
opened
in
my
browser
separately.
I've
also
deployed
erc
20
and
the
erc
721
contract
to
this
chain.
On
the
right-hand
side
of
my
screen,
you
can
see
the
solidity
source
for
the
erc20
contract.
A
It
is,
it
extends
an
open,
zeppelin,
erc20
contract
and
it
adds
just
a
little
bit
of
custom
functionality
on
top
of
that
to
be
able
to
mint
and
transfer
tokens
with
data.
So
we'll
come
back
to
this
in
just
a
little
bit,
but
what
I
want
to
show
you
first
is
the
firefly
sandbox
so
like
I
said
this
is
both
an
example:
end
user
application
that
and
and
also
shows
you
kind
of
how
to
build
each
of
the
different
things
that
you
can
do
with
firefly
into
your
own
application.
A
So,
on
the
left
hand
side
here,
we
have
kind
of
all
with
a
form
that
we
can
fill
out
and
across
the
top.
We
have
these
three
tabs,
and
these
are
really
the
the
three
major
buckets
of
features
that
are
in
firefly,
1.0
sort
of
the
the
things
that
provide
the
functionality,
those
three
those
three
pillars
that
peter
talked
about.
You
know
apps
flows
and
and
digital
assets.
These.
These
can
be
grouped
into
these
three
categories
here.
A
So
what
I
want
to
start
with
is
custom
contracts,
because
that's
that's
the
thing
that
people
oftentimes
think
of
first,
when
they
think
of
hey.
I
want
to
build
a
blockchain
application.
Oh,
I
need
a
custom
smart
contract.
How
am
I
going
to
do
that?
So
excuse
me
for
this
example:
we're
going
to
use
this
we're
going
to
use
a
custom
erc20
contract,
the
one
that
I
just
showed
you
a
minute
ago,
but
this
could
be
any
custom
smart
contract.
It
doesn't
have
to
necessarily
be
an
erc20.
A
It
could
be
something
entirely
different.
What
I'm
going
to
do
first,
is
I'm
going
to
define
a
contract
interface.
A
contract
interface
in
firefly
is
a
way
to
describe
a
custom,
smart
contract
or
any
smart
contract
in
a
blockchain
generic
way.
So
it
encapsulates
important,
specific
blockchain
information,
but
it
also
describes
the
entire
contract
in
a
way
that
firefly,
I
could
describe
both
a
solidity
contract
or
a
fabric
chain
code
using
a
firefly
interface
so
for
blockchains
that
have
a
built-in
format
to
describe.
A
Excuse
me
to
describe
smart
contracts,
their
events,
their
functions,
their
parameters
and
all
the
type
information
such
as
ethereum's
api
format.
There
is
a
an
api
built
into
firefly
to
automatically
do
this
conversion
for
you.
So
if
you
have
the
api
for
your
contract,
you
can
actually
copy
that
right
into
the
firefly
sandbox,
which
is
what
I'm
going
to
do
here.
A
And
I'm
just
going
to
paste
that
right
here,
I'm
going
to
give
this
fire
this
contract
interface,
a
name
we'll
call
this
just
erc
20
with
data
and
we'll
say
this
is
version
1.0
and
I'm
going
to
run
this.
What
happens
when
I
run
this
we'll
see
off?
On
the
right
hand,
side,
there
are
some
things
going
on
so,
but
before
before
we
look
at
the
events
immediately
we
get
back
a
202
accepted.
A
We
get
an
id
here
that
we
can
use
to
track
that
request
through
the
system.
So
firefly
has
a
very
asynchronous
programming
model,
that's
event
driven,
and
so,
when
you
submit
things
to
the
system,
if
the,
if
it
is
accepted
into
the
system,
you'll
get
a
202
and
an
id
back
and
then
the
the
general
pattern
is
that
you
either
have
a
websocket
or
web
hooks
that
are
listening
for
events
coming
out
of
firefly.
So
in
this
case
we've
received
some
events.
A
Those
events
indicate
that
we
have
broadcasted
this
firefly
interface
to
all
of
the
other
members
of
the
system,
and
so
what
this
means
is
now
the
we
can
go
into
our
our
dashboard.
I
can
reload
this
and
we'll
see
that
there
was
a
batch
pin
transaction
that
happened.
Let's
go
look
at
the
in
off
chain.
We
can
look
at
data
and
we
can
see
there
was
a
definition
that
was
created
here,
and
this
is
the
definition
of
my
smart
contract
that
I
just
uploaded.
Well,
that's
great.
A
We
submitted
it
so
it's
appearing
in
our
dashboard,
but
because
it
was
broadcasted
to
all
the
other
members
of
the
network.
I
could
hop
over
to
the
blue
node
as
well,
and
I
could
look
at
the
off
chain
data
tab
here
and
I
can
see
the
same
definition
so
when
we
create
a
definition
in
a
firefly
network,
it's
a
way
of
defining
a
a
piece
of
data
or
or
defining
some
sort
of
structure
that
all
the
members
of
the
network
should
know
about.
A
In
this
case,
it's
this
contract
that
all
of
these
members
will
be
interacting
with
here
shortly.
So
that's
great!
Now,
how
do
we
actually
use
our
contract?
So
the
next
step
is
to
build
an
api
endpoint
for
it.
So
to
do
that,
we're
going
to
register
a
contract
api,
we're
going
to
select
the
contract
interface
that
we
just
created
here
and
I'm
going
to
call
this
erc20
and
then
I
need
to
give
it
the
contract
address.
A
As
we
can
see,
we
we
received
an
event
that
the
message
was
confirmed
and
now
what
this
has
done
is
this
has
built
an
api
endpoint
that
we
can
use
to
interact
with
our
smart
contract
in
addition
to
just
creating
endpoints.
It's
also
created
full
open
api,
three
spec
and
a
swagger
ui
that
we
can
open
and
we
can
interact
with
our
contract
right
here
in
our
browser.
So,
let's
mint
some
tokens
now
I
can
invoke
methods
on
the
contract,
so
I
can
invoke
mint
with
data.
A
I
can
click,
try
it
out.
Let's
mint
a
thousand
now
we
can
send
some
data
with
it,
because
this
is
our
custom
mint
with
data
function.
I
don't
need
to
send
any
particular
data
right
now,
so
I'm
just
going
to
use
a
null
hex
string
and
then
I
need
to
provide
the
two
address.
This
is
the
ethereum
address
that
I
want
to
make
these
tokens
too.
A
I'm
going
to
make
them
to
myself
for
now
so
to
find
my
ethereum
address
for
the
red
node,
I'm
going
to
go
back
to
the
firefly
explorer
and
I'm
going
to
look
at
the
network
under
organizations
in
the
network.
I
can
see
the
list
and
I
can
see
this
is
my
my
org
or
your
org.
That's
what
it
says,
I'm
going
to
click
here
and
then
under
the
verifiers
section,
there's
an
ethereum
address,
and
this
is
the
address
of
the
wallet
for
the
signing
key
for
the
red
node
in
the
network.
A
I'm
going
to
go
back
to
the
sam
sorry
to
my
swagger,
ui
and
paste
that
here
and
I'm
going
to
click
execute
so
immediately
we
get
a
202
back
and
what
I'm
also
going
to
do
now
is
we're
also
interested
in
when,
when
tokens
are
transferred
on
the
network,
it
would
be
great
to
receive
events
for
those
as
well.
We
can
see
on
our
swagger
that
there
are
listener
endpoints
as
well,
to
set
up
a
a
listener
to
tell
firefly.
A
I'm
going
to
do
a
query
now
this
is
a
read-only
operation.
Click!
Try
it
out!
I'm
going
to
paste
again.
My
my
address
here
and
we
should
see
we
have
a
thousand
yep.
We
do
okay,
great!
So,
let's,
let's
do
a
transfer
real
quick
and
we
should
see
that
event
come
in,
so
we're
going
to
go
back
up
here
to
and
we're
going
to
invoke,
because
this
will
perform
a
blockchain
transaction.
Try
it
out,
let's
send
100
and
let's
get
the
address
of
the
green
node
this
time.
A
So
again,
we'll
go
back
to
the
dashboard
look
under
organizations
and
under
the
verifiers
we'll
get
the
ethereum
address
of
the
green
node
and
we'll
paste
that
here,
okay,
we
get
a
202
back.
Let's
go
check
the
balance
of
the
green
node.
Now
so
we'll
go
back,
we'll
scroll
back
down
here
to
query
the
balance
of
it.
A
Let's
check
our
own
balance,
first,
just
to
make
sure
yep.
So
now
we
only
have
900
and
we'll
check
the
green
node
and
the
green
node
has
a
hundred
okay,
that's
great!
Let's
take
a
peek
back
at
the
sandbox
we
receive.
We
see
that
while
we
were
doing
that,
we
received
some
blockchain
events,
and
that
was
because
we
set
up
that
contract
listener.
We
can
start
receiving
events
from
this
custom.
Smart
contract
as
well.
Let's
go
take
a
look
at
the
firefly
explorer
and
see
what
was
going
on
inside
firefly.
A
While
we
were
doing
all
these
things,
so
we
can
look
at
the
blockchain
dashboard.
We
can
see
that
there
were
several
batch
pin
events
from
broadcasting,
the
the
contract
and
the
api.
We
can
also
see
that
there
were
two
transfers
here
as
well.
One
was
the
actually
the
mint
because
mint
actually
just
does
a
transfer
behind
the
scenes,
and
the
other
was
was
the
transfer
of
the
100
tokens
to
the
other
node.
So
we
can
click
on
it
and
see
the
output
see
it
was
from
this
address
to
this
address
and
we
transferred
it.
A
Now,
as
peter
was
talking
about
earlier
hypothetically,
what
if
this
was
a
token
contract?
That's
been
on
chain
on
a
public
chain
as
an
example,
for
you
know,
maybe
even
years
and
there's
a
lot
of
transactions
on
there,
and
we
want
to
build
a
history
of
what
has
already
happened
on
this
chain.
That's
where
the
firefly
token
connector
comes
into
play
and
that's
where
the
concept
of
a
firefly
token
pool
is
used.
A
So
to
do
that,
even
though
this
contract
has
only
existed
for
about
five
minutes
and
we've
only
had
two
transactions
on
it.
We're
going
to
use
this
as
a
hypothetical
example
here,
so,
let's
create
a
new
token
pool,
we'll
call
this
ffc
for
firefly
coin,
we'll
give
the
symbol
as
ffc.
This
needs
to
match
what
was
in
the
the
smart
contract
when
it
was
deployed-
and
I
deployed
it
as
ffc.
It
is
a
fungible
token.
A
So
now,
if
we
go
back
and
look
at
our
explorer,
we
can
go
to
the
tokens
tab
here.
Under
the
token
section,
we
can
look
at
the
dashboard,
and
now
this
is
a
brand
new
page.
That's
just
lit
up,
because
we've
created
this
token
pool,
we
can
see
account
balances
for
everyone
that
has
a
balance
on
here
and
you'll
notice
that
there's
a
lot
of
zeros
here.
A
A
Likewise,
the
firefly
sandbox
also
provides
ways
to
mint
and
transfer
right
here
right
in
the
sandbox
ui.
So
you
you
could
go
straight
to
here
and
you
don't
have
to
actually
interact
directly
with
the
the
swagger.
If
you
wanted
to,
I
just
wanted
to
show
that
sort
of
building
up
from
a
custom
smart
contract
all
the
way
to
these
rich
tokens
apis
now.
So,
let's
mint
a
hundred
now
again,
this
is
this
is
going
to
be
100
times
18,
just
because
of
the
the
way
this
is
represented
in
the
user
interface.
A
A
For
the
sake
of
time,
I'm
just
going
to
kind
of
scoot
through
this
here
a
little
bit
and
then
finally,
let's
burn
one
just
so
we
can
see
what
that
looks
like
in
the
dashboard.
So
I
ran
several
different
token
transactions
there.
Let's
hop
back
over
to
the
explorer
and
refresh
now
we
can
see
our
new
account.
Balance
has
been
reflected
immediately
here
and
we
can
see
the
the
other
transfer
you
can
see
who
it
was
from
to
the
signing
key.
A
So
some
amazing
things
just
make
it
super
easy
to
do
stuff
with
tokens.
I
don't
have
time
to
also
show
non-fungible
tokens,
but
you
can
do
all
the
same
things
with
non-fundable
tokens
as
well
through
here
and
it's
it's
really
powerful,
really
easy,
quick
to
get
up
and
started
the
last
thing
that
I
want
to
touch
on
just
real,
quick
and
then
and
then
we'll
do
some
q.
A
is
messaging
messaging
is
a
foundational
component
in
firefly,
it's
a
it's
a
very
foundational
component
in
building
distributed
applications.
A
I
have
data
on
one
system
that
I
need
to
send
to
another
party
or
to
another
system
that
could
be
a
simple
string.
It
could
be
a
json
object.
It
could
be
a
json
object
that
conforms
to
a
certain
json
schema
that
I've
defined.
That
is
represents
an
important
type
that
members
of
the
multi-party
network
have
agreed
upon
and
it
could
be,
it
could
actually
just
be
a
file
as
well.
A
I
could
click
here
and
I
could
upload
a
file
directly
to
here
so
for
this
I'll
just
send
a
string,
so
this
is
going
to
be
a
broadcast
message.
Yeah
just
like
when
I
was
broadcasting
the
firefly
interface.
This
is
just
going
to
broadcast
a
strength
to
everyone.
So
I'll
run
this
I'll
wait
for
my
batch
pin
to
be
confirmed
here
and
then
let's
go,
take
a
look
at
the
blue
node.
Here
we
should
see
under
under
off
chain
data,
which
is
where
we're
at
already.
A
Actually,
I
could
click
here,
and
here
is
a
message:
let's
take
a
look
at
the
green
node
and
look
at
octane
data
as
well,
and
here
is
the
message
as
well.
So
in
these
cases,
as
someone
mentioned
in
the
chat
earlier,
yes,
the
there
is
a
blockchain
transaction
and
the
the
payload
of
the
message
is
hashed
and
it's
pinned
to
the
blockchain.
The
actual
payload
remains
off
chain.
It
remains
in
a
shared
storage
mechanism,
and
this
is
what
we're
seeing
here.
This
is
what's
why
the
data
is
under
the
opt
chain
tab
here.
A
A
Indeed,
there's
our
secret
message
we
sent
to
green
should
be
able
to
see
it
in
green's
dashboard
there.
It
is,
but
if
we
go
back
and
look
at
blue's
dashboard,
we'll
notice
that
the
blue
node
does
not
see
that
message
at
all.
So
that's
just
a
really
quick
snapshot
of
messaging
messaging
is
really
important.
There's
there's
a
lot
of
different
features
in
it
as
well.
A
I
don't
have
time
to
go
into
all
of
them,
but
hopefully
this
was
just
a
a
very
quick
taste
of
some
of
the
things
that
you
can
do
with
firefly
and
gives
you
an
idea
of
how
you
can
get
up
and
started
with
it.
There
are
guides
in
the
documentation
that
will
walk
you
through
using
the
firefly
cli,
installing
a
firefly
cli
using
it
to
set
up
this
same
environment
that
I
just
built
running
the
firefly
sandbox
and
begin
walking
you
through
each
of
the
three
sections
of
messages,
tokens
and
contracts.