►
Description
A recording of the Hyperledger Tech Study Circle session hosted by Hyperledger Sweden on March 26, 2021. In this session the group continues their chaincode deep dive with Node.js where they work on how to access the --peer-devmode network with a node.js client application.
More about the Hyperledger Tech Study Circle is at: https://www.meetup.com/Hyperledger-Sweden/events/275765846/
----
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 #HyperledgerMeetups #Blockchain
A
A
A
We
have
something
to
celebrate
with
this
and
in
this
session
I
will
discover
a
special
topic,
so
this
topic
is
from
a
user
request
or
from
somebody
who
is
watching
this
series
and
he
came
up
with
an
question
how
we
can
use
the
nodejs
sdk
with
the
development
network,
and
when
I
talk
about
development
network,
I
mean
the
docker
dev
mode.
This
is
the
network
we
have
developed
on
the
in
the
end
of
january,
so
we
can
use
a
docker
version
of
that
or
a
binary
version,
and
this
request
is
about
the
binary
version.
A
A
I
will
give
you
an
overview
about
this
development
environment,
so
we
have
done
this
in
the
past,
so
I
have
linked
this
support
material
here
from
the
29th
of
january
this
year
and
in
this
support
material
you
will
find
two
links.
One
of
them
is
broken,
so
I
will
fix.
I
will
fix
that
as
soon
as
possible
and
in
this
session
from
29
of
january,
we
have
seen
how
we
can
create
an
binary
version,
development
environment.
A
We
will
use
this
predefined
chain
code
from
the
asset
transfer
basic
example,
and
then
we
will.
I
will
show
you
how
you
can
connect
to
this
network
and
that's
the
reason
why
I
have
divided
this
session
into
two
parts.
The
first
part
is
the
preparation
of
the
chain
code
development
environment.
So
I
will
show
you
all
the
steps
again.
The
only
single
missing
steps
are
how
you
can
build
the
go
binaries
for
the
b
and
the
ottawa
and
how
you
can
clone
the
favorite
crapo
from
the
official
github
repository.
A
But
this
information
is
also
in
this
support
material
here
and
then
we
will
see
how
we
can
use
this
chain
code
and
what
is
the
advantage
of
this
pad
mode,
and
then
we
will
see
how
we
can
use
the
node.js
sdk
to
interact
with
this
dev
network
and
yeah
support
material
is
here
yeah
and
here's.
A
link
of
that
here
is
the
link
of
the
support
material
from
the
previous
session,
and
then
here
you
will
find
my
two
links
to
the
hyperledger
fabric,
documentation
and
then
to
the
favix
chain
code,
node
version.
A
It's
also
always
a
good
tip
to
read
this
documentation
and
to
see
how
things
can
work
and
yeah
and
here
a
short
overview
of
this
development
environment.
So
this
is
a
try
to
make
this
a
little
bit
understandable.
So
when
we
use
in
this
example,
we
are
going
to
use
the
binary
version.
So
that
means
that
we
will
not
use
any
docker
environment
here.
A
So
we
have
the
possibility
that
we
can
build
and
go
binary
for
the
order
and
they
go
binary
for
the
beer
and
we
can
run
this
two
systems
and
then
we
can
start
the
chain
code
by
hand
and
then
we
can
interact
with
the
string
code
and
in
this
scenario
we
will
have
here
a
simple
network.
The
favorite
repository
gives
us
all
the
binary,
all
the
crypto
material
and
config,
which
we
need,
and
that's
also
the
key
to
this
task.
A
So
when
we
look
into
this
favorite
repository,
then
we
will
find
the
folder
called
sample
config
and
in
this
center
config
we
have
a
folder
membership,
msp
membership
service
provider
with
all
the
mater
decryptor
materials
and
certificates.
We
need
to
get
this
running
and
yeah,
so
we
will
have
this.
We
will
use
only
this
binary
versions
so
and
then
we
need
some
tools
to
control
this.
So
maybe
we
can
use
this
with
a
terminal
multiplexer
or
we
can
use
it
with
the
chops
command
or
with
the
htop
command.
A
So
we
can
because
we
would
like
to
run
this
order
and
the
bigger
in
the
background.
So
we
will
not
see
the
in
the
photo
in
the
foreground
that
the
terminal
is
blocked
in
this
way
and
yeah.
So
then
we
have
appear
and
the
other
are
running
and
we
have
to
create
the
genesis
block.
We
have
to
create
the
channel
transaction,
we
have
to
create
the
channel,
join
the
channel,
install
the
chain
code
and.
A
Approve
and
commit
the
chain
code
according
to
the
new
lifecycle
development
in
favic,
2.2,
and
so-
and
this
means
this
are
the
elements
from
this
from
a
typical
development
environment
which
you
can
have
on
your
local
machine,
and
then
we
need
the
favorite
node.js
sdk.
So
we
have
to
install
it
with
the
npm
command.
So
current
version
is
2.25,
I
think,
and
then
we
need
the
connection
profile.
So
that's
an
important
part.
A
We
will
see
that
in
this
membership
service
provider
folder,
we
will
find
an
admin
chart
and
a
key
store
with
a
private
key,
and
we
need
both
of
them
to
create
an
identity
and
to
convert
this,
to
convert
this
identity
to
and
look
to
the
local
wallet.
So
the
node.js
sdk
works
as
a
client,
and
this
client
has
a
wallet,
a
local
wallet.
A
The
file
wallet
in
our
example
and
we
have
to
convert
the
existing
crypto
materials
here,
the
the
signing
certification
and
the
private
keys
to
this
local
wallet
identity,
because
we
don't
have
a
favorite
c
running
here,
so
we
cannot
register
and
enroll
a
new
identity.
So
we
have
to
use
this
one,
and
for
this
we
will
create
a
small
squig,
a
small
script.
A
I
call
this
edge
to
wallet,
so
you
find
the
script
or
parts
or
elements
of
this
script,
also
in
some
favorite
samples,
especially
in
the
commercial
paper
repository
or
example-
and
there
is
a
similar
script-
and
this
also
called
at
two
volunteers-
and
with
this
this,
this
is
one
of
our
first
tasks.
We
have
to
create
an
identity
for
this
local
wallet
and
then
we
can
use
this
identity
to
interact
with
the
network,
and
these
are
the
steps
we
have
to
do
here
now.
A
Okay,
so
yeah
here
I
have
a
step-by-step
in
guide
here
as
an
overview.
So
the
first
step
is
that
we
have
to
start
the
development
network
and
we
need
the
chain
code
for
this,
and
I
have
copied
the
asset
transfer
basic
chain
code
and
we
can
do
a
little
bit
with
them
and
try
just
to
to
modify
or
to
to
test
if
the
chain
code
is
working
or
something
like
that.
A
So
we
need
a
chain
code
and
since
this
session
is
all
all
about
the
node.js,
so
we
use
the
node.js
version
from
that
and
yeah.
That's
the
first
thing.
So
we
need
the
network
and
we
need
the
running
system
with
a
train
code,
and
then
we
need
the
connection
profile.
So
we
have
to
create
this
connection
profile.
The
connection
profile
is
nothing
more
than
a
json
file
or
a
yaml
file,
which
contains
some
useful
information
for
from
the
network.
So
in
this
connection
profile
you
will
set
your
peer.
A
So
since
this
development
environment
is
not
so
I'm
not
sure
if
this
is
a
real
real
network,
because
we
only
have
a
limited
network
and
that's
the
reason
why
I
think
the
discovery
service
is
not
working
and
that's
also
the
reason
why
we
have
to
disable
the
discovery
service
in
the
connection
part
from
the
node.js
application,
and
we
have
to
write
our
connection
profile
by
ourself
and
yeah.
So
that's
not
really
difficult.
A
A
But
this
you
can
do
this
also
for
a
regular
for
the
test
network
in
the
test
network
example-
and
you
can
do
it
also
in
your
regular
network.
So
that's
there's
no
different
to
do
this
and
then
we
can
create
a
short
command
line
interface
program
so
which
we
can
start
from
the
command
line
with
the
node
prevail,
with
the
node
command
and
then
interact
with
the
network.
A
A
A
A
A
A
A
A
A
That
and
we
need
two
environment
variables
here.
We
need
the
the
path,
so
we
have
to
extend
the
path
with
our
favorite
build
path
here.
So
this
is
the
only
part
which
I
don't
I
I'm
not
showing
here
in
this
example,
how
you
can
build
the
binaries
here,
so
we
have
here
the
order
and
the
beer
and
this
config
tx
again
file
to
create
the
genesis
block
and
the
trans
channel
transaction,
but
how
you
can
do
this.
You
will
find
this
in
the
in
the
documentation
and
you
can
find
as
well.
A
It
is
in
the
documentation
in
the
official
fabric
documentation
so
but
not
in
a
2.2
version.
You
will
find
this
only
in
the
2.3
version.
I
don't
know
why,
but
in
the
2.3
version
you
will
find
also
a
official
documentation
how
you
how
you
can
use
the
this
dev
mode
in
the
binaural
version,
so,
okay
yeah.
So
we
need
the
the
path
and
we
need
the
favorite
conflict
path
because
we
have
seen
here
are
all
all
important
environment
files
located
allocated.
A
A
So
sample
dev
mode
solo
here
you
have
the
profile
for
that,
but
you
have
also
here
other
profiles,
so
you
can
experiment
also
with
other
profiles
here
yeah
so,
but
I
think
for
the
testing.
That's
the
simplest.
This
keeps
keep
the
thing
simple
and
I
think
that's
a
simple
version
or
a
simple
way
to
do
it.
Here's
a
solo
order
for
that
and
I
think
that's
enough.
A
A
A
A
A
And
here
this
you
can
follow
this
both
please.
So
I
think,
then
we
will
have
a
little
bit
too
less
space
on
the
screen.
You
can
follow
this
in
the
on
the
github
page
and
the
same
document
document
on
this
link.
I
have
posted
it
in
the
chat
and
then
you
can
follow
this
directly
there
also
and
okay.
So
now
the
order
is
running
and
the
same.
A
We
can
do
with
the
beer,
so
we
can
start
the
beer,
and
the
important
part
here
is
that
we
start
the
beer
in
this
dev
chain
code
to
be
a
chain
code.
The
depth
mode
is
cl,
equals
two.
So,
and
this
is
the
important
parameter
to
start
the
beer
in
this
now
in
this
particular
mode,
and
then
we
can
here
we
can.
This
is
the
command
here,
and
here
we
set
some
environment
variables
for
this.
For
this
command,
and
here
we
have
the
beer,
the
core
peer
file
system
path.
A
This
is
where
the
blockchain
left,
but
there
is
there's
all
the
data,
and
here
we
have
a
debugger
variable
and
we
have
the
train
code,
listen
address
and
the
operations
address
so
in
the
documentation
from
the
meetup
from
end
of
july.
You
will
find
both
commands
a
little
bit
more
explained
than
here.
A
So,
okay,
so
the
jobs
command,
help
you
to
display
the
option.
R
is
to
all
running
jobs
means
all
are
running
jobs
so,
okay
and
the
next.
Now
we
have
the
beer
running.
We
have
the
order
running
now.
We
need
the
channel
transaction
and
we
have
to
create
it
also
with
the
config
tx
file
program
and
our
channel
should
be
channel
one
and
yeah,
and
we
also
use
here
the
the
profile
for
this.
The
sample
single
msp
channel
profile
and
this
profile
came
also
from
the
config
tx
yaml
file,
which
I
have
shown
you
previously.
A
So
and
that
we
have
to
install
the
chain
code
so
and
for
installing
the
chain
code,
we
have
to
follow
the
new
lifecycle,
train
code,
lifecycle
approach,
our
workflow,
and
that
means
that
we
have
to
package
the
train
code.
Then
we
have
to
install
the
train
code
and
then
we
have
to
improve
the
chain
approve
the
chain
code
and
we
have
to
improve
the
chain
code
only
for
a
single
organization,
because
we
have
only
this
sample
organization
and
then
we
can.
A
We
can
commit
this
chain
code,
but
these
are
the
same
steps
as
you
do
it
in
a
normal
network.
Here,
okay,
so
and
here
I
have
copied
the
asset
transfer
basic
as
a
transfer
basic
example
chain
code.
So
we
can
look
into
this
folder
train
code,
node.js
atp-
and
this
is
the
chain
code.
Here
later
we
will
see
a
little
bit
more
from
this
chain
code
so
that
we
can
see
that
this
is
also
also
running
and
working.
A
So,
but
here
is
the
drain
code
and
then
we
have
to
package
this
chain
code
and
for
node
shares.
We
have
to
specify
the
these
option.
This
line
option
with
the
valiant
node.
So
when
you
do
it
with
the
golang,
then
you
don't
have
to
use
this
because
the
go
is
the
default
language
and
yeah
so
and
for
for
node
and
for
java.
You
have
to
specify
here
this
option
with
and
in
in
this
case.
A
A
Zip
file
and
what
is
inside,
of
this
zip
file
yeah,
so
you
can
look
to
this
session
and
then
you
will
find
here
also
information.
What
is
inside
of
this
chain
code
of
this
package
here
and
why
is
it
important
okay?
So
now
we
have
this
package
here
and
then
we
can
install
it.
So
simple
beer
lifecycle,
drain
code
install
and
we
have
only
one
p
address.
So
it's
the
local
running
and
localhost.
A
So
and
I
export
here
an
environment
variable,
the
only
reason
is:
we
need
this
environment
variable
here
on
the
start,
command
of
the
train
code,
and
so
in
this
way
I
can
keep
this
line
a
little
bit
smaller.
So
that's
the
only
reason
why
I
put
this
in
an
environment
variable-
and
we
need
this
here
in
the
in
the
the
proof
step
as.
A
A
A
So
there
is
nothing
special
in
the
only
special
is
thing
here
is
that
we
have
here,
the
the
very
train
called
stop
command
here,
and
that
means
that
we
have
to
install
the
fabric.
I
think
the
favorite
favorite
common
package,
the
favorite
and
the
favorite
network
package
and
with
the
favorite
common
npm
package,
then
also
and
favorite
train
code
note
program
will
be
installed
and
but
also
this
information
is
in
the
last
in
the
session
from
end
of
january.
A
Okay.
So
let
me
start
this
now:
okay
and
now
the
chain
code
is
running
and
then
now
we
have
a
blocked
window.
So
now
we
have
to
create
a
new
panel
here
in
this
terminal
multiplexer.
So
we
can
do
this
with
a
p
and
comma
not
comma
quotes,
and
now
we
have
a
splitted
panel
here
and
very
step
the
same,
but
we
have
to
set
the
environment
variables
again
here
and
then
we
need
the
package
identifier.
A
A
A
A
A
A
B
A
Now
I'm
wrong,
so
no
okay
forget
it.
This
was
my
mistake
so
and
yeah,
but
this
is
the
important
part
here
that
the
chain
code
is
also
starting
and
in
this
library.
Here
we
have
this
asset
transfer
json
file,
and
this
is
where
the
chain
code
here
is
organized
and
we
have
here
an
init
function.
So
this
in
the
ledger
function-
and
this
is
the
function
we
are
going
to
call
now
that
we
have
some
test
data
into
the
into
our
blockchain.
A
A
A
A
A
A
A
A
So
it
cannot
moderate
this
session,
the
chat
end
and
the
and
the
session
here
at
the
same
time,
so
I
will
ask
if
you
have
any
questions,
write
the
questions
into
the
chat
and
then,
in
the
end
of
the
session,
I
will
try
to
answer
all
your
questions.
Okay,
so
this
is
the
part
here.
So
this
is
our
starting
position
when
you
see
here
so
now,
when
you
we
are
here
now
we
have
a
channel,
we
have
a
chain
code
installed
and
we
have
used
here
the
cli
with
the
cli
commands.
A
A
A
A
A
A
So,
okay,
so
and
as
I
have
mentioned,
the
connection
profile
is,
you
can
have
it
as
a
tracing
file
or
as
a
jumble
file
in
the
yaml
format,
and
the
file
itself
is
nothing
more
than
some
informations
about
the
network,
and
when
we
have
the
discovery
service
running,
then
we
we
need
less
information.
But
when
we
don't
have
this
like
in
this
scenario,
we
have
to
name
all
relevant
informations
here,
and
one
of
the
important
part
is
here
the
organization.
A
So
we
have
to
name
the
organization.
The
organization
is
sample
arc.
So
we
know
this
because
we
have
looked
earlier
into
the
conflict
example
file
so
and
that-
and
there
are
the
membership
organization,
the
name
of
the
organization
is
sample
art
so
and
that's
the
also
the
information
where
this
client
belongs
to
so
then
the
connection
timeout
peer
endorser.
So
that's
a
standard
value,
so
you
can
take
it
as
it
is.
A
The
second
part
is,
we
need
some
information
without
the
channel
this
block
here
in
this
block.
We
have
to
define
the
channels,
so
we
have
only
one
channel.
This
is
channel
one
here
and
channel.
One
has
other
us
and
the
other
is
placed
on
a
local
host,
so
we
can
put
here
localhost
here
here
and
we
have
peers.
We
have
only
one
pier
and
the
p
is
also
on
the
local
host
and
we
have
to
say
some
properties
for
this
pier.
A
We
can
say
that
this
is
an
endorsing
beer,
of
course,
and
if
not,
then
we
will
not
make
an
invoke.
Then
we
will
make
change
queries
and
also
when
we
event
source.
So
when
we
want
make
a
chain
code
where
we
use
events,
and
then
we
have
also
to
set
this
to
true.
So
it's
also
good
for
the
testing
and
finally
developing.
So
in
this
block
we
have
to
define
informations
about
the
channel
and
the
the
channel
name
is
important.
A
Then
the
other
position
is
important
and
the
local
and
the
peers
are
important
so
and
that's
it
so
and
then
some
information
about
the
organization,
the
organization
itself,
it's
the
sample
organization,
the
member
msp
id-
is
sample
arc.
This
is
also
we
have
seen
in
the
conflict.
The
example
file,
and
it
appears
we
have
only
one
pier.
A
And
in
this
scenario,
we
don't
use
a
tls,
so
we
have,
we
don't
have
to
use
the
s
here.
So
so
grpc
is
without
tls
and
grpcs
is
with
tls
and
we
don't
have
any
tls
here
in
this
development
environment
and
that's
it,
and
this
is
the
connection
profile
in
a
minimum
configuration
which
we
need
to
interact
with
this
test
network.
A
A
A
A
A
And
the
node.js
client
can
use
this
wallet
id
to
interact
with
the
network,
and
this
is
one
way
to
to
to
get
an
identity
to
this
local
wallet
and
yeah.
This
is
standard
node.
We
will
need
this
to
standard
node.js
models,
we
need
the
file
system
and
the
path,
and
then
we
need
the
wallets
object
here
from
the
favorite
network
module
which
we
have
installed,
and
then
we
have
here
to
define.
A
We
have
to
write
the
right
path
on
our
current
location
here,
since
we
have
this
in,
we
have
a
client
folder
and
in
the
parent
folder
we
have
this
fabric
folder
here
and
then
here's
the
path
to
the
fabric
and
the
sample
config.
And
then
you
have
here
this
admin,
cells,
folder
and
the
admin
cells
pem
file,
which
is
the
sign-in
certificate,
and
the
key
file
for
this
user
is
in
the
keystore
file.
A
So
it's
the
private
key
file
and
we
gave
them
a
a
name,
so
the
identity
label
name
could
be
any
name
so
and
we
call
this
admin
and
then
we
can
create
here.
A
wallet
object
from
this.
This
is
a
new
file
system
wallet.
So
we
can
have
different
wallet
types
and
the
file
system
wallet
is
one
of
them.
We
can
have
a
memory
wallet
system
or
we
can
even
have
a
couchdb
a
version
of
this
identity
bullets
here
and
then
we
have
to
construct
here
an
identity.
A
A
A
A
I
think
you
can
do
this
also
by
hand,
because
the
only
thing
what
you
have
to
do
is
you
have
to
bring
the
certificate
in
one
line
and
the
brakes
should
be
this
backslash
hands
in
this
backslash
and
format
and
the
same
for
the
private
key
here,
and
then
we
have
this
msp
information
and
dispersion
board.
So
and
then
we
have
an
identity
which
is
which
can
be
used
from
the
node.js
sdk
to
connect,
and
that
will
be
our
next
step.
So
for
the
next
step,
I
need
a
new
file.
A
Is
the
final
program
file
so
and
in
the
helper
file
we
have
here
a
method
is
called
build
connection
profile
and
and
build
wallet,
but
I
haven't
used
this
here,
really
json
string
so
that
this
for
the
formatting
when
we
receive
and
result,
then
we
can
make
a
nicer
json
output
with
that.
But
the
build
connection
profile
here
is
important
because
it
reads
this
connection
for
json
file
and
pass
the
only
thing
what
this
file
does.
Is.
It
reads
the
connection
profile
json
document
here
or
when.
A
If
it's
a
yummy
file,
then
you
have
to
read
it
as
a
yaml
file
and
then
we
pass
this
content
situation
and
give
this
back.
So
this
is
what
this
this
helper
function
here
is
for,
and
our
main
program
contains
this
helper
function
and
the
the
path
module
from
the
node.js
and
then
here
some
requirements
for
the
from
the
favorite
site.
So
we
need
these
wallets
and
gateways
objects
here
and
we
define
some
variables
or
constants
here.
So
we
need
an
ident
we
have.
A
A
A
And
then
we
need
the
gateway,
so
we
create
the
gateway,
and
the
important
part
here
is
in
the
gateway
connect
method.
So
the
gateway
connect
method
needs
the
connection
profile,
as
in
this
case,
as
a
json
document,
then
the
wallet
information
so
which
we
have
created
here
and
then
the
identity
label,
so
which
name
admin
in
this
case
and
then
this
discovery
information
and
here
we
have
to
say,
enabled
false.
A
So
then,
I
think
it's
only
some
limited
information
needed
the
tls
certificate,
the
when,
if
you
use
the
certified
authority
and
the
peer
informations
and
as
localhost
true,
that
means
that
your
system
runs
locally
on
the
same
machine
and
this
it
doesn't
make
a
difference
if
this
one
in
the
docker
container
or
it's
once
in
the
binary
version
here,
but
the
important
part
here
that
you
say
enabled
false.
So
that's
the
important
part
here
by
default.
A
That
is
true,
of
course,
because
then
it's
easier
to
get
all
informations
for
the
node.js
client
and
then,
with
this
information
in
place,
we
can
create
the
net.
We
get
the
network
from
the
channel
name.
Then
we
have
the
network
and
then
we
can
get
the
contract
and
then,
when
we
have
the
contract,
we
are
ready
to
go
for
our
chain
codes,
queries
and,
and
then
so.
This
is
now
my
implementation
here,
so
you
can
do
it.
A
A
I
have
also
here
an
elsip's
block
for
the
sweet
asset
functions
and
we
can
also
call
this
wheat
asset
and
we
have
here
to
name
the
asset
which
we
are
going
to
read,
and
this
is
the
name
of
the
chain
code
of
method
and
you
can
to
know
what
is
in
the
what
is
exactly
then.
You
have
to
look
into
your
train
code
and
you
see
here
so
this
is
the
read
asset,
so
this
is
create
asset
and
you
actually
also
update
that.
A
So
these
are
the
standard
methods
you
can
find
into
the
in
in
this
basic
asset
transfer.
Example
here:
okay,
so
let
us
so
the
read
asset
method:
okay
and
then
we
have
also
you
created,
prepared
to
create
a
set
and
so
on,
and
then
we
have.
If
you
are
finished,
then
we
can
disconnect
from
the
gateway
and
then
we
close
the
connection
together
and
that's
all
and
and
if
this
is
working.
A
We
can
try,
so
we
call
the
node
nodejs
node
index.js
file,
and
then
we
say
we
test
it
and
what
was
it
a
set
one,
for
example,
and
you
see
it
works,
and
but
you
see
it
takes
a
little
bit
on
time,
because
there
is
always
a
connection,
then
it's
the
the
read
process
and
then
it's
a
disconnect
here
and
also
when
you
say,
okay,
create
asset.
This
method
creates.
A
A
A
A
A
And
then
you
see
here
with
the
asset
for
the
test,
and
now
you
have,
and
in
this
way
you
can
change
all
the
chain
code,
all
your
chain.
You
can
develop
the
whole
chain
code,
step
by
step
here
and
test
every
step,
every
single
test,
every
single
step
and
yeah.
So
I
think
with
that
you
have
a
really
good
workflow
to
develop
a
chain
code
and
to
test
it,
and
this
works
as
well
in
nodejs
and
also
in
go
for
example,
but
in
go.
A
A
A
A
A
A
So
you
should
make
it's
better
to
make
an
rest
api
and
when
this
rest,
api
is
running
then
or
as
long
as
rest,
api
is
running
you
connect
only
once
and
and
you
and
during
this
rest
api.
This
express
shares,
for
example,
is
running.
Then
you
can
call
this
the
the
api
endpoints
from
this
rest
api
and
you
don't
have
to
connect
every
time
every
request
to
the
favic
network.
A
So
the
connection
is
stable
and
then
the
response
will
be
much
faster
and
then
it's
here
in
this
example,
where
you
have
always
to
connect-
and
the
final
part
here
is
also
you
can.
So
if
you
have
problems,
then
you
can
debug
this
so,
and
the
node.js
sdk
has
a
lot
of
has
four
debugging
levels
here
involved
and
you
can
set
environment,
one
environment
variable
here
this
this
hfc
logging
and
which
this
you
can
define
here,
a
logging
level.
A
A
Okay,
so
let's
wrap
up
our
session
for
today.
So
let's
come
back
to
this
slide,
and
what
you
have
seen
here
is
how
we
can
use
and
ferric
def
network
how
we
can
build
this.
So
we
have
seen
that
we
can
use
the
binary
versions
and
we
can
let
the
other
and
the
beer
running
in
the
background,
and
we
can
see
how
we
can
monitor
this,
with
the
jobs
command,
yeah
or
or
with
h-stop,
for
example,
and
we
can
use
also
this
terminal
multiplexer
to
control
this.
A
Then
we
have
seen
we
can
connect
this
with
the
cli
commands
very
easily.
So
that's
the
normal
way,
but
sometimes
you
want
to
use
also
the
node.js
sdk
for
that-
and
this
is
a
little
bit
that
comes
with
a
little
bit
more
effort
so
and
we
need
the
main
steps
are
we
have
to
know
what
is
the
connection
profile
here
and
we
need
an
identity
and
the
identity
is
delivered
from
this
sample.
A
Config
membership
service
provider
file
and
we
have
to
convert
this
and
the
converting
process
is
a
simple
or
finish
in
a
simple
json
document.
With
the
signing
chat
from
this
user
and
the
private
key
from
this
user.
And
with
this
information
we
can
create
a
small
program
and
then
we
can
use
this
identity
to.
We
can
use
this
identity
and
the
connection
profile,
but
we
need
both
of
them
to
connect
to
the
favorite
test
network,
and
then
we
can
here.
A
A
A
A
A
A
So,
just
just
to
get
state
here,
the
get
state
reads
always
from
the
world
state
and
the
blockchain.
The
blockchain
is
the
blockchain
with
blockchain
you
mean
the
history,
the
the
the
other
versions
of
an
asset,
and
for
that
there
is
another
command
where
you
can
query
the
history
of
an
asset.
But
the
get
state
gives
you
always
the
world
state,
you
reverse
it
from
the
levy
database
or
from
the
couchdb
database.
Here,
okay-
and
this
is
always
the
latest-
the
latest
version
of
an
asset.
A
Yes,
getstat
returns
the
value
of
the
specified
key
from
the
ledger,
but
always
from
the
last.
The
last
state
of
this
of
this
asset
ledger
is
words
that
in
blockchain
yeah,
just
so
yeah
I
don't
know
so
the
word
state.
So
when
we
talk
about
an
asset,
so
an
asset
is
an
element
in
this
fabric
blockchain
and
to
get
the
information
very
fast
in
hyperledger
fabric.
Does
there
is
a
world
state?
A
The
world
state
is
also
the
latest
state
of
an
asset,
and
when
you,
when
you
talk
about
the
blockchain,
then
you
mean
the
ledger,
for
example,
or
also
the
ledger
so
there's
I
don't
know
we
have
to
look
what
is
the
right
term
for
that,
but
it's
easier
to
understand
that
we
have,
in
the
world
state
the
last
version
of
an
asset
and
all
trio
versions
of
an
asset.
The
history
of
an
asset
is
stored
into
the
blocks
into
the
blockchain
or
into
the
ledger.
A
A
Docker
compose
yaml
file,
docker
compose
files
in
the
test
network.
So
in
the
test
network
you
find
also
configuration
from
where
you
use
the
raft
ordering
system
and
the
raft
ordering
system
you
can
have
more
than
one
order
and
then
you
can
see
how
the
port
numbers
are
organized,
but
you
can
use
here
every
port
number
as
you
want,
so
because
to
connect
to
this
p
or
to
this
order
you
have
to
you
have
to
name
this
part.
A
A
So
you
have
here
a
playlist,
so
we
have
on
the
hyperledger
on
the
official
hyperledger
channel.
We
have
a
playlist
from
hyper
sweden
and
there
you
can
find
all
the
videos
audio
recordings
after
I
would
like
to
introduce
myself
chris
carver
in
the
reboot
and
talk
about
the
fabric
dogs
working
group
and
invite
everyone
to
getting
involved
to
help
people
documentation.
School
yeah,
that's
cool
they
get.
History
for
key
function
is
really
interesting.
A
A
And
then
you
can
see
what
is
needed
to
define
this.
I
think
this
is
a
good
way
to
see
how
this
works,
but
you
have
to
start
the
tricky
part.
Is
you
have
to
start
the
the
test
network
and
when
you
stop,
when
you,
when
you,
when
you
stop
the
the
test
network,
then
all
the
crypto
material
and
also
the
connection
profile
will
be
deleted
and
then
it's
gone.
A
A
I
don't
know
for
for
the
certification,
so
I
think
normally
you
have
so
the
certification
is
on
favorite.
I
think
favorite
2.2
and
in
the
documentation
from
favorite
2.2.
There
isn't
any
information
about
how
you
use
the
development
network
and
how
to
use
the.
I
think,
the
binary
information.
So
this
started
in
favorite
2.3.
A
B
Roland,
I
don't
know
the
specific
answer
to
that
question
either,
but
I
do
remember
that
we
had
had
somebody
from
the
hyperlapse
or
from
the
linux
foundation.
Training
team
come
and
present
to
the
sweden
group
a
while
back
to
talk
about
the
training
and
certification,
so
that,
if
people
are
interested
in
that
recording
is
also
on
youtube.
In
the
sweden
playlist.
A
B
Yeah
yeah
so
hi
everyone,
my
name
is
david
boswell.
I
work
at
hyperledger.
I
also
want
to
introduce
everyone
to
chris
gabriel.
We
we
are
involved
in
the
hyperledger
fabric,
documentation
working
group,
and
I
thought
that
there
would
be
a
lot
of
interest
in
that
group
with
the
people
here.
So
you
know
like
everything
at
hyperledger
the
fabric
documentation
is
an
open
source
effort
and
anybody
is
welcome
to
get
involved
and
it
felt
like
this
group
would
be
interested
in
that
you
know.
B
I
think
you
obviously
are
interested
in
technical
information
about
hyperledger
technologies
and
there
probably
are
places
where
you
would
like
improved
documentation
or
new
documentation.
So
you
know
we
just
wanted
to
talk
a
little
bit
about
that
group.
Invite
you
to
it.
You
know
we
always
welcome
your
input,
comment
contributions
and
again,
if
you're
wanting
better
or
improved
or
more
documentation
for
the
you
know
the
content
you're
wanting
to
you
know
review
as
a
group.
You
know
the
group
that
the
fabric
documentation
working
group
could
be
a
really
great
place
for
that.
B
B
Very
nice
to
meet
you
all
very
interesting
presentation
by
the
way
roland.
This
is
my
first
time
seeing
your
group
here
and
very
well
done.
My
name
is
chris
gabriel.
I
am
a
volunteer
contributor
to
the
documentation
working
group.
I've
been
involved
with
the
group
since
almost
the
very
beginning
and
27
late,
2017
we've
had
some
turnover
in
the
group
and
we're
hoping
to
recruit
more
members.
B
So
we
are
looking
to
other
established
groups
in
the
community
to
maybe
come
in
and
share
their
knowledge,
and
there
are
very
good
instructions
on
how
to
become
a
contributor
to
documentation
on
the
fabric
website.
David
can
link
to
it,
shows
you
how
to
set
up
a
github
fork
for
fabric
and
and
how
to
how
to
contribute
documentation,
step
by
step,
creating
pull
requests
and
and
the
like.
So
just
a
quick
short
introduction
and
a
pitch.
B
B
You
may
have
seen
there
is
a
change
in
the
fabric
github
repo
to
rename
the
master
branches
from
master
to
main.
So,
if
you
think
about
everywhere
in
the
documentation
in
code
snippets,
we
reference
in
instructions
a
master
branch.
Now
we
have
to
go
back
and
redocument
all
of
that
stuff
to
maine.
So
there's
an
example
of
how
other
groups
can
come
in
and
help
clean,
that
sort
of
stuff
up
and
any
help
is
greatly
appreciated
and
if
you're
just
not
sure
how
to
start
or
how
to
contribute.
B
The
best
thing
you
can
do
is
join
our
weekly
documentation
call
ask
questions,
and
we
we
also
do
some
technical
demos.
During
that
call.
I
am
the
founder
of
two
blockcha
founder
of
a
blockchain
company
based
on
hyperledger
fabric.
We
do
a
lot
of
work
in
a
node
sdk
and
we
have
working
applications
and
use
cases
that
we
have
the
the
apis
written
for
and
the
front
end
angular
apps
for
the
ui.
B
B
B
We
book
an
hour
for
that
meeting.
Sometimes
it
doesn't
take
that
long
so
and
if
we
go
every
other
week,
it's
not
a
huge
time
commitment.
But
to
me
how
I
learned
hyper
ledger
fabric
really
good
was
to
become
a
volunteer
in
the
documentation
work
group
because
no
better
way
to
learn
it
than
if
you
have
to
write
the
instruction
manual
for
it.
A
A
You
only
need
the
the
documentation,
the
official
documentation,
so
you
find
a
lot
of
useful
information
in
and
also
the
examples,
and
I
think
the
the
the
switch
from
1.4
to
2.2
with
the
new
test
network.
This
is
really
really
good
because
you
can,
with
with
something
with
a
single
command
line.
We
can
start
in
the
new
favorite
2.2
with
the
new
2.2
test
network.
We
can
start
a
lot
of
different
scenarios
to
test
and
to
play
with
now,
and
this
is
really
really
easy
and
I
think
it
works
every
time.
A
So
it
doesn't
matter
if
you
want
a
favorite
network
within
certified
authority
or
if
you
want
couchdb,
for
example,
so
you
only
have
to
use
the
the
proper
key
for
that
the
the
option
for
that
and
then
the
the
network
is
starting.
Then
you
can
try
and
play
with
that
and
that's,
I
think,
that's
an
improvement
to
the
1.4
version,
because
the
1.4
version
was
a
little
bit
more
difficult
to
use
all
the
different
situations,
and
that's
is
really
good.
A
Also
for
for
for
starters,
and
in
my
session
here
I
can
use
a
lot
of
different
scenarios
with
the
with
the
new
network
and
you
can
start
it
with
any
effort
and
that's
I
think
it's
really
cool
to
test
and
to
use
and
for
and
of
course,
to
learn
of
als
and
also
the
the
background.
Scripts
are
very
good
documented.
A
So
you
can
learn
from
this
a
lot
and
to
see
how
the
things
are
work
together,
and
then
you
can
take
some
snippets
for
your
own
project,
for
example,
or
learn
or
modify
it
in
your
own
way.
So
I
think
the
2.2
version
are
really
good,
but
one
question
I
have
so
why
you
find
the
documentation
through
the
deaf
network
here
to
the
peer
def
network,
only
in
the
2.3
version
and
not
only
2.2
version.
B
A
B
That's
a
good,
that's
a
good
question
and
a
lot
of
the
people
who
were
helping
do
this
have
left
the
group
recently.
So
I
would
have
to
go
back
and
investigate
that
and
get
back
with
you.
There
are
some
features
available
in
2.3
that
are
not
available
in
less
than
2.3,
like
the
osn
admin
channel,
join
for
joining
the
channel
for
the
new
process,
and
so
that
that
would
not
be
available
in
any
of
the
other
branches.
In
some
cases
it
was
written
and
not
back
ported
to
the
prior
versions.
B
B
A
So
if
not,
then
thanks
for
this
for
the
attention
and
in
the
next
session
we
will
move
forward
with
our
way
in
the
nodejs
development,
and
then
we
will
use
the
test
network
and
with
this
test
network
we
can
start
then
favorite
ca,
and
then
we
will
see
how
we
can
use
node.js
and
interact
with
the
favorite
ca
and
can
make
some
maybe
asset
paste.
The
chain
code.
A
Examples
where
we
can
query
some
different
properties
from
the
user
and
then
we
can
make
a
little
bit
more
about
the
permissioning
from
the
chaincode
site
here,
and
that
is
that's
the
yeah.
I
think
that's
the
plan
for
the
next
session
and
then
maybe
a
short
announcement.
My
colleague
from
hyperledger
budapest,
has
announced
also
a
session
about
favorite
ca
and
that
will
be
will
be
in
april.
I
think-
and
maybe
I
will
post
about
that
in
the
next
in
next
session.