►
From YouTube: Node.js for Chaincode Development
Description
A session of the Tech Study Circle hosted by Hyperledger Sweden on February 26, 2021. In this meetup Node.js for chaincode development is used. What you can expect from this session:
* How to use the --peer-devmod for Node.js with Docker.
* How to install Node.js chaincode into the test-network with the network.sh script.
* How to write a Node.js chaincode from scratch.
* Add-on: Comparison of the Node.js with Golang chaincode as well as analysis of both regarding the docker image size and TPS (transactions per second).
* As an use case example the commission statement is used.
----
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
So
I
try
to
compare
the
node,
the
node.js
chain
code
with
the
gold
chain
code
and
try
to
understand
what
is
better
so
in
case
of
performance
in
case
of
development
and
so
on
so
and
today's
session.
We
will
start
with
a
simple
with
a
simple
chain
code
use
case
and
first
we
will
look
a
little
bit
at
the
use
case.
A
And
then
I
have
developed
a
small
guideline
how
you
can
get
started
with
the
node.js
development
so
because
today
we
will
see
a
little
bit
from
the
dev
docker
dev
network.
So
from
the
pdf
mode
we
have
used
in
the
last
sessions
and
then
we
will
develop
this
chain
code
and
we
will
see
how
we
can
pin
from
scratch
this
chain
code
and
test
it
during
the
development
process.
A
And
then,
when
we
have
finished
this,
we
will
install
this
chain
code
in
the
test
network
and
and
that's
very
easy,
because
the
new
network,
the
new
network
script,
gives
us
a
single
command
line
and
with
this
single
command
line,
we
can
create
the
network
and
install
this
chain
code
as
well.
And
then
we
have
a
situation
where
we
have
two
organizations
with
two
peers
and
then
we
can
test
this
chain
code.
A
And
finally,
I
have
prepared
a
small
script
where
we
can
test
how
fast
my
test
machine
is
and
how
how
many
transactions
per
second
we
can
create
with
this
chain
code
and
in
a
next
in
the
upcoming
sessions.
We
will
compare
this
with
the
same
use
case
in
the
go
link,
for
example,
and
then
we
can
compare.
Is
this
faster?
Is
this
slower
and
also
in
terms
of
peers?
A
So
I
think
that's
an
important
question
is
a
network
slower
when
you
have
more
than
two
peers:
free
peers,
10,
ps,
20
ps,
for
example,
and
which
impact
has
a
proper
endorsement
policy
and
yeah?
So
that's
a
little
bit
an
ongoing
work
from
my
side
and
and
small
parts
of
that.
I
would
like
to
show
you
with
you
and
I
have
created
a
small
example.
I
call
this
commission
statement
because
it's
it
does
a
little
bit
of
calculation.
A
A
A
The
chain
code
so
a
short
overview
about
my
use
case.
So
this
is
a
simple
situation,
so
we
have
two
organization.
This
is
fits
to
the
test
network
example.
So
we
can
imagine
organization,
one
is
the
producer
and
organization.
True
is
here
the
seller
and
we
say
when
the
producer
gets
an
recommendation
from
the
seller,
then
the
seller
should
earn
one
percent
of
the
revenue
and
when
the
producer.
A
That's
only
for
testing,
but
it's
also
a
good
example
for
later
when
we
say
that
when
it
comes
to
discussion,
what
is
the
smart
contract,
then?
What
is
the
chain
code
so?
And
I
would
like
to
explain
this-
that
that,
in
a
permissioned
situation
in
the
permissioned
blockchain
network,
then
we
have
the
companies
have
to
come
to
an
agreement,
so
the
companies
from
organization,
one
and
organization
two
they
must
come
to
an
agreement
that
they
say.
Okay.
I
accept
your
one
percent
or
accept
your
ten
percent
for
a
closed
sale.
A
So
this
is
a
smart
contract
and
this
smart
contract
must
be
done
by
the
companies
by
the
manager,
body,
managers
and
ceos
from
these
two
companies
and
the
chain
code
is
the
programmable
interpretation
of
this
written
smart
contract
between
the
organizations
and
what
happened
when
we
have
to
change
this
parameter
here.
When
we
say
okay,
now
I
gave
you
so
much
recommendations
and
yeah.
A
I
want
two
percent
or
three
percent,
and
then
we
can
test
with
this
use
case
the
upgrade
process,
so
how
we
can
upgrade
the
chain
code
in
the
running
in
the
running
network,
and
this
is
also
a
good
example
which
we
can
do
later
and
see
how
we
can
upgrade
this
check
and
then
today
we
will
implement
this
in
with
node.js
and
later
we
will
see
it
also
the
same
indigo
length,
and
then
we
compare
it.
We
compare
it
here
in
the
container
image
size.
A
This
is
one
key
parameter,
for
example,
so
that
we
can
see
how
large
is
this
nodejs
container
when
it's
running
and
how
large
is
a
golan
container?
Is
it
larger?
Is
it
smaller,
for
example,
and
then
we
will
test
a
little
bit
the
performance
in
this
in
the
test
network,
with
the
default
configuration
with
the
default
block
size
with
the
default
endorsement
policy,
and
this
is
also
a
good
way
to
see
in
my
test
case
with,
I
think
it's
one
cpu
and
two
gigabyte
ram
also.
B
A
A
Machine
must
be
to
come
to
the
certain
transactions
which
we
want
and
we
can
test
this.
We
can
extend
this
analysis
also
with
some
other
components
like
the
endorsement
policy,
how
many
endorsers
you
will
have
in
your
network?
So
is
there
an
impact
if
you
have
10
endorsers
in
this
network
or
not
so
makes
it
sense
to
have
more
endorsers
or
not
so
yeah?
This
is
some.
A
This
are
some
facts
which
we
can
analyze
here
in
this
scenario,
and
the
asset
here
has
four
five
values
so,
and
this
is
a
little
bit
constructed
so
that
we
can
see
some
some
special
things,
so
we
can
see
the
transaction
id,
so
we
can
get
the
transaction
id
from
the
chain
code.
Then
we
can
store
a
string.
A
So
that's
an
important
part
that
when
we
use
dates
here,
then
we
have
to
give
the
correct
date
to
the
chain
code.
Here
then,
we
have
here
two
numbers
yeah,
and
then
we
will
implement
two
simple
methods.
We
will
implement
the
methods
to
store
the
this
commission
statement
asset
and
then
we
will
query
this,
and
for
this
I
will
use
a
so-called
composite
key,
and
this
is
a
way
we
use
only
the
level
db
database
and
the
level
ap
database
has
only
a
key
to
store
and
then
we
can.
Normally.
A
Then
we
can
query
this
in
this
way
or
we
can
create
this
when
we
say
we
want
all
revenues
for
2020
and
the
month
march,
for
example,
then
we
can
can
do
it
as
well,
but
we
can.
We
can
extend
this
also
for
the
day,
but
I
haven't
this
here
and
when
we
add
the
transaction
id,
then
we
will
get
the
the
the
single
revenue.
So
this
is
an
example
to
understand
how
we
can
use
a
composite
key
in
special
configuration
like
this
use
case.
A
So
this
is
not
useful
for
every
situation,
so
this
is
used
for
useful
because
I
say
my
que-
I
don't
use
couchdb
here.
I
don't.
I
won't
only
use
the
the
level
db
because
this
could
also
be
have
an
impact
on
your
performance
and
on
your
security
and
so
on
so
and
yeah
so
and
for
this
situation.
I
want
to
query
all
revenues
per
year
per
month
or.
A
A
short
overview,
what
we
are
going
to
do
now
so
for
this
example
we
need
here
in
the
left
box.
We
have
this
docker
environment
for
the
local
testing,
so
I
use
the
setup
from
the
session
in
the
end
of
january.
Here
so
and
and
then
we
use,
we
try
to
install
this
in
the
test
network,
and
this
is
the
material
from
the
from
the
beginning
of
this
session
so
on
at
the
beginning
of
october
last
year.
So
this
is
this.
A
This
is
built
on
on
this
part
and
then
in
the
middle
here
we
will
use
the
favorite
contract
api
in
the
nodejs
implementation
to
build
this
particular
chain
code,
and
we
will
try
to
run
this
here
during
the
development
so
that
we
see
okay.
When
we
do
this
step,
then
we
can
check
if
this
is
running
or
not,
and
but
we
can
in
this
death
mode.
A
A
B
A
A
B
B
B
B
A
Cs01Gs
and
this
file
will
contain
our
chain
code
logic,
and
then
we
have
to
export
a
contracts.
This
contract
property
within
a
way
of
we
can
have
different
contracts.
So-
and
this
is
the
contract
here
and
then
we
have
to
export,
also
an
object
here
and
and
and
up
and
property
here
with
the
contract.
B
A
A
A
B
A
And
this
function
is,
a
function
is
called
before
transaction
and
after
transaction.
So
we
don't
have
to
use
this,
but
when
we
use
this
then
we
can.
We
use
this
for
certain
things
or
for
logging,
for
example.
So
when
we
need
the
transaction
id
from
this
from
this
transaction,
and
then
we
can
say
okay
before
the
transaction
happen
before
we
in
the
main
process
of
the
transaction
will
come,
then
we
can
grab
this
transaction
id
and
we
can
store
this
in
in
this.
A
B
B
B
A
A
B
B
A
B
B
B
B
B
B
B
B
B
B
B
B
A
B
And
also
to
store
there
to
store
the
the
new
state
with
the
put
state
command
here,
and
so
the
first
part
here
is
is
simple,
so
we
have
the
commission
fee,
we
have
our
revenue
and
we
import
here
are
timestamp.
This
timestamp
is
this
is
a
single
it's
a
simple
javascript
date,
and
then
we
have
here
a
small
case
where
we
can
say:
okay.
A
A
We
store
this
commission,
the
timestamp,
the
type
and
the
transaction
id,
and
then
we
said
we
want
a
new
key
and
we
have
the
possibility
to
create
a
so-called
composite
key,
and
that
means
that
the
key
is
not
a
single
number,
a
single
string
or
something
like
that.
So
we
can
have
a
combination
and
we
can
define
a
combination
like
we
want
with
this
tilde
delimiter
here.
A
B
A
A
A
And
that's
it
so,
and
with
this
we
can,
we
can
create
the
a
new
key
and
we
can
query
later
this
key.
When
we
say
when
we
give
only
the
year,
then
we
will
have
all
transaction
from
this
year
for
this
month
and
then
we
can
say:
okay,
we
want
this
particular
transaction.
Then
we
have
to
use
the
whole
combination.
B
A
B
B
A
B
A
A
A
And
we
do
this
with
the
command
line
peer
train
code
invoke
so
the
other
address
the
channel,
the
the
tranquil
name
so
and
the
c
option
here
has
our
arguments
and
we
say:
okay,
we
call
you
method
store
cs,
then
we
have
a
value
of
hundred,
and
here
we
will
have
a
time
stamp.
So
it's
a
fixed
string
here
and
then
we
have
this
type
and
is
in.
It
is
only
because
it's
the
first
transaction
here
in
the
network.
B
B
B
A
A
Year
and
month
we
have
also
here
the
the
ctx
too,
and
here
we
use.
I
use
another
example.
So
in
the
first
version
here
we
say:
okay,
we
we
have
a
revenue,
we
have
the
revenue
timestamp
and
we
have
the
this
cs
type.
So
and
then
we
can
use
this
variables
here
in
our
function,
but
when
we
have
here
a
lot
of
parameters-
or
we
don't
want
this-
we
can
have
this.
Also
with
this
get
arcs
method
here
and
this
git
get
arcs
method
gives
you
exactly
these
parameters
here.
A
A
A
Yeah
and
the
only
thing
what
we
have
to
do
here
is
to
query
this.
We
have
to
say,
okay,
how
is
our
key
compost
so
with
this
year
method
and
transaction
id,
and
then
we
have
to
deliver
here
and
away
with
elements
in
this
in
the
correct
order.
So,
but
the
good
thing
is:
when
we
only
deliver
the
year,
then
we
will
receive
all
transactions
from
this
year.
A
When
we
deliver
the
year
and
the
month,
then
we
will
receive
all
transactions
from
january
february
and
so
on,
and
when
we
deliver
also
the
final
transaction
id,
then
we
will
receive
the
exact
transaction,
but
this
will
only
work
in
this
order.
So
you
cannot
say
I
want
only
the
I
want
all
transactions
from
every
year
in
the
month
of
october,
for
example,
so
we
have
to.
We
have
to
use
the.
B
A
A
This
one
so
yeah,
you
cannot
say
give
me
only
that
give
me
give
me
the
transaction
regarding
this
transaction
id.
If
you
want
a
function
like
this,
then
you
have
to
create
here
a
new
function
which
does
this
yeah,
and
this
works
only
in
this
order,
so
you
can
leave,
you
can
leave
transaction
id.
You
can
leave
month,
yeah.
B
A
A
A
From
the
documentation,
so
this
is
also
called
the
old
way
and
in
the
documentation
you
will
find
a
new
way,
but
in
my
case
and
and
in
the
time
I
I
could
spend
to
to
to
do
this
example,
it
doesn't
work.
So
I
switched
back
to
this
version
to
finish
this
example
here,
but
in
the
documentation
you
will
find
another
way
with
a
for
a
weight,
loop
and.
B
B
A
So
we
have
to
implement
a
function
to
query
this
information
from
the
command
line
and
when
we
don't
want
the
command
line,
then
we
have
to
use
the
nodejs
sdk,
for
example,
to
connect
to
the
network
and
make
a
client
application
where
and
query
this
this
ledger,
but
this
is
this
is
another
step.
So
in
this
example,
we
see
we
use
the
only
the
command
line
option
here,
but
there
is
no
diff.
There
is
from
the
chain
code
side.
A
And
start
is
it
here
in
this
network
here,
so
we
have
a
test
network
here.
This
is
the
deaf
network.
In
my
slides,
you
find
the
date
for
undeniate
paper.
You
find
the
the
documentation
from
this,
and
here
we
have
a
docker
composition.
So
in
this
test
network
here
we
only
have
a
single
order.
This
is
a
solo.
B
A
B
B
A
You
have
here,
you
can
run
this
network
in
two
different
modes,
so
I
call
this
the
binary
mode,
and
this
is
the
the
setup
which
is
also
descripted,
but
you
need
one
terminal
more.
You
need
four
terminals
to
run
this,
but
you
don't
have
to
use
docker
for
this,
so
you
can
use
a
favorite
without
docker,
because
in
since
the
2.2
version
I
think
we
can
run
appear
and
the
order
also
in
a
native
version,
and
but
you
can
also
a
docker
version
of
that
and
this.
B
A
A
A
B
B
A
Of
this
of
this
trend
of
this
asset,
so
it's
important
to
understand
a
use.
I
use
here
several
times
the
term
transaction.
So
but
we
don't
store
a
transaction
here
in
general,
we
restore
an
asset
and
when,
if
there
is
an
asset,
then
an
asset
has
a
state.
And
then,
when
we
update
this
asset,
then
we
change
the
state
of
the
asset,
and
the
transaction
is
only
there
the
container
around
this.
A
A
So
when
we
change
to
revenue,
then
we
change
the
asset
and
we
have
a
second
version
of
this
asset,
and
this
is
triggered
to
a
transaction,
and
this
transaction
has
a
transaction
id
and
yeah.
But
this
is
also
an
important
part.
So
when
we
are
talking
about
the
key,
so
what
should
be
the
key?
And
this
the
key
could
be
the
car,
for
example
like
in
the
fab
car
example,
a
marble
name
like
in
the
marble
example,
but
the
key
could
also
be
a
transaction
id.
So
you
can
use
this
here.
A
B
A
To
query
this,
but
it
depends
on
your
use
case
in
our
scenario
here
we
don't
have
any
update
so
think
of
a
logging.
So
when
you
try
to
lock
some
some
results
or
some
other
informations,
then-
and
you
have
only
one
state,
then
you
can
use
this
transaction
id
as
a
unique
identifier
for
your
key
and
then
it's
difficult
to
query.
A
B
B
A
B
A
B
A
A
A
B
B
B
A
B
B
A
A
A
And
the
important
part
here
is
the
core
yaml
file
so
and
the
config
txjumbo
file,
so
this
pro
and,
of
course,
the
order
yaml
file.
So
these
three
files
are
the
important
configuration
files
for
your
favorite,
blockchain
and
ferric
needs
to
know
where
this
is
where
the
files
live,
and
this
is
done
with
this
fabric.
Config
path
variable
here.
A
A
And
we
can,
in
fact
that
these
are
two
commands.
The
first
is
the
network
create
channel
command,
so
we
say:
okay,
we
create
a
channel
with
the
name
channel
one
and
we
use
the
create
channel
option
here,
and
this
is
the
first
step
and
then
all
the
crypto
material,
the
organization,
key
tls
and
also
the
connection
profiles
for
the
node.js
client
application.
A
All
this
will
generate
that
to
this
from
this
command
here,
and
if
this
is
ready,
then
we
can
deploy
the
train
code
so
and
that's
new
here,
I
think
so,
because
when
you
deploy
a
go
chain
code,
you
don't
have
to
use
so
much
options
here,
and
one
important
part
here
is
that
okay,
we
say
we
deploy
and
change.
We
deploy
a
train
code.
B
A
B
B
A
A
Okay,
that's
the
chain
code
version,
that's
a
number,
so
you
can
say
always
name
number
one,
and
then
we
have
this
sequence
number
and
this
sequence
number
is
important
because
every
change
on
this
chain
code-
if
you
have
an
upgrade
to
this
chain
code,
then
you
have
to
increase
this.
Seek
this
sequence,
number
yeah
to
two
three,
four
and
so
on,
but
the
chain
conversion
could
also
be
the
version.
One
version.
A
A
Three
whatever
and
could
also
be
the
same
here,
but
the
sequence
number
is
the
number
which
you
have
to
increase
when
you
do
a
chain
cut
up
great
and
that's
why
I've
said
in
the
in
the
in
the
presentation
here.
So
what
happened?
If
we
try
to
change
this,
when
you
say
two
percent
or
twenty
percent
whatever,
then
we
have
to
upgrade
the
train
code
and
the
chain
code
sequence
number
here
is
the
key
for
that
and
yeah
and
then
the
path
to
the
chain
code
and
that's
it.
A
B
B
A
A
A
B
A
A
A
A
A
A
B
A
A
This
could
be
done
also
with
a
single
command.
We
can
use
the
docker
compose
command
here
and
we
have
to
say
we
have
to
set
the
position
from
the
docker
compose
yaml
file
here
so
and
in
the
test
network
in
the
in
the
test
network.
There's
a
folder,
it's
called
docker
and
there
we
have
different
yaml
files
and
the
default
yaml
file
for
the
test
network.
Is
this
one
so
undefined?
And
then
we
can
say:
okay,
we
want
the
locks,
then
we
see
the
locks
and
then
we
use
this
f
option.
A
But
with
the
f
option
here
then
we
have,
this
is
called,
follow
or
follow
up,
and
then
we
will
have
continue
so
here
the
the
terminal.
The
program
is
not
blocked
and
then
where
is
blocked
and
then
we,
when
we
see
some
debug
messages
or
log
messages,
it
will
will
be
printed
here
to
the
terminal
here
and
then,
but
we
can
skip
this
also
with
control
c.
But
in
the
background
the
blockchain,
the
fabric
network,
is
still
running.
B
A
And
then,
okay
to
communicate
now
with
the
test
network,
we
need
some
environment
variables
and
the
test
network
came
also
with
this
results.
It
is
preparated
for
us
and
this
script.
What
we
need
is
this
environment
var
script
here
and
this
you
can
find
also
in
this
in
this
folder
in
this
test
network
folder
under
scripts,
and
we.
A
And
then
we
have
the
possibility
to
call
a
function,
and
this
function
is
also
useful.
So
it's
called
set
globals
and
with
set
globals
one.
We
set
all
needed
environment
functions
which
we
need
to
communicate
from
the
terminal
as
an
admin
user
from
the
organization
one,
and
when
we
change
this
to
set
globals2,
then
we
have
all
environment
variables
in
place
to
act
as
an
admin
user
from
organization2,
and
that's
also.
B
A
A
A
This
is
the
first
invoke
command
here,
be
a
chain
code
invoke,
and
you
see
it's
the
same
like
in
a
test
in
the
development
network,
but
it's
longer
and
the
reason
why
this
is
longer
is
because
we
have
here
the
tls
enabled.
So
we
have
here
the
tls
path
to
the
temp
file.
Then
we
have
the
channel
here.
It's
the
same.
A
We
have
a
chain
good
name,
okay,
but
here
that's
important
here
we
have
a
peer
address
from
the
local
host
and
the
tls
root
certificate
from
this
host,
and
we
have
here
another
peer
address,
yeah,
and
then
we
have
here
the
c
option
with
the
argument-
and
that's
this
also
there.
So
this
aura
tls
hostname
override
this
is
all
all.
A
The
peer
chain
code
invoke
command
here.
This
is
declined,
so
the
terminal
is
declined,
the
environment
variables
say:
okay,
I'm
declined,
and
this
be
a
chain
code.
Invoke
yeah
use
this
environment
variables
to
do
the
invoke-
and
this
is
now
a
client
call
and
the
default
installation
is
has
an
endorsement
policy
and
the
endorsement
policy
is
peri-fold
the
majority
and
when
that
means
that
the
majority
of
all
organizations
have
to
approve
have
to
check.
If
this
transaction
is
is
correct
and
with
two
organizations
and
the
majority,
that
means
that
we
need
both.
A
A
Command
is
here
longer
when
you
do
this
with
the
node.js
sdk
with
the
client.
You
don't
have
to
take
care
on
this
p
addresses
and
so
on,
because
that's
the
job
from
the
node.js
sdk.
So
when
you
have
in
place
the
node.js
sdk
as
a
client
application
as
a
nodejs
client
application,
then
it's
very
easy
to
query
the
data
and
you
can
focus
on
the
creation
of
the
client
application
on
your
rest,
api
and
so
on.
A
So
you
don't
have
to
care
on
all
these
certificates
and
all
these
p
addresses
because
the
node.js
sdk
checks.
What
is
the
endorsement
policy
and
knows
through
the
gossip
protocol
that
we
need?
Oh,
we
need
this
local
host.
We
need
this
beer,
we
need
this
beer
or
we
need
another
beer
and
so
on
so
and
that's
the
advantage
from
the
node.js
sdk.
B
B
A
A
A
A
A
A
This
situation,
you
have
double
dots
here
and
you
can
use
this
and
this
patch
variable
here
as
like
a
string
for
example,
but
this
will
not
work
when
you
have
here
single
quotes
and
in
this
scenario
here
we
have
to
use
the
single
quotes,
because
we
have
to.
This
is
a
json
string
here.
This
is
a
json
string
and
for
the
adjacent
string
we
need
the
double
quotes
here.
B
B
B
A
A
Yeah
so-
and
you
see
here
one
you
see:
okay,
the
chain
cut
container,
they
use
here
and
virtual
amount
of
of
space
from
300
megabytes
here.
So
yeah-
and
you
see
here,
you
can-
I
don't
know
if
this
much
or
not
so-
and
that's
part
of
this
exercise
here
to
understand-
is
this
much
inco
in
comparison
with
golem,
for
example?
So
what
is
the
number
here
and.
B
A
And
that
I
don't
know
if
this
is
a
proper
way
to
test
it
so,
but
I
think
it
gives
me
an
impression
how
the
system
performs
and
yeah
so
in
the
next
couple
of
sessions.
We
will
improve
this
a
little
bit
and
once
I'm
ready
with
the
golem
code,
then
we
can
compare
this
with
the
nodejs
version
and
then
we
will
see
what
is
the
difference,
and
then
we
can
play
a
little
bit.
A
B
B
A
I
mean,
I
think,
that's
a
problem.
Well,
that's
a
question
because
that's
I
think
that's
favorite
is
is
plug
and
play
so
they
call
it
plug
and
play
and
when,
when
they
have
enough
people
which
contributes
to
the
travel
project,
a
java
chain
code
project,
and
then
they
will
increase
this
when
they
have
enough
people
for
the
golang
or
no
chairs
project,
then
this
project
will
work.
A
So
this
is,
I
think,
that's
not
that's
community
driven
and
I
think
it
depends
how
the
community
contributes
to
each
part
project
and
and
in
the
end,
some.
I
read
something
about
the
rust
there's
a
for
chain
code
so
and
when
there
are
enough
people
who
contribute
to
this
project,
then
I
think
we
will
see,
whereas
there's
another
chance
language.
B
A
A
So
they
resume
the
certification,
with
the
node
shares
on
the
chain
code
side
and
also
on
the
client's
client
side.
Man,
that's
a
little
bit
the
reason
why
I
have
focused
me
a
little
bit
on
the
chain
code
side
for
the
for
the
node.js
for
the
chaincode
development,
and
maybe
it
helps
someone
who
is
going
to
try
the
exam.
The
developer
certification
in
march
april
or
this
year.
B
A
Native
support-
and
that's
also,
I
wrote
some
articles
about
from
guys.
They
said.
Okay,
no
chess
is
so
it's
not
performant,
it's
slow
and
it
took
so
much
storage.
The
chaincode
container
took
so
much
storage
and
so
on,
and
I
said
why
and
that's
also
the
reason
why
I
try
to
analyze
this
and
do
a
small
example
like
this.
What
you
have
seen
today
and
compare
this
with
node
shares
and
the
same
with
the
goal
length,
and
then
we
have.
We
see
it
clearly
what.
B
A
Chain
code,
development-
and
I
think,
when
you
know
all
these
steps
here,
then
you
will.
You
will
recognize
that
it's
not
so
difficult
to
write
so
a
standard,
a
chain
code
for
a
standard
implementation.
So
it's
not
so
difficult.
I
think
when
you
know
this
steps
when
you
know
how
you
can
test
this
when
you
know
that
you
have
the
in
the
package
json
the
start
command
when
you
know
that
the
start
start
command
will
be
installed
to
this
ferric
skim
shim
package.
So
these
are
some
some
some
hard
learned
facts.
B
A
B
A
A
Right,
okay,
so
thank
you
for
for
your
attention
and
your
time,
and
I
hope
we
will
see
you
on
the
next
session
and
on
the
next
session
we
will
focus
a
little
bit
more
on
the
notions
part.
So
I
will
go
a
little
bit
through
the
last
session
through
the
requirements
for
the
certification,
so
we
can
extend.
B
A
A
B
B
B
A
So,
but
if
this
is
ready,
then
we
can
switch
back
to
to
this
topic
and
then
I
can
prepare
such
a
such
a
session,
but
this
is
an
open,
meetup
session.
So
if
someone
of
you
want
to
make
a
session,
then
come
connect
me
and
and
then
you
can,
you
can
do
a
session
by
your
own.
You
can
show
also
your
examples
and
what
you
have
learned.
So
that's
not
a
course
or
something
like
that.