►
From YouTube: Running and Managing Solidity Smart Contracts in Hyperledger Fabric using Web3 - Part 1
Description
Swetha Repakula & Jay Guo, IBM
Hyperledger Fabric is a permissioned blockchain platform where people build applications to communicate and interact with deployed smart contracts. However, smart contracts and apps must be written in programming languages like Go or Javascript. Alternatively, Ethereum made it friendly to write smart contracts by inventing Contract-Oriented Languages, e.g. Solidity, and created a Web3 library that can be used to interact with smart contracts.
The talk will cover how an EVM has been integrated into Fabric, enabling users to write contracts in Contract-Oriented Languages as well as interact with them via the Web3 library. Developers familiar with Ethereum can easily develop on Fabric, leverage tools like Truffle & Remix, as well as migrate their Distributed Apps (DApps) with minimal effort. The talk will also describe use cases where permissioned blockchains are more desirable.
----
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 #HyperledgerGlobalForum2018 #Blockchain
A
So
thank
you
for
being
interested
in
managing
evm
contract
in
fabric.
So
this
is
a
fairly
new
project.
We
haven't
been
officially
released
yet,
but
it's
gonna
be
very
simple
and
the
whole
purpose
is
to
all
be
able
to
support
a
smart
contract
written
in
solidity
or
Viper.
Basically,
everything
that
can
be
compiled
into
you
get
back
the
bike
cult,
so
that
could
be
run
in
fabric
also
I
want
to
first
of
all
have
a
sign
of
hands
like
how
many
of
you
are
familiar
with
easier.
A
How
many
of
you
have
been
like
writing,
contract
or
writing
applications
or
d/f
in
a
theory,
oh
cool,
and
how
many
of
you
are
familiar
with
fabric
more
like
happy.
Has
this
white
fabric?
Okay,
cool,
that's
nice,
because
we
kind
of
have
assume
people
will
have
some
basic
knowledge
about
fabric
and
okay,
that's
got
started
I.
This
is
swetha
replica
from
IBM
the
United
States
I'm
Jay
from
IBM
China,
and
we
we
are
first,
several
people
working
on
this
project
and
the
goal
today
is
to
let's
go
through
some
basics
of
a
few
of
transactions.
A
So
people
have
a
exactly
how
that
works
and
we're
going
to
learn
how
to
install
and
the
invoke
TMCC,
which
basically
is
the
runtime
for
Ethier
contract
and
the
will.
We
will
learn
how
to
interact
with
this
smart
contract.
We
just
deployed
in
yeah
yep
yep,
EVM
CC,
with
both
with
fabric
peer
command.
Typically,
the
one
you
use
normally
with
other
fabric
contract,
also
with
Feb
3,
which
is
a
proxy
we
developed
until
support.
Even
if
your
JSON
RPC
ap
is
so
exciting.
If
you're
most
likely,
you
will
have
the
smart
contract.
A
Deploy
in
the
network
also
will
be
interacting
with
that
contract
using
web
3,
which
is
a
lot
worried
about
by
theory
that
evokes
those
JSON
PC
will
go
into
some
details
later
and
then
we
probably
well
group
people
into
several
teams
and
basically
they're
well
reflect
several
different
organizations
in
fabric
network
and
people
will
be
deploying
their
own
and
at
the
end
of
workshop,
we
hopefully
can
have
a
several
games
running
in
this
network,
and
people
can
interact
with
each
other.
Of
course,
we'll
all
be
issuing
our
token.
A
I
just
want
to
have
a
quick
recap
of
how
fabric
transaction
works,
so
this
is
like
very
basic
or
transaction
workflow
in
fabric.
So
first
you
have
a
client
which
sends
the
transactions
to
fabric
endorsing
peers
where
they
collect
the
signatures
on
those
transaction
based
on
the
endorsement
policy,
and
you
will
collect
all
these
of
proposal
response
and
sent
them
to
the
ordering
service
to
have
this
transaction
being
totally
ordered,
and
then
the
ordering
service
will
distribute
these
transactions
in
blogs.
A
Back
to
the
committee
peers,
where
these
transaction
basically
signed
proposals
will
be
meditated
and
eventually
committed
to
the
ledger.
So
this
several
steps
will
be
expected,
reflect
the
up
the
transaction
workflow
in
fabric
and
some
characteristics
of
fabric
I
just
want
to
probably
read
emphasized
here.
So
we
have.
This
is
permission
system,
so
you
need
to
the
chain
called
runs.
The
transaction
and
output
will
be
a
refresh
set
yeah,
it's
a
base,
all
of
them
the
endorsement
policy.
A
Different
endorsing
Pierre
will
sign
the
transaction,
so
this
is
part
of
the
permission
mechanism
in
fabric
and
all
these
components
they
interact
with
each
other
using
certificate.
So
we
know
like
we
will
be
able
to
authenticate
the
counterparty
and
the
kernel
if
every
support
fix
a
stall
is
for
deaf
mold
and
apparently
every
supports
a
cough
cough
based
consensus
and
in
the
near
future,
we'll
be
having
graph
to
face
the
consensus
and
probably
a
PMT
over
there
and
the
fabric.
A
We
have
this
data
isolation
mechanism
called
channels
to
make
Floyd
the
channels
is
used
in
terms
of
to
group
organizations
into
a
its
own
short.
So
you
will
basically
join
organization,
YouTube
channels
and
they
will
be
interacting
with
each
other.
It
makes
the
most
see
the
same
data
within
that
channel.
So
organization
outside
of
the
channel
will
not
see
the
the
data
and
we
have
finality
for
transactions.
So
it's
not
like
I
think
if
you
tended
keynotes
on
stay
basically
for
a
lot
of
peel
peel
group,
a
school
of
consensus,
we
have
probabilistic
fanáticos
consensus.
A
So
basically
you
all
after,
like
certain
blogs
you
have
to
you,
don't
have
the
absolute
guarantee
that
your
chest
section
won't
be
reverted,
but
it's
highly
highly
likely
that
it
will
be
final
in
the
transaction,
but
in
fabric
we
have
finality.
So,
basically,
once
you
intersection
is
in,
it
will
be,
never
reverted
and
we
will
basically
run
this
workshop
in
several
steps.
First,
we
will
help
you
to
set
up
a
local
favorite
network
on
your
laptop,
so
we
kind
of
expect
people
have
their
own
laptop
working
and
you
stop.
C
A
Just
since
this
is
a
workshop,
we
kind
of
expected
you
to
ask
questions
whenever
you
meet
one
or
you
have
some
doubts
and
we
want
to
we'll
go
to
the
next
step
when
probably
all
of
the
group
or
60%
of
the
group
have
finished
the
cur.
Is
that,
and
hopefully
everybody
can
keep
up
with
us
and
we
kind
of
want
to
make
this
casual.
It's
not
really
a
lecture
or
presentation.
It's
kind
of
workshop
yeah.
B
C
A
B
A
little
bit
more,
so
you
guys
can
know
if
it's
ketchup,
but
for
those
of
you
who
already
have
go
installed
or
if
you
guys
are
new
to
go
I
just
want
to
make
sure
we're
all
kind
of
starting
off
on
the
same
page.
So
we
want
to
set
up
our
go
path
if
you're
familiar
with
go
projects,
you
probably
already
have
this
set
up,
but
just
make
sure
you
have
a
you
want
to
first
make
a
directory
for
all
of
our
hyper
ledger
kind
of
repos
that
we're
going
to
download.
B
C
B
B
So
the
next
thing
that
we
kind
of
need
to
do
is
there's
two
main
repos
we're
going
to
be
playing
with
the
first
one.
Is
the
fabric
chain
code,
EDM
code?
This
is
basically
the
repository
that
is
keeping
all
the
work
that
we
are
talking
about,
that
you
guys
are
going
to
play
with.
It
has
the
EBM
chain
code
and
the
factory,
so
that's
the
first
one.
You
have
to
make
sure
that
it
goes
into
your
go
path.
C
D
B
B
A
D
C
B
B
A
B
So
since
the
slides
are
up,
I'm,
gonna
kind
of
move
a
little
bit
so
that
way,
people
who
can
move
forward
and
we
can
kind
of
start
to
get
through
so
just
for
ease.
So
that
way,
when
we're
doing
things
in
the
terminal-
and
we
know
where
to
go-
export
these
to
VB
MCC
and
workshop-
it's
just
just
going
to
make
it
easier.
When
we
go
back
and
forth
between
the
two.
C
B
Just
so
kind
no,
so
this
is
another
step
that
we're
gonna
download
a
lot
of
stuff.
So
if
you
can
get
here
as
quickly
I
mean
you
can't
control
that
but
go
to
the
workshop
directory,
and
then
we
have
a
bootstrap
script,
which
is
basically
going
to
download
all
the
fabric,
images
that
you
need
to
run
a
local
fabric
network
for
the
first
part,
yeah,
basically,
and
then
the
next
two
steps
that
be
yfn.
So
we've
borrowed
these
fabric
samples.
B
A
So
EVM
basically
stands
for
rotation
and
it's
like
JDM
or
other
kind
of
VIPs
at
one
time
for
a
smart
contract
in
easier
and
it's
basically
as
that
turing-complete
stack
machine
and
until
all
your
cult
can
be
written
in
solidity
or
viper.
And
that
will
be
compiled
into
this
bytecode
and
loaded
into
EVM
and.
A
A
If
you
have
some
ether,
which
is
the
basically
that's,
how
can
be
easier
and
that
will
be
stored
under
your
account,
but
since
we
don't
have
such
a
cholera
epidemic,
so
so
we
don't
really
run
ether
in
fabric
I
just
want
to
say
say
that
corner
that
we
won't
be
able
to
run
this
Olivia
smart
contract.
For
example,
you
can,
we
will
be
presenting
some
like
voting
app
or
you
should
be
our
C
2010
within
the
contract,
but
we
don't
inherently
have
token
in
fabrics.
A
Therefore,
we
don't
really
need
to
say
cow
user
account
and
there's
another
type
of
account
in
theory,
which
is
the
contract
account
it's
basically
the
two
types
again
user
account
where,
as
an
individual
user
you'll
be
can't,
create
and
user
account
easier,
which
is
faithfully,
the
address
will
be
extracted
from
your
public
key
and
another
type
is
content
count,
which
is
the
account
to
store
the
smart
contract
and
every
time
you
want
to
invoke
a
contract.
They
are
basically
sending
a
transaction
from
a
user
account
to
that
contact
count.
A
A
Basically,
we
will
be
using
remix,
which
is
a
vApp
ID,
where
you
can
write
some
art
contract
and
will
compile
the
smart
contract
and
deploy
that's
more
contract
for
you
to
the
fabric
network.
Will
it
be
digging
into
data
and
when
you
call
a
contract
in
ethier,
you're,
basically
signing
transaction
which
contains
a
hash
of
that
function?
Name
and
the
values
encoded
as
the
function
argument
and
fix
that
you're,
sending
all
these
a
long
bite
to
the
content
account
and
to
complete
your
function,
unification
and
we
will
be
presenting
video.
B
A
B
Transactions
and
the
way
anything
runs
using
something
message
passing
so
basically,
the
format
is
this
from
input.
Sometimes
they
might
have
other
fields,
but
for
what
we
are
interested
in,
these
are
the
three
and
then
I'm,
just
gonna
gonna
go
through,
and
this
is
a
little
bit
going
over
in
theory.
Oh,
this
is
not
a
fabric
thing.
This
is
just
so
you
guys
kind
of
get
a
basic
understanding
about
so
pretty
regular
transaction.
How
it's
going
to
work
is
they're
gonna
have
a
contract
actors,
so
those
are
that's.
B
B
It's
basically
how
the
EVM
is
able
to
know
the
infant
figure
out
what
function
it
needs
to
call
from
a
specific
contract
and
then
there's
a
way
that
EVM
encodes
parameters-
I'm,
not
gonna,
go
too
deep
into
all
of
this
stuff,
but
this
is
kind
of
how
the
transaction
breaks
down
and
you're
gonna
kind
of
see
how
this
translates
into
the
fabric
world
in
a
little
bit.
So
there's
special
kind
of
a
transaction,
though
it's
called
a
contract,
create
creation.
B
This
is
how
you
create
a
contract
account
and
the
thing
that
you
do
is
you
have
to
send
the
transaction
to
the
zero
address,
because
there
is
no
account
there
and
the
EDM
when
it
sees
that
it's
going
to
take
the
contract
byte
code,
what
that's?
What
you're
gonna
put
in
as
your
input?
That's,
basically
the
compiled
solidity
or
VIPR
code,
whatever
you're
trying
to
deploy,
and
then
it
will
run
it
once,
which
will
generate
a
runtime
byte
code
and
then
it
stores
it
under
an
account
address
or
a
contract
account
address.
B
C
C
B
A
D
A
C
B
D
D
B
B
Okay,
so
as
people
are
doing
this
I'll
kind
of
continue
with
our
a
little
bit
of
the
learning
part
we've
briefly
kind
of
covered
this.
The
first
initial
set
of
slides
was
just
to
kind
of
give.
You
guys
an
overview
of
how
transactions
and
smart
contracts
work
in
theory
on
how
do
they
work
in
fabric
and
what
are
the
design
decisions
that
we've
kind
of
made?
If
you
guys
are
familiar
with
the
hyper
ledger,
burrow
project,
they
have
an
EDM
implementation.
B
B
The
way
we're
going
to
do
this
if
you're
familiar
with
the
fabric
chain
code
model
the
interface
that
you
have
to
do
in
it
and
invoke
everything
we're
going
to
do
we're
gonna
kind
of
consider
it
like
how
we
do
message
passing
those
are
going
to
be
passed
into
they
both
you're
always
going
to
call
in
both,
and
these
are
you're
going
to
follow
that
format
of
message.
Passing
a
couple
of
caveats
that
are
going
to
be
a
little
bit
different
from
you
know
how
contracts
work
in
aetherium
is
january
mentioned.
B
Doesn't
involve
a
contract
either
contract
creation
or
contract
location,
and
then
the
next
thing
is
contracts
must
be
deterministic.
So,
for
example,
you
can't
tap
something.
That's
like
has
an
element
of
randomness,
for
example,
because
of
the
way
the
endorsement
policy
in
the
consensus
is
reached
in
fabric.
So
that
is
difference.
If
you
have
solidity
contracts,
that
kind
of
have
like
a
random
number
generator,
it's
not
going
to
work
most
likely.
It's
not
going
to
work
if
it
works.
There's
something
wrong
with
your
random
number
generator.
C
B
D
D
B
So
there's
a
couple
of
things,
so
the
question
is:
if
your
guests
were
familiar
with,
the
theorem
was
when
we
say
no
tokens.
How
does
that
deal
with
gas
which,
if
you're
familiar
with
like
how
the
virtual
machine
VM
actually
works?
The
way
it
works
is
they
have
expect
when
you
submit
a
transaction
you've?
Also,
given
it
an
amount
of
gas,
this
is
kind
of
intermediary
asset,
token
thing
and
area.
B
Basically,
you
have
to
pee
or
code
that
runs
in
the
etherium
virtual
machine.
So
if
you
run
out
of
gas,
your
transaction
immediately
stops
and
you
won't
keep
running
off
codes.
So
gas
is
still
an
element.
The
EDM
is
just
that:
there's
no
longer
a
need
for
a
transaction
or
allocated
we're
hard
coding
it
to
a
very
high
limit,
so
you
should
be
able
to
successfully
complete
any
transaction
that
you
run
around.
A
C
B
The
question
you're
asking
is
kind
of
a
the
difference
between
Imperium
and
factory.
So
the
way
the
fabric
consensus
is
achieved,
you
have
to
get
endorsements.
You
have
to
get
other
peers
to
sign
your
transaction
before
it
gets
an
info
blog,
so
you
can
submit
a
transaction
and
if
it's
delicious,
the
other
peers
the
option
of
projecting
that
transaction.
So
the
the
kind
of
mechanisms
to
keep
malicious
actors
aways.
A
B
C
C
C
A
So
I
think
this
comes
to
the
question
like
why
and
from
there
everybody.
Why
do
we
do
this
from
you?
Basically
or
if
you
do
our
say,
a
huge
ecosystem
like
that
all
the
two
links
around
the
developer
tools
and
some
people
or
nozzoli
or
viper,
are
more
like
business
developer
friendly
so
because,
if
they
don't
read
one
program
ago
or
java,
but
they
think
slowly,
this
kind
of
object-oriented
beverages
are
more
natural
and
we
want
to
be
able
to
provide
this
developer
experience
to
these
group
of
people,
so
they
can
either.
A
You
already
have
a
vacation
on
the
easier
and
you
want
to
migrate
that
to
fabric
to
basically
adding
a
permission
layer
to
that
at
the
kitchen
or
you
are
just
more
familiar,
but
those
toolings
and
by
the
way,
the
remix.
I
personally
think
it's
pretty
good
IDE
and
they
are
more
many
more
like
mathematics
and
shuffle
all
these
frameworks
for
easier
so
basically
easily.
Once
we
support
this
smart,
contrary
theory,
we
can
gain
the
benefit
of
leveraging
those
tools,
the
best
of
pretty
basic
idea.
A
Why
we're
doing
this
project
surface,
though,
since
we're
adding
permission
to?
Basically,
we
evaporate
their
permission
and
then
a
Suzette,
we're
expect
user
to
be
authenticated
and
they
will
be
using
a
certificate
to
interact
with
the
network.
It's
not
like
either.
We
can't
just
any
arbitrary
circle
into
each
other.
We
can
just
send
transactions,
so
you
just
expect
people
to
be
no--but
belonging
to
a
student
organization.
B
B
B
C
C
A
The
first
part
of
the
workshop
you're
running
with
your
little
Network,
but
we
have
a
foster,
deploy
in
the
towel
and
for
you
fix
the
beforehand,
and
we
will
be
checking
each
other
using
that
network
and
you
can
definitely
just
join
or
local
here
to
best
network
this
step
of
possible.
This.
We
think
when
you
just
already
deploy
several
of
them
in
class.
So
it's
easier
for
people
to
interact
with.
D
A
Just
I
mean:
is
that
possible
to
like
everybody
will
run
another
peers
based
local
network
and
probably
have
a
said,
their
service
similar,
and
so
we
started
interacting
with
each
other.
I
just
I
doesn't
have
a
part
of
this
bookshop.
You
don't
be
part
of
the
another
workshop
next
to
door
where
the
purpose
is
to
eat.
C
B
So
these
slides
are
not
been
for
the
workshop,
their
slides
that
we
use
when
we
give
a
technical
version
of
this
I'm
going
to
some
of
it.
I've
we've
already
said
some
of
it
doesn't
quite
apply
and
I
might
skip
over,
but
we
can
kind
of
go
through,
so
we
already
did
the
overview
of
my
religion
fabric.
B
So,
basically
the
idea
is,
we
talked
a
little
bit
about
fabric.
We
can
talk
about
some
of
the
motivations
of.
Why
we're
doing
this
work
then
we'll
talk
about
divyam
concepts
and
the
natural
implementation
I'm
not
going
to
be
doing
a
demo.
You
guys
will
be
doing
the
demo
later
on
so
hopefully
it'll
all
make
sense,
as
you'll
start
noticing
that
these
slides
look
similar
to
what
we
already
have
in
the
workshop,
but
basically
permission
endorsement
policy
finality.
We
talked
about
that
I.
B
Take
that
diagram
that
is
in
there
and
it's.
This
is
kind
of
a
little
bit
more,
have
been
animated
to
explain,
and
this
might
help
some
of
the
confusion
about
the
etherium
to
fabric
transfer.
So
this
transaction
flow
is
not
changing.
The
way
it
works
is
we
are
gonna.
Have
a
user
client
right
to
invoke
or
have
any
kind
of
transaction?
We
already
have
chain
codes
installed
on
the
peers
and
we
have
an
ordering
service
there.
The
first
thing
the
client
has
to
do
with
them
to
go,
collect
the
endorsements
from
these
peers.
B
B
Service
is
going
to
create
a
block
with
that
transaction
in
it
actually
go
one
step
back
when
you
collect
the
endorsements.
What
you're
actually
getting
is
these
peers?
That's
the
execute
stage.
That's
when
the
actual
support
contract
is
being
run
in
fabric
and
what
it
generates
is
a
wreath
set
and
a
right
hook.
So
it
says
this
contract.
This
is
the
data
that
it
read,
and
this
is
the
data
that
it's
writing
to
and
it
collects
all
that
information
and
it
passes
it
back
to
the
client.
B
The
ordering
service
is
going
to
make
a
block,
and
then
it
years
now
that
appears
at
this
stage,
they're
not
going
to
run
the
transaction
again,
because
when
they
get
the
information
they're
going
to
have
a
read
set,
and
it
writes
it
with
the
information
and
all
they
do.
Is
they
verify
that
the
reads
that
hasn't
changed?
If
the
read
set
has
changed,
then
that
means
something
has
changed
since
the
transaction
was
initially
executed
and
it's
going
to,
it
will
always
put
the
transaction
at
the
block.
B
This
reads
that
right,
set
thing
is
the
reason
why
the
contracts
that
you
deploy
in
an
area
have
to
be
deterministic,
because
these
notes
are
running
them
simultaneously
by
themselves
and
if
there's
some
kind
of
chance
of
randomness
they're
not
going
to
be
able
to
come
up
to
the
same
answer
and
if
they're,
not
your
read,
sets
are
going
to
be
different.
Yes,.
D
B
D
A
D
B
B
There
is
a
way
to
do
if
you
want
to
have
any
deterministic
contract,
and
that
applies
to
everything-
that's
not
just
absolutely
I'm,
just
talking
about
the
chain
code
kind
of
a
thing,
so
we
kind
of
thought
this
is
our
transaction
flow
right
and
the
only
thing
we're
gonna
change
in
all
of
this
is
instead
of
having
chain
codes.
What?
B
If
we
can
use
some
of
it,
it
would
be
kind
of
nice
and
kind
of
bring
some
of
that
developer
experience
joy
into
fabric,
so
we
kind
of
already
went
through
some
of
these
motivations,
but
basically
is
to
enable
people
who
are
familiar
with
solidity
and
viper
be
able
to
write
contracts
on
chakra.
We
should
not
have
to
learn
or
know
the
also.
The
other
thing
is.
B
We
want
to
have
a
migration
path
for
those
who
you
know,
they've
already
developed,
invested
time
in
learning
and
creating
these
assets
on
material,
but
if
they
feel
like
they
want
to
go
to
a
permission
setting,
we
want
to
a
migration
path,
so
they
can
reuse
some
of
the
work
that
they've
already
done.
We
also
want
people
to
be
able
to
get
the
tooling.
B
So
all
these
tools
and
material
uses
they're,
based
on
the
expectation
that
these
clients,
people
with
the
theory,
are
the
clients,
expect
that
whatever
it's
talking
to
influence
the
interior
jason,
our
pc
api,
so
once
you
implement
those
and
the
more
and
more
instructions
that
you
get
and
kind
of
open
up
the
tools
that
you're
allowed
to
use-
and
then
the
last
thing
is
the
per
diem
is
Apache
2.0
license.
So
it
was
easy
for
us
to
pull
it
in
to
fabric
to
some
of
the
EDM
concepts.
We've
already
have
talked
about
these.
B
We
have
accounts
which
there's
external,
it's
they're
called
externally
own
accounts,
do
their
user
accounts
and
there's
contact
accounts.
Gasps
I
was
like
one
of
the
questions
you
still
have
gasps.
It's
just
that
it's
not
configurable.
We
give
you
a
hard
code
at
high
living,
so
any
transaction
you
want
to
run
should
run
successfully
to
completion.
We
talked
about
a
via.
A
B
Calls
basically
it's
a
to
from
implement
those
are
the
three
main
parts
of
the
message
that
you
have
to
pass
in
and
we're
still
kind
of
keep
that
this
read
current
transaction
rights,
and
this
is
a
little
more
of
a
technical
detail
in
fabric
right
now,
when
you
have
a
contract
and
you
read
a
value
and
you
write
a
value
and
then
you
read
out
the
same
value.
You
are
not
going
to
get
the
value
that
you
just
wrote.
B
C
B
Actually
altering
lender
State
at
that
moment
in
in
theory
on
that,
doesn't
work
so
well.
So
what
we
have
done
is
we've
implemented
a
little
cash
around
the
etherion.
So
that
way,
if
you
read
a
value
or
write
it,
we
kind
of
that
way.
When
you
write
something,
we
first
look
in
the
cash
you
put
value
back.
So
that
way
you
could
do
ten.
B
You
can
do
some
rewrites
and
kind
of
they
can
be
connected
to
each
other,
and
then
we
already
talked
about
the
Imperium
JSON
JSON,
RPC
API,
so
the
design
we
basically
have
two
pieces.
We
have
the
EVF
chain
code.
So
that's
the
actual
piece
that
we'll
be
running
on
with
your
nodes
and
that's
where
the
EVM
is
going
to
be,
and
that's
just
the
runtime
aspect
of
it.
That's
how
you
run
the
transactions.
All
of
that.
These
second
piece
is
fab.
Proxy
ensues
these
LEDs
have
been
created.
B
B
B
Basically,
they
could
we
go
through
how
a
transaction
would
come.
We
expect
that
you'll
hit
the
API
we're
using
the
go
s2k
to
be
able
to
actually
communicate
with
fabric.
It's
going
to
invoke
the
EBI
of
CC.
Once
it
involves
see,
we
have
implemented
something
called
the
state
writer.
Basically,
it's
a
layer.
So
that
way,
the
borough
code
can
talk
or
interact
with
the
fabric
ledger
it's
just
like
an
intermediary
state
and
then
state
writer
will
usually
get
the
contract
code
so
that
this
is
different
from
how
fabric
does
things
fabric
you
have
to
man?
B
You
are
off
chain,
you
have
to
all
install
the
chain
code
on
all
the
nodes
that
we
have
many
different
organizations
and
stuff
l-look.
All
the
admins
have
to
kind
of
do
it
simultaneously
and
then
you
do
an
instantiation,
that's
a
transaction
and
the
contract
code.
When
you
do
it
in
fabric,
is
actually
staying
in
the
purified
system
for
the
EVMs
contracts.
The
contract
code
is
going
to
be
on
the
ledger:
we're
actually
committing
it
into
the
ledger
and
you're
not
going
to
go
there.
B
They
install
instantiate
process
as
you
do
in
fabric,
and
that's
mostly
because
the
install
instantiate
applies
to
the
EDM
CC,
not
the
smart
contracts
that
we
deployed
the
writer
and
then
the
rest
of
it
is
just
generating
reads
and
writes.
This
is
usually
where
I
do
it
down.
But
let's
see,
where
are
your
local
networks?
I.
D
D
B
That's
not
it
so,
even
in
solidity,
it's
considered
one
transaction
right,
it's
one
transaction
in
the
walk,
and
it's
going
to
say
this
value
changed
from
here
to
this
and
that's
the
same
thing
that's
going
to
happen
here,
we're
talking
about
what
did
that
transaction
execution
if
you're
doing
this
rate,
so
even
insolently,
if
you
do
the
read
a
write,
a
it's
all
in
the
end,
it's
going
to
be,
you
wrote
a
to
this
value.
That's
all
that's
going
to
be
recorded,
I
believe.
B
A
A
B
B
So
what
we
first
thing
we're
gonna
do
is
we're
going
to
exempt
into
the
CLI
container
that
you've
created
through
the
network.
One
thing
that
we've
already
done.
So
if
you
compare
this
to
the
first
Network
fabric,
samples
example-
and
you
look
at
what
the
differences
are,
the
thing
is
we
just
mounted
the
bridge
pincode
EBM
repo
into
those
containers,
and
only
reason
we
can
do.
It
is
because
we
set
up
a
notepad,
so
that
kind
of
explains
why
we're
making
you
do
these
steps.
B
Gonna
actually
install
elenimia
so
though,
as
I
was
mentioning
before
this
is
this
thing
where
each
gear
has
to
get
the
installation
by
itself
it's
not
unlike
a
transaction
you
can
submit.
So
what
I
have
provided
is
a
script
in
the
scripts
term.
So
when
you
in
your
CLI,
when
you
get
to
that
terminal,
you
should
see
a
script
stir
and
in
there
there
to
be
a
target
peer.
The
first
argument
that
you
put
in
is
the
order
you
want
to
target,
and
the
second
argument
is
the
bigger
you
want
to
target.
B
The
first
thing
you
want
to
do
is
scripts
target
here:
SH
1
0.
So
that
way
it
sets
up
the
environment
variables.
So
the
CLI
tools
know
the
CLI
knows
what
we're
here
to
talk
to
you
basically
and
then
the
next
step
is
to
peer
chain
coding,
install
it
we're
going
to
just
call
it
version.
1.0
really
doesn't
matter.
If
you
want
to
change
that.
Just
remember
what
you
put
it's
a
go
leg
chain
code.
You
want
to
name
it
the
EB
MCC.
B
C
D
D
D
B
B
Okay,
I
can
always
go
back
so
now.
The
next
thing
is
we
need
to
instantiate
at
this
point.
Whatever
they're
targeted
should
be
fine
and
you
I
have
given
a
script
to
export
the
orders
da.
So
that
way
you
don't
have
to
type
that
file
path
out.
Every
time
you
do
a
transaction
and
basically
it's
going
and
you
have
to
source
it,
don't
run
it
source
it.
B
It's
just
doing
an
export
command
and
it's
sending
the
order,
underscore
CA
environment
variable
and
then
you're
gonna
run
the
peer
chain
code,
instantiate
and
the
channel
that
should
have
been
created.
When
you
created
the
network
is
my
channel,
you
choose,
we
done,
we
installed
it
as
version
1.0,
so
make
sure
you
do
v
1.0
and
then
the
constructor
arts.
B
These
are
the
argue
arguments
for
the
init
command
of
the
EVM,
the
EVM,
and
it
doesn't
really
do
anything-
doesn't
need
to
so
we're
gonna
pass
in
no
arts,
but
this
is
one
where,
if
you're
copying
pasting,
you
might
have
to
rewrite
the
quotes,
the
single
and
the
double
because
they're
slanted,
then
you
want
to
say
DBM
CC,
passing
the
CA
file,
TLS
true
and
then
target
the
order,
which
should
be
an
ordered.
On
example,
comm
point:
seven:
zero,
five,
zero.
B
B
C
D
C
C
D
C
C
C
B
Okay,
so
we're
gonna
try
to
make
this
the
goal
if
you've
already
gotten
to
the
instantiation
I
mean
we're
gonna,
we're
gonna
try
to
come,
get
this
done
before
the
break.
So
if
you're
already,
there
I
just
feel
free
to
go
to
the
break
early
like,
but
how
many
people
are
the
still
at
the
network
layer
getting
the
network
up
just
one
two:
okay,
not
bad.
We
can
also
help.
B
The
cook
dojin
is
it
that
he
can't
find
the
tool.
So
when
you
do
the
bootstrap,
we
missed
the
step
in
the
slides.
But
when
you
do
that,
you
should
see
in
the
evm
workshop
repo.
There
should
be
a
new
director
that
gets
created
called
bin
in
that
bin.
You
have
to
export
that
or
add
that
to
your
path,
and
then
this
the
rest
of
the
generation
should
work
for.
C
C
C
C
B
A
D
C
D
C
D
C
C
C
B
B
B
B
Is
only
for
people
who
are
using
a
darker
version,
that's
in
the
old
schema
110:1,
something
like
that.
If
you're
in
docker
version
18
point
something
you
should
don't
have
to
do
any
of
this
and
then
once
you've
done
that
break
your
network
back
up,
you
might
have
to
run
the
generate
again
and
then
we'll
see.