►
Description
Bring your laptop to this hands-on workshop to build your first Smart Legal Contract based on open-source tools from the Accord Project.
The Accord Project defines the technical and legal standards for legally enforceable smart contracts and integrates with Hyperledger Composer and Hyperledger Fabric.
Attendees will learn how to deploy a legal agreement to a Hyperledger Fabric network using open source tools from the Accord Project.
----
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 #Blockchain
A
So
I'm
sure
you
all
heard
the
expression
that
smart
contracts
are
neither
smart
nor
contracts.
So
what
we
do
it
caused
them
within
the
Accord
project
is
to
try
to
address
that
clause
is
a
legal
technology
startup
we
exist
to
help
or
help
law
firms
and
companies
using
contracts
to
automate
legal
agreements.
A
So,
first
of
all,
I'll
spend
a
little
time
introducing
the
import
project
so
I
set
that
down
and
only
work
for
Klaus.
That
is
a
commercial
entity,
but
Klaus
is
the
founding
member
of
an
organization
called
the
Accord
project
and
that
exists
to
de
set
and
define
the
specification
and
standards
for
smart
legal
agreements.
A
A
Association
in
the
middle
as
well,
so
that
is
an
awful
profit
organization.
That
organization
defines
specification
in
the
open.
It
defines
open
source
code
and
its
tools
from
the
Accord
project
that
we'll
be
using
in
the
lab
today
to
build
smart
legal
agreements,
the
those
tools
that
have
been
built
by
the
Accord
project
platform
neutral.
We
we
support
a
number
of
different
platforms,
both
the
ledger
and
on
that
ledger
base.
So
we
believe
that
the
platform
will
be
decided
by
the
use
case.
A
Some
will
be
best
fitted
to
suited
to
fabrics
and
will
be
best
suited
to
Corder.
Some
won't
need
a
DLT
at
all,
and
you
know
may
get
shot
for
saying
that
here,
but
we
believe
in
some
cases
the
relationships
between
the
parties
and
agreement
mean
that
it's
quite
appropriate
for
a
single
organization
to
run
that
that
contract,
that
legal
agreement
in
their
own
datacenter
or
in
the
cloud
for
example,
so
you'll
see
us
taking
advantage
of
some
of
that
behavior
in
the
tools
that
we're
using.
A
There
are
a
number
of
components
to
those
tools
and
we'll
be
using
some
of
these
today,
you'll
see
Cicero,
which
is
the
templating
system.
This
is
really
the
magic
that
joins
together
legal
text
with
logic,
so
we
don't
believe,
certainly
in
the
short
and
medium
term
that
there's
a
reliable
and
an
ambiguous
way
of
generating
computable
codes
from
unstructured
natural
language.
So
we
deliberately
make
a
distinction
between
the
two,
but
we
bind
them
together
in
a
very
tight
way
through
and
through
a
data
model
that
we'll
talk
about.
A
So
a
Cicero
is
the
templating
system
that
lets
us
do
that
text
with
parameters
and
placeholders,
so
you
can
have
reusable
clauses,
reusable
documents,
but
also
logic
that
correspond
the
text
in
those
contracts.
We
also
have
defined
again
in
the
open,
a
domain-specific
language
called
ergo.
So
if
ago
is
a
language
that
understands
as
primitives
the
concepts
of
a
contract
and
clauses,
it
understands
the
state
of
a
contract,
it
understands
that
data
can
be
sent
to
it
and
we
believe
that
it's
accessible
to
less
technical
people.
A
There
are
some
more
technical
properties
that
we
had
that
it
has
that
we
think
also
make
it
suitable
for
running
on
a
distributed
ledger
platform.
So
for
those
of
you
that
are
interested
ago,
is
non
cheering
complete
deliberately,
so
it's
built
in
a
way.
That
means
that
we
can
formally
verify
right
using.
You
know
proper
academic,
formal
verification
tools,
it's
type
safe,
but
it
also
because
it's
like
a
platform
independent.
We
can
compile
it
and
produce
code
that
will
grow
on
whatever
platform
we
want.
A
A
lot
of
these
things
are
reusable
and
valuable
to
to
others,
so
we'll
be
using
some
resources,
template
libraries
and
the
model
repository
to
help
accelerate
some
of
the
work
that
you'll
be
doing
today
and
finally,
we
provide
so
many
user
tooling
for
developers
of
these
templates,
particularly
something
called
template
studio,
which
is
an
in-browser
editor
for
modeling,
the
natural
language
and
the
grammar
of
these
templates,
the
logic
and
the
data
model.
Okay,
all
still
with
me,
make
sense
so
far
good.
A
So
this
is
what
we
mean
when
we
say
a
template.
What
is
a
smart
legal
contract
template
the
way
that
we
binds
logic
on
the
left-hand
side
and
natural
language
on
the
bottom?
Right-Hand
side
is
through
a
data
model.
We
define
that
a
person
has
specific
attributes
and
when
you
refer
to
that
person
in
text,
we
we
can
parse
that
text
automatically
and
extract
the
data.
So
there's
the
clever
bit
there,
the
logic
that
performs
calculation
on
all
those
attributes
uses
the
same
model.
A
So
we
have
that
binding
between
the
text
and
the
natural
language
through
the
data
model.
For
those
of
you
that
are
interested,
the
modeling
language
that
we
use
is
called
concerto,
which
has
recently
come
from
the
high-polish
a
composer
project.
So
we
had
a
session
yesterday
where
we
talked
about
the
work
that
we've
done
to
extract
that
components,
make
it
an
independent
module
that
can
be
used
on
a
number
of
different
platforms,
and
that
now
has
the
name
concerto.
A
A
So
let's
have
a
look
at
some
examples
of
each
of
these.
This
is
a
really
simple
example,
we'll
be
doing
something
a
little
bit
more
complex
in
the
lab
of
contract
text.
So
what
we?
What
we
do
is
we
take
the
clause
from
the
lawyer
and
we
identify
the
variable
components
of
that.
What
are
the
parameters
to
that
contract?
So
we
can
see,
we've
got
some
parties,
Betty,
buyer
and
Steve
seller.
A
We
have
some
values,
ten
point,
five,
two
days,
fifty
five
percent
and
so
on
and
ultimately,
when
I
write,
a
contract,
I
should
be
able
to
change
the
parties
change
the
values.
The
lawyers
should
be
able
to
do
that,
but
we
can
still
pass
that
text
and
extract
those
attributes
that
we
can
use
them
in
our
logic
and
and
or
do
other
things
with
them.
Yes,.
B
A
We
can
generate
a
parser
automatically
from
the
template
to
do
that.
So
this
it's
a
smart
parser,
so
it
will
recognize
strings
and
recognize
numbers,
for
example,
in
the
structure
of
complex
types.
So,
if
you
see
two
days
is
a
complex
type
for
a
duration
that
could
say
one
month,
no
twelve
years,
for
example,
and
the
possible
will
be
able
to
handle
that.
But
it's
not
an
AI
system.
That's
don't
how
to.
A
So
we've
identified
those
parameters.
The
next
thing
that
we
do
with
this,
this
notation
is,
is
build
what
we
call
a
grammar,
so
we
punch
holes.
We
take
all
of
those
variable
elements
out
and
we
make
this
reusable,
and
it's
from
this
that
we
generates
that
that
parser
that
I
mentioned
again.
You
don't
need
to
worry
about
how
we
do
that,
but
you'll
be
creating
and
modifying
one
of
these
in
in
the
lab,
so
that
you
can
make
your
your
legal
documents
reusable.
A
So
for
each
of
those
parameters
we
produce
a
data
model,
here's
a
class
diagram
for
the
data
model
that
corresponds
to
those
parameters.
We
have
some
parties
for
the
contract.
We
have
the
duration,
some
percentages
for
the
values,
so
duration
is
15
days
like
we
said,
and
there
can
be
some
fairly
complex
relationships
between
these
models.
So
duration
is
defined
elsewhere,
that's
a
built
in
type
if
you
like,
and
we
know
that
iterations
are
a
mate
and
under
unit.
So
is
it
seconds
minutes
hours
or
so
on,
and
one
of
those
libraries
are
referred
to.
A
The
model
library
provides
a
whole
suite
of
reusable
libraries
that
you
can
and
you
can
use
in
your
contracts.
So
we
have
the
text.
We
have
the
data
model.
We
then
need
to
start
thinking
about
about
the
logic
and
how
we
integrate
logic
with
that.
So
we've
done
these
things.
We've
started
on
the
top
right
with
contract
text,
we've
converted
that
to
a
contract
template
because
of
that
model
we
can
generate
an
instance
of
the
contract.
We
can
pull
out
the
data
and
we
serialize
that
into
Jason.
A
So
that's
one
option
for
that's
the
serialization
format
that
we've
we've
chosen.
So
that's
what
that
looks
like
a
complex
type
is
a
nested
object
here.
So
that's
sometimes
referred
to
as
the
deal
data,
so
the
lawyers
amongst
you
that
that
tends
to
be
the
terminology.
That's
used
the
contract
because
it's
no
longer
just
a
PDF
or
a
word
document.
It's
now
a
living
thing,
so
we
need
to
think
about
the
lifecycle
of
that
contract.
How
does
it
respond
to
data
from
the
outside
world?
A
A
We
have
a
contract
instance
and
we
can
send
data
to
it.
We
call
those
requests
and
we
get
responses
back
in
based
on
our
request.
Those
requests
could
cause
a
change
in
the
state,
so
in
this
example,
late
delivery
and
penalty.
Maybe
there
are
multiple
packages
or
we
remember
whether
the
package
has
already
been
delivered,
for
example,
and
if
we
receive
a
quick
request
once
the
package
has
already
been
delivered,
we
record
that
in
the
state
so
that
we
know
not
to
do
something
again.
A
The
next
time
and
the
things
that
we
might
do
are
to
emit
an
obligation,
for
example,
so
in
many
clauses
there'll
be
an
obligation
for
a
party
to
do
something,
maybe
in
certain
circumstances
somebody
needs
to
make
a
payment,
so
the
contract
can
emit
an
obligation.
You
can
think
about
that
as
an
event
in
fabric
terms,
if
you
like,
and
then
we
can
surround
this
contract
with
a
system
which
can
automate
that
obligation,
we
can
perform
a
payment
automatically.
A
Currency
scenario,
it
could
be
that
actually
for
some
people,
automating
payments
is
a
bit
too
risky
that
they
on
some
level
of
sense
checking.
So
we
just
give
some
in
alerts
and
then
an
email
or
we
want
to
add
a
line
item
to
an
invoice
which
goes
through
a
normal
counting
cycle
so
again
as
those
design
decisions
to
be
made
outside
the
system
as
to
how
we
responded
to
the
the
output,
the
events
and
obligations
limited
by
the
contract.
So
you'll
see
these
these
concepts
as
we
go
to
the
lab.
Yes,.
C
A
A
Okay,
the
final
parts
that
I
said
I
would
introduce
you
to
is
the
the
execution
logic,
and
here
is
a
simple
example
of
some
of
that
Bill
go
code,
the
domain-specific
language,
so
you
can
see
here
that
we're
settings
doing
some
variable
assignments,
so
request
is
the
input
data
that
we
is
coming
in
that
I
referred
to.
So
the
request
tells
me,
when
the
not
sure
Hamner
tells
me
when
the
package
was
delivered
in
this
case
in
the
leg.
A
B
A
A
A
So
in
most
of
the
lab
today,
you
won't
be
expected
to
write
any
new
logo
in
the
basic
set
of
instructions,
but
then
there
are
some
advanced
of
instructions
so
for
some
of
you
that
may
rattle
through
the
first
set
of
instructions
very
quickly,
there
are
some
extension
exercises
where
we
encourage
you
to
add
additional
use
cases
to
the
template
that
you
start
from,
so
where
it
help
and
guide
you
through.
That
have
questions
on
that
on
the
language
before
I
give
you
the
instructions
to
start.
The
lab
here
are
a
few
resources.
A
I'll
put
these
back
up
again
afterwards,
they
will
be
helpful
as
we
go
through
the
left
hand.
Side
is
the
Accord
project
documentation
website,
so
that
inch
gives
you
detailed
documentation
on
Cicero
logo
and
those
resources
for
templates
and
models
that
I
mentioned
and,
on
the
right
hand,
side.
If
you
go
to
a
core
project
order
and
click
join
the
AP
slack,
we
have
a
slack
channel
called
tech,
hyper
ledger,
which
we
use
for
general
hyper
ledger
discussion
in
the
Accord
project,
so
we
thought
it
would
be
great.
A
B
B
A
So
currently
we
have
support
for
fabric,
that's
the
the
one
we'll
be
using
in
the
lab.
Today
we
have
experimental
support
for
quarter
and
we
have
the
team
working
on
on
others
too.
So
we're
interested
in
in
tezo's
and
running
on
the
EBM
in
particular,
and
of
course
we
can
run
off
chain
two,
so
we're
we
can
run
in
a
node.js
runtime
or
in
the
browser,
so
you'll
be
doing
some
testing
in
the
browser
transparent
to
whichever
platform
you
want
to
do
to
begin
with
today,.
A
Okay,
so
the
lab
exercise,
the
lab,
is
set
up
to
try
and
accommodate
different
levels
of
technical
ability.
So
there
are
three
different
options
for
you.
We
have
some
pre-built
images
in
the
class,
so
we
thought
that
asking
30
or
40
feet
or
download
with
six
or
ten
gig
image
before
you
begin
was
probably
not
a
great
idea.
So
we
have
some
images
that
you
can
log
into
via
remote
desktop
connection.
A
So
that's
the
most
straightforward
way
to
get
started
and
if
you
think
that's
the
best
option
for
you
come
and
see
us
and
we'll
give
you
a
post-it
note
with
an
IP
address
and
some
credentials,
so
you
can
just
log
in
you
should
be
able
to
log
in
from
any
remote
desktop
client
on
your
machine
option.
Number
two:
is
we
the
image
that
we
use
behind
the
remote
desktop
limit
machines
is
available
in
the
Frankfurt's
AWS
data
center?
A
So
if
you
have
an
AWS
account,
can
provision
your
own
image
and
you
can
keep
it
after
the
end
of
the
lab,
so
there's
instructions
in
the
lab
on
how
to
find
that
image
in
in
the
ec2
community
marketplace
or
find
me
if
you're
feeling
really
adventurous.
We've
listed
all
of
the
prerequisites
and
requirements
that
you
need
to
install.
Basically,
you
need
nodes,
get
docker
and
docker
compose
installed
on
your
machine
with
appropriate
versions.
You
can
have
a
go
doing
that
yourself.
It's
two
subjects,
so
the
wife
fight
over.
A
Avocados
sugar
are
the
two
things
that
we've
you
know
the
organism
without
organizations
that
work
with
us
shipping,
those
kinds
of
produce,
there's
a
contract
that
says
that
if
the
datalogger
in
the
container
shows
that
the
reading
goes
outside
of
the
range,
the
shipper
has
to
pay
a
penalty,
so
the
total
main
payable
is
not
determined
until
the
shipment
is
received.
Now,
if
we
automate
that
process,
we
can
listen
to
events
from
that
container.
In
real
time,
we
can
send
up
notifications
go
along
and
we
can
determine
the
actual
obligation
on
receipt
of
delivery.
A
So
we
have
natural
language
contract.
We
have
logic
which
processes
those
IOT
sensory
events,
and
we
can
store
those
events
on
chain.
We
can
run
the
logic
on
fabrics.
What
we're
going
to
do
today
and
perform
that
obligation
calculation
automatically
in
the
lab
we'll
go
through
building
the
templates,
using
the
templates
to
do
and
then
deployments
to
your
own
local
fabric
instance.
That's
sort
of
the
first
easy
step
is
a
couple
of
steps
and
then
some
extensions
to
the
to
the
activity,
for
example,
to
make
the
contract
more
stateful.
A
How
do
we
record
what
data
we've
had
before,
rather
than
sending
it
all
in
in
one
go?
How
do
we
deploy
this
and
how
does
it
work
across
a
network
rather
than
in
in
a
single
node,
for
example?
So
there's
about
five
or
six
extension
exercises
that
you
can
choose
as
you
as
your
as
you
wish
to
look
in
this
is
the
final
slice
lab
instructions.
A
Are
that
URL
at
the
top,
so
lab
instructions
for
all
three
of
those
variants,
whether
you
use
the
remote
desktop
image
provision
your
own
or
deploy
to
your
own
machine
to
save
the
Wi-Fi.
We
recommend
not
downloading
a
bun
too,
and
everything
locally.
We
might
do
a
unintentional
denial
of
service
on
all
the
other
labs
going
on
at
the
same
time,
and
we
have
about
20
or
so
pre-built
images
that
that
Dan's
got
here
that
we
can.
We
can
give
out
to
you.
A
So
that's
why
we
connect
to
remote
addresses
the
images
are
only
going
to
be
available
for
the
lab
and
shortly
afterwards,
so
we'll
deep
revision
them.
So
it's
just
that
we
know
who
is
using
those
images.
So
we
can,
we
can
bring
them
down
right,
I!
Think
that's
all
I've
got
to
say
so.
Are
there
any
any
questions
before
I
I
said
you're
going?
A
B
A
Clauses
in
public
pizza
yeah,
so
you
can
go
to
close
to
IO
and
sign
up
for
applause
today.
It's
it's
open
for
anybody
to
sign
up,
yeah
I'll
be
completely
open.
We
are
not
using
any
clause.
Proprietary
technology.
Everything
here
is
open-source
actually
licensed.
You
know,
of
course,
we'd
love
you
to
go
and
also
have
a
look
at
laws
and
talk
to
us
about
that
as
well,
but
there's
no
mandate
for
you
to
use
clause
technology
in
the
lab.
Yes,.
A
C
A
C
A
Other
thing
that
I'll
say-
and
you
know,
you're
free
to
do
this
evaluation
I
often
find
with
these
kind
of
labs.
It's
really
helpful
to
do
them
with
somebody,
because
you
follow
the
instructions
and
you
get
to
the
end,
and
often
you
don't
fully
appreciate
what
it
is
that
you've
done
if
you're
working
in
pairs,
it's
a
natural
tendency
to
question
and
trying
to
figure
out.
Why
doing
this
way?
What's
the
benefit
of
doing
it?