►
From YouTube: Debugging Hyperledger Fabric Chaincode_VS Code Extension
Description
A virtual meetup hosted by the Hyperledger India Chapter on June 24, 2023 featuring Ashwath Govindan, co-founder of Spydra speaking about debugging Hyperledger Fabric chaincode.
Hyperledger Fabric Debugger Plugin by Spydra is an Open Source Extension for Visual Studio Code that makes it easy for developers to build and debug Chaincode right from within the IDE. Typically, developing Chaincode for Fabric requires developers to set up a Fabric environment, deploy the developed Chaincode to it and then debug it by printing log messages to the console. In addition, installing a new version of Chaincode in a Fabric network is not as simple as uploading the new code. Developers have to execute the chaincode lifecycle commands for every modification to upgrade the Chaincode. This makes it very difficult to develop code in an iterative manner.
By using the Hyperledger Fabric Debug Plugin, a developer does not need to set up a Hyperledger Fabric network to deploy and test Chaincode. The plugin will automatically set up a local Fabric environment and manage the process of installing the Chaincode.
----
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
Okay,
I
started
the
recording,
so
let's
continue
Yeah.
So
basically,
as
I
was
saying
right,
while
we
were
developing
our
own
developing
chain
code
for
for
our
own
platform
right,
it
was
really
getting
difficult
for
us
to
basically
debug
chain
code
in
real
time
and
truly
do
an
iterative
kind
of
development
in
for
hyperledger
fabric
right
and
that's
where
that's
where
we
started
looking
at
what
are
the
different
options
for
actually
debugging
chain
code
right?
So
what
I'm
going
to
cover
today
is
basically
some
of
our
experiences
while
doing
that.
A
So
the
different
approaches
for
debugging
chain
code
that
already
exists
so
I'll
cover
some
of
that
and
then
I'll
also
cover
a
particular.
You
know
extension
for
vs
code
that
we
have
developed
as
part
of
spider.
It's
we
have
made
it
open
source,
so
you
know
you
can
use
it
and
as
contributed
as
well.
A
But
we'll
look
at
you
know
the
I
apologia
fabric,
debug
vs
code
extension
and
see
you
know
how
that
can
easily
make
that
process
a
bit
more
easy
to
debug
chain
code
right
with
from
within
within
Visual
Studio
Port
as
such.
So
basically,
you
know.
First
of
all,
what
are
the
challenges
while
developing
a
chain
code
for
hyperledger
fabric
right?
First
of
all,
you
know
the
chain
code
literally
runs
within
within
the
fabric
environment
right.
A
So
the
first
thing
that
you
need
to
have
is
a
fabric
environment
itself,
which
means
you
know
you
need
to
deploy
the
peers
orders
and
you
know
basically
set
up
the
entire
high
quality
fabric.
Network
right.
Of
course,
you
have.
You
know,
default
out
of
the
box
test,
Network
and
scripts
available
to
do
that,
but
that
still
becomes
a
prerequisite.
First
of
all,
then
the
second
and
more,
you
know
painful
process,
really
is
the
updating
of
a
chain
code
right?
A
A
So
every
time
you
update
the
chain
code,
you'll
have
to
go
through
this
entire
chain
code
lifecycle
as
such
to
to
do
that
and
then
the
third
thing
is,
you
know,
even
if
you
do
this
right,
unlike
traditional
other
languages
and
Frameworks
right
where
you
can
literally
run
the
chain
code
within
an
IDE
and
put
a
breakpoint
and
then
you
know
do
line
by
line
debugging.
That
is
still
not
possible
really
out
of
the
box
right,
that's
that
requires.
There
are
some
approaches
to
do
that
which
I'll
talk
about.
A
But
you
know
those
are
the
things
which
typically
is
a
challenge
for
for
hypologist
fabric
Developers
and
typically,
what
happens
because
of
that
rate?
Is
that
people
don't
really
do
debugging
within
an
IDE
as
such,
mostly
what
people
start
out
with
and
what
we
also
started
out
with.
Is
you
know
just
login
messages
or
console
messages
and
logging
messages
and
files,
and
things
like
that,
and
then
you
deploy
the
chain
code
and
then
you
know,
you
basically
see
what
the
output
is
and
then
you
make
some
changes
again
deploy
the
chain
code.
A
Then
again,
you
know
see
what
the
messages
are
where
the
flow
is.
You
know
what
the
what
the
flow
of
the
code
is,
what
what
which
code
is
being
executed?
What
is
the
output
of
that?
All
of
that
you
log
in
messages,
and
then
you
try
to
figure
your
way
around
right.
That
is
very
cumbersome
of,
of
course,
right
and
that's
what
we
also
started
to
do
initially,
but
then
you
know
that
was
really
not
helping
us
a
lot
and
it
was
taking
a
lot
of
the
developers
time
over
a
period
of
time
right.
A
So
that's
where
we
started
looking
at
different
ways
of
actually
debugging
chain.
Port,
right
and
hyperledger
fabric
does
support
couple
of
different
ways.
So
there
is
the
hyperledger
fabric,
Dev
mode
which
I'll
talk
about,
and
then
you
know
starting
the
with
the
newer
versions
of
2.x
hypological
fabric
versions.
Right
there
is
this
new
concept
of
deploying
chain
code
as
a
service.
A
Now
she
input
is
a
service
model,
although
he's
used
for
a
completely
different
purpose
or
it
has
been
built
for
a
completely
different
purpose,
but
it
can
actually
be
used
to
solve
this
challenge
of
of
debugging
chain
code
as
well,
which
I
will
which
I'll
also
get
into.
But
even
these
approaches
right
require
you
to
basically
set
up
your
own
fabric
Network
and
then
do
some
configurations
first
right
to
make
all
of
that
possible.
So
let's
look
at
these
approaches.
First
right
and
I'll
cover
the
chain
code
as
a
service
debugging
method.
A
First,
because
that's
the
more
recent-
and
you
know
that's
where
that's
the
recommended
model
of
deployment
also
going
forward
for
chain
board
right.
So,
let's,
let's
take
a
look
at
how
that
can
actually
be
used
to
debug
chain
Port
while
you're
writing
it
so
essentially
a
quick
background
on
the
chain
code
as
a
service
model
itself.
First,
fundamentally,
the
chain
Port
as
a
service
model,
has
been
designed
so
that
you
know
you
have
more
control
on
how
the
chain
code
itself
is
built,
deployed
and
run.
A
So
traditionally
right
when
you,
when
you
create
a
chain
Port,
you
will,
you
basically
have
to
you,
know
upload
it
or
install
it
on
the
peer
and
then
ask
the
peer
to
basically
run
it.
So
the
entire
entire
work
of
building
the
chain
code
from
the
source
code
deploying
it
in
a
you
know,
in
a
container
where
it
runs
and
actually
running
it
was
maintained,
was
done
by
the
by
the
peer
node
as
such.
Right.
A
Of
course,
you
know.
That
means
that
you
can
only
you
know,
run
chain
code
with
which
is
supported
by
the
with
you
know
the
framework
versions
which
is
supported
by
the
peer,
and
you
know
you
literally
didn't-
have
much
control
and
how
it
is
built,
how
it
is
deployed
and
all
that
right.
That's
where,
starting
with
the
2.x
versions
of
hyperger
fabric,
there
has
been
a
different
model
where
you
have
more
control
on
how
the
chain
Port
is
built.
A
First
of
all,
which
is
the
concept
of
extern
external
Builder,
and
then
you
there
is
also
a
concept
of
where
you
can.
You
know,
run
the
chain
Port
by
yourself,
so
you
can.
You
can
run
the
chain
code
in
your
own
container,
essentially
and
then
in
struck
the
peer
node
to
connect
your
chain
port
in
order
to
run
it
right.
A
So
you
you
are
literally
responsible
for
building
hosting
the
chain
port
and
running
it,
and
then
you
instruct
the
peer
to
connect
to
it
and
submit
the
request
to
the
chain
codes,
container
or
server
that
you
are
running
right.
Essentially.
So,
if
I
look
at
the
code
right,
let
me
just
show
you
some
code
of
how
that
actually
works.
A
So
if
I,
so
this
is
the
basically
the
chain
for
external
sample
from
this
fabric
samples
itself.
So
if
I,
if
you,
if
you
go
to
the
fabric
samples
right,
there
is
the
asset
transfer
basic
sample
that
has
different.
That
is
a
bit
extensive
and
it
has
different
versions
of
it
in
different
languages
and
different
ways
of
running
it
right.
A
So
this
is
the
chain
code,
external
sample
that
I'm
actually
showing
you
and
if
you
look
at
the
code
for
that
right,
the
way
this
this
works
is
that
at
the
bottom
there
is
a
the
main
method
and
a
new
chain
code
is
instantiated
with
the
smart
contract
that
has
been
written
and
then
this
chain
code
instance
is
passed
to
a
chain
Port
server
right
and
the
chain.
Port
server
is
then
started.
So
literally
we
are.
We
are
starting
its
input,
server
and
running
it
ourselves,
right
and
while
starting
the
chain
code
server.
A
There
are
few
parameters
that
are
given.
One
is
the
chain
code
ID
which
I'll
come
to
what
it
is,
and
then
there
is
an
address.
So
this
is
the
address
where
our
chain
code
server
is
literally
running,
and
there
are
some
samples
if
you
look
at
the
environment,
variable
sample,
provided
here,
it's
just
a
you
know,
host
and
a
port
right.
So
it
could
be
something
like
this,
where
the
chain
Port
is
actually
running
and
on
this
particular
Port
right.
A
So
that's
what
we
are
literally
running
the
server
on
a
particular
address
and
then
that's
the
first
step
right
and
then
the
second
step
is
typically,
you
know.
When
you
deploy
the
chain
code
right,
you
will
deploy
the
actual
chain
input
on
the
peer,
but
in
the
chain
code,
as
a
service
model,
you
don't
deploy
the
actual
chain
port.
A
You
deploy
certain
files
right,
one
is
a
metadata
file
which
basically
tells
you
certain
information
like
what
is
the
type.
So
there
is
a
so
I
was
telling
that
chain
code
is
a
service.
Basically
is
all
about
running
the
chain
code
outside
right,
but
before
that
you
have
to
build
the
chain
code.
So
there
is
a
concept
of
an
external
Builder,
and
that
is
an
extensive
Topic
in
itself.
A
But
without
going
into
that
in
too
much
detail,
there
is
a
you
know:
inbuilt
or
default
external
builder
for
chain
code
as
a
service
right,
so
you're
basically
telling
that
this
this
the
type
of
the
chain
Port,
is
a
chain
Port
as
a
service,
and
this
is
just
a
label
or
a
name
for
the
chain
code
literally.
So
this
the
metadata.json
doesn't
contain
much,
except
for
telling
that
this
type,
this
chain
Port
ease
of
type
chain
code
as
a
service
right
and
then
the
connection
information
basically
tells
the
instructs.
A
A
So
that's
how
these
two
are
linked
and
then
it's
the
connection.json
file
and
the
metadata.json
file,
which
is
actually
deployed
on
the
peer
instead
of
the
chain
code
to
to
support
this
entire
mod.
So
we'll
look
into
that,
but
that's
the
overall
high
level,
high
level
concept.
So
how
do
I
use
this
now
right
to
my
advantage
to
actually
debug
chain
code
right?
So
the
way
to
do
that
is,
let's
say
you
know
if
you
look
at
the
code
here
right.
A
This
is
a
go:
go
golang
chain,
Port
right.
So
what?
If
I
simply
try
to
run
this
within
Visual
Studio
code
right
and
the
way
to
do
that
normally
in
Visual
Studio
code
is
that
you
go
to
the
run
and
debug
section
and
basically
create
a
launch
file.
First
of
all,
right
and
when
I
create
a
launch
file,
it
will
basically
detect
that.
Okay,
this
is
a
golang
language
and
it'll.
Give
you
some
options
so
launch
a
package
right.
A
This
is
what
we
want
to
do
so
it'll
give
you
some
configuration
like
this
right.
Let
me
save
that
and
then
I
can
actually
click
this
to
debug.
But
if
you
do
this,
plainly
like
this
right,
I
need
to
select
the
golang
file
first,
where
the
main
method
is.
This
is
the
file
with
the
main
method
and
then
I
can
go
and
start
debugging
right.
A
A
That's
because
you
know
because
when
the
exception
yeah
it's
through
an
exception
and
it's
basically
saying
the
ccid
must
be
specified.
So
it's
coming
from
our
code
only
because
you
know,
as
we
saw
in
our
code,
there's
a
chain
code
ID
and
address
where
it
starts,
and
we
haven't
configured
those
those
environment
variables
yet
right.
So
what
I'm
going
to
do
now
is
that
you
know,
because
we
know
that
we
Visual
Studio
can
actually
run
this
code
now.
What
I'll
do
is
I'll
configure
the
chain
Port
addresses
to
be
localhost
right.
A
A
A
B
A
Okay,
so
I'll
just
say
start
the
network
with
the
channel.
That
is
all
with
by
creating
a
channel
my
channel
right
and
when
I
do
that
it
is.
This
is
a
fabric
Network
that
it
will
bring
with
two
organizations
right
or
one
and
Ortho,
so
it
will
do
that.
All
of
that
behind
the
seats.
Now
what
we
have
to
do
is
we
have
to
basically
deploy
the
connection.json
and.
A
A
What
we
will
do
is
we'll
ask
the
peer
node
to
connect
to
the
localhost
9999,
but
remember
that
the
pr
node
is
running
inside
a
Docker
container,
so
for
Docker
container
for
for
a
container
running
inside
Docker
to
access
my
localhost,
you
have
to
use
a
different
way
of
doing
it.
You
can
either
use
the
IP
address
of
the
bridge
or
there's
an
internal.
A
So
this
is
what
we
are
doing
by
doing
this
right.
So
the
mychain
connection.json
looks
like
this,
and
the
metadata.json
is
pretty
simple.
Nothing
no
changes
there
right
so
I've
already
so,
and
how
do
I
deploy
this?
So
you
have
to
basically
create
a
zip
file
with
the
connection.json
right.
It's
simply
zipping
it
into
code.gz,
and
then
you
know
you
take
this
as
well
as
the
metadata
or
Json
and
then
zip
it
again
right.
A
So
these
things
I've
already
done
and
if
I
look
at
the
sample,
folder
I
already
have
that
zip
file
here
right.
So
once
you
have
the
zip
file,
what
you
have
to
do
is
you
have
to
Simply
installed
that
zip
file
in
onto
the
network
that
we
just
created
so
the
above
portions
here
these
are
just
setting
some.
A
And
then
what
you
get
out
of
this
is
the
package
identifier.
So
this
is
the
chain
code,
the
ccid,
that
we
are
talking
about
right.
So
let
me
just
copy
this
and
use
it
here
so
once
we
have
that
right,
then
what
we
need
to
do
is
to
basically
I'm
just
setting
it
as
a
environment
variable
and
then
the
next
step
is
to
approve
the
chain
code.
So
this
is
nothing
different,
regular
chain
code
approval,
as
you
can
see,
it's
it's
nothing
different.
A
We
are
using
the
name
as
debug
CDC
for
the
chain
code
and
we
are
providing
the
package
ID
that
we
got
earlier
and
the
rest
is,
you
know,
providing
the
order
of
information,
the
TLs
information,
Channel
information
and
so
on
and
so
forth
right.
So
let
me
just
do
that
approve
on
behalf
of
or
one
which
is
basically
successful,
and
then
let
me
approve
on
behalf
of
R2.
A
And
once
the
chain
code
is
approved,
you
basically
commit
the
chain
code,
which
is
again
nothing
different,
normally
how
you
do
that
by
providing
the
the
chain
code
name,
the
peer
addresses
the
order
addresses
the
TLs
configuration
all
of
that.
So
this
is,
you
know
how
you
would
normally
do
that
nothing
different.
A
And
once
that
is
done,
you'll
see
that
you
know
the
chain
code
is
now
committed
to
the
channel
right,
the
channel
that
we
have
deployed.
So
what
we
have
really
done
is
we
have
committed
the
we
have
deployed
so
chain
code
as
a
service
way
of
doing
it
and
set
that
okay.
The
peer
should
now
connect
to
localhost
on
my
host
to
submit
the
chain
code
requests
right
now,
let's
come
back
to
my
visual
studio
right.
A
So,
as
I
was
saying
now
we
have
to
run
the
visual
studio
change
code
within
visual
studio
and
basically
provide
these
two
pieces
of
information
right.
So
that
is
where
we
have
to
add
those
as
environment
variables
here
right.
So
what
I'll
do
is
I'll
add
the
these
environment
variables
in
the
launch.json
debug
configuration.
A
A
So
that's
pretty
much
it
right.
Now
we
have
instructed
the
Visual
Studio
to
launch
the
chain
code
and
connect
here
right
and
run
it
now.
Let's
see
what
what
happens
if
we
run
the
chain
code
again,
okay,
I
have
to
select
the
golang
file
first
and
run
so
now
it
will
run
and
it
shouldn't
give
any
exception
right.
A
So
it's
still
trying
but
it'll
yeah.
It's
it's
started
running
right,
but
nothing
has
happened
till
now
because
it
has
just
started
running
so
the
chain
code
server
has
started
right
so
now
the
next
step.
Typically,
you
write
to
invoke
a
chain
code
invoke.
Each
import
is
to
basically
is
to
basically
invoke
a
chain
code
method
right
and
the
way
to
do
that.
Normally
people
how
you
they
do,
that
is
using
the
fabric
CLI
again.
A
So
let
me
go
back
here
and
let's
try
to
invoke
a
method
right,
so
this
chain
code
has
an
initialize,
init,
Ledger
method
and
I'm,
just
invoking
it
from
the
pscli
yeah.
So
let
me
try
that,
okay,
before
that,
what
I'll
do
is
now
you
know,
supposedly
the
debugging
should
work.
So
let
me
locate
the
init
chain
for
initialize.
A
It's
at
the
top
unit,
Ledger
method
and
I've
already
put
a
breakpoint,
but
you
can
put
a
breakpoint
anywhere.
You
want
right.
So
let
me
just
invoke
it
foreign,
and
now
you
can
see
that
something
is
already
blinking
here
and
you
can
see
that
the
breakpoint
has
hit
so
now
literally,
the
chain
Port
is
running
in
Visual
Studio
code
and
when
I
submit
a
request
to
the
peer,
the
peer
calls
our
chain
code
and
which
is
running
with
the
visual
studio,
and
then
the
breakpoint
gets
hit
right.
So
now
you
can
actually
inspect.
A
You
know
everything,
that's
so.
If
I,
if
you
can
do
line
by
line
debugging,
you
can
inspect
the
variables
right
what's
happening.
What
are
the
values?
You
can
look
at
the
context
you
can,
you
know,
do
F10
f11
step
into
step
over.
All
of
that
you
can
continue
right
and
I
just
pressed
F5
so
that
it
continues,
and
then
you
can
see
that
the
chain
code
invoke
is
successful
and
you
get
the
result.
So
this
is
one
way
of
doing
it
right.
A
A
Yeah,
so
so
this
is
this:
is
this
bit?
This
is
literally
what
we
did
right
so,
irrespective
of
what
language
it
is,
it's
golang
or
node.js
or
Java.
As
long
as
you
configure
Visual
Studio
to
debug
the
language
corresponding
language.
First,
then
you
can
do
these
additional
steps
of
configuring,
the
connection.json
and
metadata.json
properly
and
then
start
debugging
it
right.
A
A
First
of
all,
you
know
there
is
no
test
Network
kind
of
out
of
the
box
script
per
se,
which
will
set
set
this
up
for
you,
so
you'll
have
to
you,
know,
download
the
peer
download
or
build
the
peer
binaries,
and
then
you
know,
run
the
order
peer,
CLI,
binaries
yourself
and
then
do
the
configuration
for
this
to
work.
But
the
way
this
works
is
that
you
know
so.
A
This
will
work
with
so
the
earlier
model
that
I
was
showing
you
right
the
chain
code
as
an
external
service
that
will
work
with
only
code
which
is
written
for
the
newer
external
service
model.
This
will
work
with
anything
right
literally
because
this
here
you
will.
Basically,
you
are
basically
configuring
peer
to
run
in
what
is
called
as
a
Dev
mode,
and
there
is
some
documentation.
You
know
in
the
hyperledger
fabric,
documentation
site
which
tells
you
how
to
do
that.
A
A
So
the
the
steps
of
committing
the
chain
code
and
approving
the
chain
Port
by
each
organization
and
committing
the
chain
code
need
not
happen
every
time
you
can
change
the
chain
code
upload
it
again
and
it
will
run
when
you
change
code
without
these
additional
steps
to
be
done.
So
that
is
what
fundamentally,
it
does
right
at
a
very
high
level,
but
for
it
to
work
right.
First
of
all,
you
have
to
use
solo
as
the
consensus
solo,
as
we
all
know,
is
sort
of
deprecated
at
this
time,
but
it
still
works
right.
A
So
for
this
particular
reason
of
debugging,
you
can
still
use
it
because
it's
not
really
production
port
or
production
deployment
that
you're
doing
here
right,
so
you'll
have
to
use
so
low.
So
you
know,
you'll
have
to
create
the
Genesis
block
by
running
config
exchange
with
solo
as
the
profile
right
and
then,
while
while
starting
the
order
node
right,
you
have
to
use
the
solo
profile
and
the
samples
for
that
is
given
in
this
particular
location,
right
and
then
more
then.
A
What
you'll
have
to
do
is
when
you
start
the
peer
node
right,
you
will
have
to
start
it
in
with
an
additional
switch
saying
peer
chain
code.
Dev
is
equal
to
true.
So
what
happens
by
doing
that?
And
then
you,
you
have
to
install
the
chain
code
that
you're
written
and
then
approve
and
change
input
one
time
right.
So
this
this
task
here
to
do
one
time.
A
That
is
when
you
run
similar
to
what
we
saw
in
the
chain
code
as
a
service
model,
you
can
actually
run
the
chain
Port
within
Visual
Studio
code,
and
while
you
are
starting
the
chain,
Port
right,
you
basically
configure
some
other
environment
variables,
like
the
name.
Tls
has
to
be
disabled
because
you
know
solo
doesn't
work
with
well
with
TLS,
and
for
that
matter
we
have
to
disable
TLS
and
then
what
we
say.
What
we
do
is
that
when
we
start
the
chain
code,
we
have
to
pass.
A
A
The
slight
complication
with
this
method
is
that
you
know.
First
of
all,
you
have
to
do
more
work
to
actually
set
up
the
network
and
then
the
second
thing
is,
you
know,
depending
upon
the
language
right.
The
way
you
configure
the
chain
code
in
Visual,
Studio
like
in
go
for
go,
you
do
this,
but
for
node.js
you
have
to
slightly
give
the
arguments
in
a
different
way.
So
the
program,
the
way
that
you
launch
the
in
go
right,
you
have
to
launch.
A
So
those
are.
You
know
two
methods
that
exist
sort
of
out
of
the
box
within
hyperledger
fabric
itself,
which
you
can
use
to
your
advantage.
But
of
course,
as
we
saw
right,
you
still
need
to
deploy
the
network.
First,
that's
one
thing,
and
then
you
have
to
understand
these
additional
configurations
that
you
have
to
do.
You
have
to
do
it
in
the
right
way
and
then
only
things
will
work
right.
A
A
A
Yeah,
so
this
is
the
same
same
chain
code,
but
I've
named
it
differently
right
and
it's
opened
in
a
different
window,
as
you
can
see,
there's
nothing
in
the
launch,
dot,
Json
or
anything
right.
So
this
is
a
fresh,
fresh
sample
that
I've
just
opened.
Think
of
it
that
way.
Right
now,
what
you
can
do
is
that
there
is
an
extension
called
hyperledger
fabric.
Debugger
right.
A
You
can
basically
search
it
within
Visual,
Studio
Marketplace
and
it
will
come
up
like
this
hyperledger
fabric
debugger
and
once
you
install
it
right,
it'll
come
up
in
the
left
pane.
Now,
if
you
go
here,
there's
nothing
there
right
now,
but
because
we
have
not
done
anything
right.
So
let's
say
you:
you
want
to
debug
the
Golan
chain
code
here
right,
and
this
is
the
same
change
input
as
I
was
saying
which
is
written
for
a
chain.
Four
is
an
external
service
yeah.
A
C
A
You
can
customize
it
you
can
put
whatever
Port
you
want,
it's
just
a
port
where
you
know
the
chain
code
will
be
launched,
so
whatever
you
configure.
So
let
me
go
back
to
that
example.
So,
whatever
you
configure
here
right,
the
same,
you
have
to
put
here,
okay,
so
this
should
match.
So
this
is
where
you
are
saying
where
the
chain
code
should
be
launched,
and
this
is
the
section
where
we
are
saying
you
know
instructing
the
peer
where
it
should
connect.
So
these
should
match.
That's
all
it's
not
hard
coded
you
can.
C
D
A
Yeah,
so
this
is
the
only
built-in
type
literally,
but
basically
this
type
you
can
use
to
so
there
is
this
concept
of
external
Builder
in
in
fabric
right,
where
you
can
say
that
you
can
customize
the
way
the
fabric
here
will
build
your
code,
so
you
can
Define
your
own
type
and
then
you
can
define
a
builder
for
that.
So,
if
you
look
at
here
right,
there
is
a
sample
Builder
that
is
given
here.
A
So
this
Builder
is
what
will
basically
use
this
type
at
the
end
of
the
day.
So
if
you
want
to
create
your
own
builder
right,
you
can
Define
your
own
type
and
then
use
a
custom
builder
for
that.
So
you
can
look
at
the
how
the
external
Builder
Works
in
in
Fabric
and
that
will
give
you
a
much
better
understanding
of
how
how
how
that
looks
yeah.
So
here,
if
you
see.
A
So
this
is
this
doesn't
come
automatically.
This
is
coming
here
because
I
have
installed
the
extension,
so
this
extension
is
contributing
this
additional
option
here.
So
if
you
select
this
right,
what
it
has
done
is
it
has
created
another
configuration
section
here
right.
So
now
you
can
see.
There
are
two
configuration
section.
One
is
the
default
one
which
which
Visual
Studio
code
creates,
which
is
the
just
saying:
I
can
debug
go
go
to
import,
and
now
there
is
another
configuration
section
that
is
created
here.
A
A
The
other
is
the
type,
so
the
the
extension
basically
supports
golang
and
node,
so
HLF
go
is
for
golang,
so
this
is
go
land
and
if
you
change
it
to
node
and
I'll
show
that
come
to
that
later,
it's
the
it
will
support
node,
and
then
there
is
another
flag
which
is.
This
is
a
chain
Port
as
a
service,
so
we
are
talking
about.
You
know.
A
There
are
two
ways
of
developing
chain
code
right,
so
chain
quarter,
service
way
or
the
older
way,
because
this
is
a
chain
Port
as
a
service
kind
of
a
code.
I'll
switch
this
to
true
right
to
instruct
the
debugger
that
the
code
has
been
developed
to
work
with
chain
code
as
a
service
model
right
and
that's
pretty
much
it
right.
A
You
don't
have
to
so
what
I'll
do
is
I'll,
also
just
to
be
sure
what
I'll
do
is
I'll,
remove
the
network
that
we
created
right,
so
I
will
okay,
so
I
will
do
dot,
slash
network,
so
I'll,
just
search
down
so
I'll
bring
down
the
network
right
the
earlier
one
that
we
have
created.
So
we
don't
have
that
Network
anymore,
and
all
that
we
have
done
is
open
the
chain
port
and
created
this
configuration
file
right
and
that's
it
now,
if
I
click
on
debug.
A
A
So
if
I
look
through
the
through
the
messages
here,
everything
that
was
done
to
create
a
network
right
is
being
done
automatically
by
the
chain
code.
Okay,
I
got
an
error
because
you
know
as
again,
I
have
to
select
go
file
before
I
click,
the
debug,
which
I
always
forget.
Let
me
do
that
again
and
if
I
look
at
the
output
here
right
is,
as
you
can
see,
it's
creating
a
CA
container.
Cli
container
order
appear,
so
everything
that
happens
when
you
create
a
network
is
automatically
happening
here.
A
So
the
chain
code,
the
the
extension
actually
does.
All
of
that
for
you
right
and
then
it
deploys,
creates
the
channel
if
I
look
through
all
of
that,
it's
creating
a
channel,
and
then
it's
deploying
the
chain
code
into
that
channel,
and
you
know
everything
that
we
discussed
about
how
to
manually
configure
the
chain
code
as
a
service
model
is
being
done
automatically
by
the
plug
plugin.
A
Literally,
that's
what
is
happening
so
now
that
debugging
is
actually
started,
but,
as
we
are
seeing
earlier
in
order
to
actually
submit
a
request,
we
use
the
pr
CLI
earlier
right,
but
that
defeats
the
purpose
right.
If
now
again,
I
have
to
go
somewhere
else,
basically
use
the
pr
CLI
and
submit
the
request
right.
So
that's
where
the
second
thing
that
the
plugin
does
is.
A
It
provides
a
way
to
submit
the
request
right
from
within
Visual
Studio
code
and
the
way
to
do
that
is
by
creating
a
file
with
a
DOT
fabric
extension.
You
can
name
it
anything
right,
like
I
have
name,
we
already
created
a
file
called
test.fabric
here,
but
the
name
doesn't
matter
and
you
can
actually
create
as
many
files
as
you
want
right
so
and
how
does
the
file
look?
It's
a
Json
file.
A
Basically,
it's
a
Json
file
which
you
know,
which
is
an
array,
and
there
are
individual
objects
that
you
can
create
within
it,
and
the
structure
of
this
is
first
of
all.
You
say
whether
you
want
to
invoke
or
query
so.
Just
like
you
know,
when
you're
invoking
through
the
pr
CLI,
you
say
whether
you
want
to
invoke
or
query
you
say
you
basically
say
that
first
and
then
which
method
right
so
init
Ledger
is
a
method
which
doesn't
take
any
argument.
So
all
that
you
have
to
say
is
invoke.
A
Init,
Ledger
and
you'll
see
that
the
moment
you
type
invoke
right.
So
let
me
type
something
new
here:
create
a
new
section,
I'll
type
invoke
or
query
you'll
see
a
send
request,
link
appearing
above
right,
so
like
here
it's
appearing
here,
so
you
click
that,
and
you
can
see
that
you
know
the
result
will
be
on
the
right.
So
the
invocation
is
successful.
A
A
Let
me
put
a
breakpoint
at
the
top,
so
let
me
put
it
in
get
the
read:
read
essay
here:
yeah
and
I
go
to
the
dot
fabric
file
and
let
me
create
a
new
section
for
that,
because
I
don't
have
one
so
I'll
say:
read:
asset
is
what
I
want
to
do
and
arguments,
because
this
expects
some
arguments
and
what
does
it
expect?
It
expects
the
context
and
an
ID
right.
So
ID
is
a
string.
So
let's
say.
B
A
A
A
Sorry,
let
me
go
back
here
and
put
the
big
points
here
and
if
I
send
requests
the
breakpoint
is
hit,
and
then
you
can
see
that
the
ID
that
was
sent,
which
is
A1,
is
what
is
coming
here
right
so
and
then
you
can,
you
know
debug
as
you
normally
would
do
yeah.
So
that's,
that's
the
let's
look
an
easy
way
of
doing
it.
As
I
was
saying
you
know
this
works
with
golang
as
well
as
node.js
jail
code.
A
So
let
me
just
quickly
switch
to
a
different
chain
code,
which
is
the
node.js
change
code,
and
this
is
again
of
coming
from
fabric
samples.
Only-
and
this
is
the
chain
code
that
I'm
using
here
is
the
asset.
Ledger
asset
transfer,
Ledger
queries,
because
this
has
some
more
advanced
features
around
querying.
So
let's
quickly
look
at
that.
So
this
is
a
chain
code
that
I've
just
opened
in
Visual
Studio
code
and,
as
usual,
I'll
go
to
the
debug
section,
create
launch
file,
create
node.js,
launch
file
this
time
and
as
earlier
basically.
A
A
And,
as
you
can
see,
it's
doing
a
similar
thing:
it's
creating
the
network,
launching
the
chain
code
and
all
of
that,
and
once
it's
ready,
it
starts
printing.
The
message
that
it's
ready
again
I
can
create
a
DOT
fabric
file,
but
with
the
the
methods
that
exist
in
this
one
right.
So
similarly,
there's
an
init,
Ledger
method
in
the
node.js
chain
code
that
gets
initiated.
A
A
So
when
I
click
that
it
comes
here
and
as
usual
right
I
can
basically
inspect
the
the
variables
the
I
can
inspect
the
ID
here,
for
example
like
in
Step
through
step
over
all
of
that
right
now,
there
are
some
additional
features
that
this
supports.
The
the
plugin
supports
like,
for
example,
if
I
go
to
the
dot
fabric
file
right
normally,
when
you
submit
a
argument
right
everything,
even
if
you
do
it
using
the
pr
CLI,
everything
is
a
string.
A
A
Way
of
doing
it
is
mentioned,
and
you
know,
you'll
have
to
stringify
and
then
submit
it
right
like
this
will
work,
but
this
is
a
bit
difficult
right
and
especially
if
your
Json
is
huge,
so
that's
where
we
also
the
plugin,
also
supports
instead
of
stringifying
it
and
support
and
and
submitting
it,
you
can
basically
submit
it
as
a
Json
itself
right.
So
this
this
will
work,
and
this
will
also
work
right.
So
when
you
do
that,
it's
actually
changing,
but
let
me
Let
Me
Show
You
by
calling
something
else.
A
A
A
So
if
you
want
to
put
manually,
stop
start
or
remove
right
if
you
want
to
reset
the
network,
so
the
way
this
will
work
is
that
when
you,
when
you
quit
Visual
Studio
code,
it
will
stop
the
network
next
time
when
you
debug
the
same
network
will
be
reused
so
any
as
any
anything
that
you
have
submitted
right.
Any
transactions
you
have
made.
Everything
will
be
there
in
The
Ledger
as
such.
A
So
you,
you
know
there
will
be
continuity,
but
let's
say
you
want
to
start
from
scratch
right,
so
you
can
remove
the
network
and
then
then,
when
you
debug
the
next
time,
you'll
get
a
fresh
Network
all
together.
So
there
are
some.
You
know:
options
to
manage
the
network
that
is
created
automatically
by
the
plugin
and
then
the
other
thing
that
you
can
do
is
you
you
can
use.
You
know
different
users.
A
So
if
you
have
a
case
where
you
want
to
use
different
users
and
do
some
testing
right
by
default,
the
plugin
will
create
two
users
for
you
or
open
admin
and
user
user.
One
or
good
admin
has
an
admin
role
and
user.
One
has
a
client
role
within
within
fabric,
but
you
can
actually
create
more
users
right,
like
I,
can
say,
create
user
10,
let's
see,
and
that
will
be
created
and
in
the
test.fabric
right.
A
A
A
Okay,
I
think
maybe
when
I
did
I
click,
something
here,
okay,
I
think
I'll
probably
have
to
reset
the
network
but
I.
Basically,
you
know
when
you
when,
when
you
use
a
different
identity,
it
should,
and
if
you
inspect
the
context,
object
right,
you
should
actually
see
the
different
identity
that
that
you
basically
set
up
right.
So
the
plugin
basically
supports
multiple
users
to
be
created
in
a
wallet
and
things
like
that.
A
So
yeah,
that's
that's
pretty
much.
What
I
wanted
to
show
you
so
feel
free
to
You
Know,
download
the
plugin
and
play
around
with
it.
As
I
was
saying
you
know,
at
spider
we
also
provide
a
our
mission,
is
to
you
know,
make
the
adoption
of
blockchain
easier.
So
we
provide
a
platform
that
you
can
also
try
around.
So
you
can
go
to
spider
dot
app
and
if
you
go
to
get
started
right,
you
should
be
able
to
register
yourself
and
try
the
platform
out.
A
D
D
A
A
About
yeah,
it
actually
does
go
to
the
Peoria,
so
you
know
if
you
so.
Basically
the
you
know
what
the
plugin
does
is.
It
actually
creates
a
real
Network
behind
the
scene.
It's
a
single
work
Network,
as
you
can
see,
so
there's
no,
no
multiple
organizations
at
all,
but
it
actually
creates
a
real
Network
behind
the
scenes
and
the
transactions
are
submitted
to
the
peer.
It's
just
that
it's
all
managed
behind
the
scenes
for
you,
so
you
don't
have
to
create
your
own
network,
but
it's
actually
going
to
the
hyperledger
fabric.
A
A
B
A
B
A
We
support
both
actually,
and
in
fact
you
know
in
the
samples
that
I
was
showing
you
right,
the
JavaScript
one
is
actually
written
with
the
older
way
of
doing
it.
So
it's
not
chain
code
as
a
service,
so
there
is
a
in
the
configuration
for
the
debugger
right.
There
is
a
particular
key,
whether
it's
a
chain
code
as
a
service
or
not.
A
D
I
have
another
question:
how
this
private
data
collections
or
the
upper
mechanism,
if
I
mentioned
in
the
chain
code
like
if,
if,
for
example,
if
I
put
if
conditions
in
the
chain
code
saying
that
only
from
this
organization
comes
in,
you
allowed
to
execute
the
chain.
Call
in
that
case,
how
that
can
be
handled
in
the
by
the
plugin.
A
Yeah,
so
the
plugin
plugins,
the
reason
really
to
just
debug
your
code
right
literally.
So,
if
you
look
at
the
the
network
that
it
creates,
it's
a
single
org
Network
and
which
means
you
know,
there's
only
one
pr200
right,
so
there
is
no.
There
are
no
multiple
peers.
We
are
not
talking
about
endorsement
policies
or
so
private
private
data
collection
will
work
but
endorsement,
but
there
is
no
endorsement
policy
concept
as
such
in
the
in
the
network
that
the
plugin
deploys
and
the
reason
for
that
is
it's.
A
A
D
A
Not
using
the
plugin,
but
yes
using
the
manual
the
way
that
I
talked
about
right.
Where
you
know
you
can
basically
do
the
right
configurations,
either
as
a
Dev
mode
or
chain
code
as
an
external
service
in
your
existing
Network.
They,
then
you,
then
it
can
do
yes,
but
not
using
the
plugin.
But
yes
in
the
roadmap.
We
want
to
extend
the
plugin
so
that
the
debug
works
with
any
existing
Network
that
you
have.
A
A
Yes,
so
if
you
go
to
the
plugin
itself
right,
the
extension
plugin
itself,
so
you
can
actually
see
the
documentation
right
here
and
there
are
links
to
the
other
to
the
GitHub
repo.
Also-
and
things
like
that.
So
if
you
see
here
right,
there's
a
quick
start
and
you
can
view
this
in
the
marketplace
also,
so
there's
a
quick
start:
how
to
do
that.
All
the
instructions
are
here
right
here.