►
From YouTube: Smart AND LEGAL Contracts - Dan Selman, Clause
Description
Smart AND LEGAL Contracts - Dan Selman, Clause
Dan Selman shows how you can move from chaincode to real Smart Legal Contracts, where code and legal text is linked via the powerful Open Source Accord Project stack from the Linux Foundation.
Dan will demo creating a new clause template and execute it on Hyperledger Fabric, as well as discussing commercial projects and opportunities.
Dan will summarise with thoughts on the future, including synergies with smart contract work going on within Hyperledger, and elsewhere.
----
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 #HyperledgerGlobalForum2020 #Blockchain
A
All
right,
it's
11:50,
let's
get
started,
I've
got
lots
of
content
for
you.
My
name
is
Dan
Solomon
I'm,
a
maintainer
at
the
Accord
project
contributor
at
hyper
ledger
and
today
I'm
going
to
talk
about
smart
and
legal
contracts.
So
what
do
we
need
to
do
to
make
the
chain
code?
The
smart
contract
code
that
we
write
legally
enforceable?
And
that's
the
that's
the
problem
that
the
Accord
project
has
been
working
on
for
about
the
last
three
years
or
so
so?
A
I'll
just
start
with
a
few
few
slides
to
introduce
the
Accord
project
and
then
quite
quickly.
Hopefully,
I'll
show
you
a
demo
of
some
code
running
on
fabric,
so
the
Accord
projects
is
a
fellow
Linux
Foundation
open
source
project
where
a
top-level
project
and
our
mission
is
to
provide
a
non-profit,
open
source
technical
foundation,
a
set
of
libraries
that
help
people
work
on
these
problems
that
are
all
to
do
with
the
intersection
between
the
law
and
technology.
A
So,
in
a
nutshell,
essentially
what
we
help
people
do
is
to
take
legal
contracts
and
to
digitize
them
in
some
way,
shape
or
form
and
I'll.
Show
you
what
that
means.
In
a
moment
and
we're
very
technology
agnostic,
we
talk
to
obviously
all
the
projects
within
hyper
ledger,
but
we
also
engaged
with
our
three
the
enterprise
of
theorem
Alliance,
you
name
it.
The
reality
is
that
contracts
are
getting
digitized
and
they
will
need
to
execute
on
a
variety
of
platforms,
both
blockchain
and
non
blockchain.
A
So,
as
I
said,
we've
been
going
for
for
over
two
years
now,
we've
built
a
lot
of
technology.
Some
of
it
is
about
run
time.
You
know
how
do
we
execute
the
logic
of
a
contract,
but
a
lot
of
it
is
actually
around
the
user
experience
so
providing
a
set
of
web
components
to
edits
a
digitized
contract
and
we've
also
done
a
lot
of
work
on
markup.
A
So
recently
we
build
a
whole
markdown
based
stack
for
representing
the
text
of
a
contract
and
introducing
formatting
and
variables,
and
and
that
kind
of
thing,
but
some
of
the
some
of
the
code
names
that
I'll,
probably
inadvertently
start
using
are
things
like
Cicero
and
so
Cicero
is
our
project
for
defining
a
template
and
I'll
go
into
more
details
on
that?
What
is
a
component
of
a
smart
legal
contract
if
you
like,
and
then
ergo,
which
is
the
programming
language,
the
domain-specific
language,
that
we've
developed
to
capture
the
logic
of
a
contract?
A
A
So
it's
a
very
big
project
with
kind
of
a
broad
range
of
stakeholders
from
legal
on
one
extreme
to
developers
and
everything
in
between
and
it's
a
very
vibrant
community
that
we're
very
proud
of
I
ran
the
stats
this
morning,
186
contributors
on
github
and
over
9,000
users
on
the
Accord
project,
slack.
So
a
lot
of
engagement,
a
lot
of
people
are
starting
to
wrestle
with
this
issue.
A
Contract
Digitas
digitization
is,
if
you
like
kind
of
the
last
mile
we've
done
over
the
last
30
years
or
so
a
lot
of
work
on
digitizing
business
process,
business
rules,
but
comparatively
little
work
has
gone
on
in
the
last
mile,
which
is
actually
the
text
on
the
page.
And
what
does
the
text
on
the
page
mean?
And
that's
you
know
that's
a
pretty
big
challenge
that
that
we've
bitten
off
with
in
the
old
core
project
and
we're
really
grateful
for
you
know
all
the
people
that
are
helping
us
in
this
in
this
mission.
A
So,
first
of
all,
what,
from
our
point
of
view
is
a
smart
legal
contract,
so
a
smart
legal
contract
involves
sort
of
two
sides
to
a
coin:
there's
the
humans
side
and
the
legal
side,
which
is
about
text.
So
you
know
if
you
have
a
dispute
and
you
have
to
go
to
court
they're
going
to
want
to
see
the
text
of
your
contract.
That's
really
all
the
existing
legal
system
is
capable
of
dealing
with.
So
there
has
to
be
a
textural
component
through
a
smart
legal
contract.
A
Aspect
of
this
and
the
the
apex
of
the
triangle
is
really
to
relate
these
two
things.
You
have
to
have
the
notion
of
a
data
model,
because
the
the
legal
text
is
going
to
be
talking
about
concepts,
so
it
could
be
talking
about
a
late
delivery,
for
example,
and
a
penalty
that
needs
to
be
paid
if
the
delivery
is
late.
A
So
those
concepts
that
appear
in
the
legal
text
are
essentially
in
instantiation
of
a
data
model
and
on
the
computational
side,
the
code
that
you
write
will
be
strongly
typed
and
will
be
referencing
elements
of
a
data
model
so
that
data
model
at
the
apex
is
the
key
to
integrating
these
two
different
worlds.
Without
a
shared
data
model,
you
can't
really
relate
the
legal
text
and
the
computational
code,
because
the
data
model
really
gives
you
the
semantics
of
both
sides
of
the
house
right.
A
We
need
to
have
a
shared
understanding
between
technology
and
legal
of
the
concepts
about
which
we're
we're
entering
into
a
contract.
Does
that
make
sense
any
questions
before
I
move
on
great,
so
we
love
triangles
and
we
use
this
triangle
a
lot
and
essentially,
if
you
draw
a
circle
around
this
triangle,
that's
what
we
call
a
template.
A
A
But
you
know
rome
wasn't
built
in
a
day
and
the
reality
is
of
you
know
most
procurement
departments
or
legal
departments.
Is
it's
completely
dominated
by
Microsoft
Word,
but
all
of
all
of
the
legal
contracts
are
just
Microsoft
Word
documents.
So
how
do
we
move
them
from
that
to
fully
executing
autonomous
smart
contracts
on
a
blockchain?
A
You
go
online,
you
pay
200
bucks
and
you
can
get
a
a
pro
forma
contract
to
sell
a
vehicle
or
something,
and
it
will
have
those
kinds
of
placeholders
enter
the
name
of
your
vehicle,
the
mileage,
you
know
the
color
etc.
So
that's
kind
of
the
first
step.
The
second
step
is
computers
need
types
so
in
a
traditional
pro
forma
contract,
all
those
variables
are
just
in
a
word
document
in
angle,
brackets,
they're
all
strings.
So
now
we
have
to
kind
of
convince
you
that
the
second
step
is
not
everything.
A
It
can
be
a
string
if
everything
is
a
string,
we're
pretty
limited
in
the
types
of
computation
that
can
do
so.
You
need
to
tell
us
well
the
model
year,
for
example,
is
a
number,
whereas
the
the
manufacturer
name
is
in
enumeration
and
there's
a
list
of
manufacturers
so
essentially
you're
providing
a
data
model
for
for
those
variables.
A
The
third
step
is
well
now
we
have
a
data
model.
We
can
actually
write
some
code,
so
we
can
put
some
logic
behind
that
legal
clause
to
perform
some
actions.
Automated
actions
on
your
behalf
and
that's
where
our
NGO
comes
in
and
then
the
fourth
step
is
you
decide
well,
where
do
I
want
this
logic
to
execute?
A
If
it's
a
much
more
equal
relationship
like
perhaps
we
might
see
in
banking,
then
maybe
we
do
want
distributed
trust
and
I'm
going
to
execute
my
copy
of
the
contract
logic
and
you're,
going
to
execute
your
copy
of
the
contract
logic
and
we're
gonna
use
consensus
to
make
sure
that
we're
you
know
we're
in
agreement
as
to
the
state
of
the
contract,
and
then
we
start
to
bring
in
blockchain
into
the
discussion.
But
our
experience
has
been.
You
can't
jump
from
step
one
to
step
four
very
effectively.
A
You
need
to
walk
people
through
these
intermediate
steps
of
actually
digitizing
the
contract
and
then
having
the
discussion
about
well.
Where
do
you
want
the
contract
logic
to
run
but
I'm
going
to
violate
that
and
I'm
in
a
blockchain
conference
I'm
going
to
show
you
step
four?
Essentially,
how
do
we
take
in
a
court
project
template
and
run
it
on
a
distributed
ledger
with
all
the
logic
running
on
chain
using
fabric?
A
A
Let's
just
walk
that
walk
through
that
with
a
very
simple
clause
that
you
might
find
in
a
lot
of
supply
agreements,
so
late
delivery
and
penalty.
It
basically
says
you
need
to
deliver
me
some
goods
by
a
certain
date.
If
you
don't,
you
need
to
pay
me
some
penalties,
it's
a
very,
very
common
clause,
so
in
this
case
I've
highlighted
what
I
believe
the
variables
to
be
in
red.
So
we've
got
the
names
of
the
parties
we
want
to
flex
those
we
want
to
be
able
to
vary.
A
Those
we've
got
the
penalty
amount
which
in
this
case
is
a
percentage
amount
of
the
total
value
of
the
goods
which
is
fairly
common,
and
then
we've
got
a
calculation
about
well.
How
are
we
going
to
calculate
the
penalty
amount
based
on
how
late
the
delivery
is?
So
in
this
case,
it's
for
every
two
days
of
delay:
we're
going
to
increment
the
penalty
up
to
a
cap
of
55%
of
the
total
value
of
the
goods,
and
if
you
still
haven't
delivered
it
after
15
days.
A
Well,
then
I
can
cancel
the
contract
and
walk
away
without
any.
You
know
without
any
commitment
to
you,
so
this
is,
you
know
this
is
clearly
a
sort
of
a
new
role
right.
You,
you
need
someone
with
legal
expertise
to
understand.
Where
are
the
points
of
flex
that
we
want
to
introduce
in
this
clause
and
then
someone
with
a
bit
of
technical
skill
to
at
least
say
well
10.5
that
looks
like
a
number
buyer
and
seller.
They
look
like
party
names.
A
A
So
when
we,
when
we
build
the
template
for
that
clause,
it
looks
something
like
this.
That's
the
well,
it
does
look
like
that.
That's
the
that's
the
format
for
that
lower
left
corner
of
the
triangle,
the
the
text
side
of
the
triangle
and
then
there's
a
data
model
that
that
that
is
referenced.
So
maximum
delay
is
defined
as
a
duration.
A
So
duration
is
one
of
the
sort
of
the
pseudo
built-in
types
in
the
Gord
project
type
system,
which
is
a
sort
of
distributed
internet
scale
type
system.
In
that
anyone
can
define
types
they
can
be
referenced
by
URLs.
You
know,
there's
no
central
type
of
repository
or
anything
like
that,
which
is
very
powerful.
A
The
cap
percentage
is
a
floating-point
number,
so
it's
a
double
in
in
this
concerto
modeling
representation
and
the
buyer
and
the
seller
are
both
record
parties.
So
these
are.
These
are
special
entities
that
we
know
are.
You
know
they
represent
businesses
or
human
beings
that
are
entering
into
this
contract.
So
it's
quite
a
lot
of
metadata
there
that
that
will
be
used
downstream.
A
A
A
So
at
the
top
we
import
the
models
that
we
want
to
use,
and
then
this
logic
is
calculating
that
when
did
the
delivery
occur?
What
are
the
terms
of
the
contracts?
How
do
we
calculate
the
penalty
based
on
the
terms
of
the
contracts
when
the
delivery
occurred?
It's
kind
of
joining
between
the
message
from
the
outside
world,
which
we
call
the
request
and
the
contract
data
through
produce,
in
this
case
at
the
bottom
of
my
payment
obligation,
so
the
logic
of
the
contracts.
A
A
You
know
based
on
when
the
delivery
occurred,
and
you
can
imagine
that
that
payment
obligation
will
then
be
picked
up
by
the
hosting
infrastructure
whatever
that
might
be,
and
it
could
turn
into
an
email
they
get
sent
to
Bob
in
accounting
or
it
could
be
a
token
exchange
or
it
could
go
over
a
traditional
payment
rail.
That
is
not
our
domain
of
concern.
You
know
our
domain
of
concern
in
AP
is
how
do
we
formalize
and
capture
that
logic?
A
Right
and
then
this
is
what
one
of
those
obligations
looks
like
there.
You
know
everything
is
represented
in
JSON.
You
can
see
that
there's
a
little
snippet
of
JSON
here.
We
know
that
the
obligation
is
related
to
a
specific
type
of
contracts
with
a
contract
ID.
We
know
that
who
the
buyer
and
the
seller
are
in
this
obligation
and
further
down.
We've
got
the
actually
the
amount
of
obligation,
110
US
dollars,
any
deadline
for
the
obligation,
etc,
etc.
A
So
at
the
top
above
the
dotted
line,
you
can
see
a
contract,
template
and
contract
parameters
and
essentially
what
we
do
is
we
generate
a
parser
from
that,
so
you
can
throw
it
any
natural
language
that
conforms
to
the
structure
of
that
template
and
we
can
pull
out
the
data
from
that
name,
natural
language
and
then
use
it
at
runtime
and
at
runtime.
The
programming
model
is
you
send
a
request
in
the
logic,
runs
the
logic
and
return
response
and
or
emits
an
event.
So
it's
a
pure
function,
a
deterministic
pure
function.
A
So,
let's,
let's
skip
the
slides
and
show
you
a
little
demo
before
that,
just
a
tiny
bit
of
context.
I've
got
a
fabric
1.4
peer
running
locally
on
my
laptop
you're,
going
to
see
a
a
client
application
to
that
peer,
send
a
smart
legal
contract
into
the
its
to
the
peer.
The
peer
will
initialize
the
contract,
which
in
this
case
means
downloading
the
templates,
the
logic
validating
them,
passing
them
and
then
we'll
be
able
to
trigger
the
logic
on
that
pier
and
the
world
state
will
be
updated
by
both
initialized
and
by
trigger.
A
So
when
we
initialize
the
contract
will
store
the
contract
text
on
chain
and
the
contract
data,
and
when
we
trigger,
we
can
actually
potentially
transition
the
state
of
the
contract
through
various
states,
because
these
contracts
are
typically
stateful
right.
So
the
you
know,
the
ledger
will
contain
the
latest.
The
the
world
state
will
contain
the
latest
state
of
the
contract,
as
well
as
the
contract
text
and
I
hope
I'll.
Make
that
clear
as
we
go
through.
A
A
A
You
can
see
that
the
party
ID
is
now
Acme.
If
I
change,
Acme
down
here
to
hyper
ledger,
you
can
see
that
the
contract
text
is
updated,
so
the
core
project
technology
is
binding,
that
legal
text
to
that
JSON
data
structure
in
both
directions-
and
that's
that's
quite
important,
because
it's
that
JSON
data
structure
that
your
code
cares
about,
whereas
it's
the
the
text,
obviously
that
the
human
being
and
the
the
dispute
resolution
body
cares
about,
and
that's
done
via
this
notion
of
a
template.
So
you
can
see
the
mark
up
here.
A
We've
introduced
the
variables
there's
even
some
sort
of
conditional
text.
If
we're
in
the
force
majeure
state,
then
we're
going
to
include
this
snippet
of
text
and
these
names
here
sell
our
cap
percentage
fractional
part
are
referenced
from
the
data
model
for
that
that
contract.
So
as
you,
as
we
saw
earlier,
buyer
is
an
accord
party
force
majeure
is
a
boolean
duration
is
a
penalty
duration
penalty
generation
is
a
generation,
etc,
and
then
the
last
corner
of
the
triangle
is
the
ogo
logic
itself.
A
This
is
where
we
can,
you
know,
enforce
invariants.
We
can
return
responses.
We
can
do
some
fairly
complex
temporal
calculation.
Time
is
often
really
important
in
these
contracts,
so
you
have
a
pretty
rich
library
of
time
and
date
functions
that
you
can
use,
and
then
we
can
omit
these
these
obligations.
A
A
And
then
we're
going
to
submit
a
request
to
the
logic
so
we're
not
in
the
Force
Majeure
State
we
haven't
declared
force
majeure,
we
haven't
delivered
the
goods
and
the
value
of
the
goods
is
$200
and
the
current
date
is
sorry.
The
agreed
delivery
date
was
December
2017,
so
we're
extremely
late,
and
when
we
send
that
request
into
the
logic
we're
going
to
get
a
response
which
says
well,
the
penalty
is
one
hundred
and
ten
dollars
and
actually
the
buyer
may
terminate
the
contract
we're
so
late.
A
A
Now
the
penalty
is
thirty
one
dollars
and
we
may
not
terminate
the
contract
without
you
know
violating
our
obligations
and
if
we
go
a
bit
crazy,
let's
say
that
the
agreed
delivery
date
was
the
1st
of
April.
Well,
we
get
a
week
in
an
error
saying.
Well,
you
know.
That's
in
the
future.
Something's
gone
wrong
here,
so
you
know
we're
pretty
happy
at
this
point.
We've
you
know:
we've
got
the
legal
text,
we've
written
the
logic,
we've
simulated
a
little
bit
now
we
want
to
deploy
it.
A
A
A
But
my
day,
job
is
as
a
CTO
for
Klaus
and
within
Claus.
We
pick
up
the
open
source
components
and
we
wrap
them
in
a
SAS
platform
that
gives
people
this
online
experience
of
editing
these
contracts.
So
this
is
what
the
the
Cicero
UI
component
looks
like
embedded
within
claws.
So
you
can
see
the
text
of
the
smart
claws
on
the
web,
so
we're
no
longer
editing
markdown.
A
And
the
text
will
get
pre-written.
You
know
we
can
agree
on
the
penalty
duration.
You
know
so
this
might
be
something
that
someone
in
procurement
is
doing.
They
don't
really
understand
the
logic
behind
the
clause.
Their
job
is
just
to
parameterize
it
during
the
negotiation
of
the
contract.
I,
don't
like
you
very
much
so
I'm
going
to
set
the
cap
percentage
to
be
75%
and
the
fractional
part
is
going
to
be.
You
know
weeks
instead
of
days
or
something
you
get
the
idea
right.
We've
got
this
bi-directional
binding
from
from
one
to
the
other.
A
We
can
then
download
that
markdown
and
that's
what
we
call
Cicero
Marc.
So
it's
kind
of
a
extended
markdown,
the
basic
sort
of
WYSIWYG
formatting,
is
captured
using
standard
markdown,
but
the
clauses
themselves
are
subtly
embedded
in
an
extended
markdown
format
within
that
document
and
I'll
show
you
what
that
looks
like
in
vs
coach.
A
So
this
is
a
Cicero
Marc
document
before.
Can
you
see
that
okay,
for
essentially
what
we
just
saw?
This
is
all
standard
markdown.
This
is
all
standard
markdown.
Then
there
is
this
code
block
which
has
a
any
embedded
flaws
in
it
and
within
that
code,
block
is
more
markdown,
which
is
the
the
text
of
that
of
that
clause
and
the
Accord
project.
Password
technology
will
be
able
to
pass
that
markdown
and
pull
out
the
JSON
data
structure
so
that
we
know
that
you
know
Dan
and
Steve
are
the
Accord
parties.
A
The
cap
percentage
is
85%,
etc,
etc,
and
then
there's
there'll
be
some
more
text.
So
the
the
working
assumption
here
is
that
you'll
have
an
existing
word
document,
which
might
be
70
pages.
Long
and
95%
of
that
word
document
is
for
human
beings
and
will
almost
never
be
automatable,
but
within
that
word
document
there'll
be
there'll,
be
a
handful
of
clauses
that
you
can
automate
and
there's
a
lot
of
value
in
automating
them.
Often
these
are
sort
of
the
happy
path
clauses
like
late
delivery
and
penalty,
payment
terms,
etc,
etc,
etc.
A
Some
of
the
clauses
you
might
just
choose
to
parameterize
the
variables
so
you've
got
like
a
machine,
readable
representation
of
the
variables
you
won't
bother
implementing
any
logic,
maybe
because
the
logic
is
non,
it's
not
deterministic
or
it
requires
human
decision-making
for
some
of
them.
The
more
mechanical
clauses
like
this
one
you
might
choose
to
to
write
the
logic
as
well.
A
So
now,
what
I'm
going
to
do
is
I'm
going
to
send
this
markdown
document
to
my
fabric
instance.
So
I
have
a
piece
of
chain
code.
That's
running
on
fabric
I've
deployed
it
to
my
local
fabric
and
I'm
gonna.
Call
this
initialize
method,
which
takes
that
contract
text
and
what
the
initialize
method
is
going
to
do.
A
A
We
are
going
to
do
a
whole
bunch
of
connection
boring
stuff.
Then
we're
going
to
read
this
request.
Json
file
off
the
filesystem,
we're
going
to
read:
contract
MD
off
the
filesystem.
Women
will
initialize
the
contracts
with
the
contract
text
and
then
we
will
trigger
the
contracts
with
the
the
request
that
we
read
off
disk.
So
this
is
kind
of
simulating
hooking
it
up
to
your
IOT
platform
or
whatever
it
is
they
you
might
be.
You
know
where
you're
gathering
those
late
delivery
notifications
and
then
we
then
we
disconnect.
A
So
let's
run
invoke
so
first,
we
load
the
request
looks
very
similar
to
the
one
we
we
simulated
before.
We're
not
enforced.
Mature
value
of
the
goods
is
200.
The
agreed
delivery
date
is
February
first,
so
we
found
one
clause
in
the
markdown
that
we
we
sent
into
the
fabric
and
then,
when
we
triggered
that
clause
it
calculated
that
the
penalty
was
170
and
that
all
happened
on
chain.
A
A
So
yeah
the
penalty
has
doubled.
So
that's
that's
good!
That's
reassuring!
So
now,
let's
mess
with
the
the
contracts
a
little
bit.
So
this
is
the
Cicero
mark
that
we're
sending
up
to
the
ledger.
So,
let's
change
so
instead
of
for
every
two
days
of
delay,
let's
make
it
every
one
day
of
delay
and
Riaan
VOC.
A
A
So
we're
now
up
to
400,
so
that
was
the
total
value
of
the
goods.
So
we
we
capped
it
a
hundred
percent
just
for
fun.
Let
me
break
the
structure
of
the
template,
so
I'll
introduce
something
random
in
here.
The
passers
now
should
now
complain
and
say:
I
can't
deal
with
that
that
the
structure
of
that
text
doesn't
match
the
structure
of
the
template
that
that
is
defined
by
this
thing.
A
Boom
there
we
go
endorsement,
has
failed
and
we
even
get
a
little
syntax
error
coming
back
from
the
parser.
It
can't
deal
with
that
contract
because
it
doesn't
conform
to
the
structure
of
the
template,
and
this
this
is
kind
of
interesting,
because
in
this
case,
we've
made
the
choice
that
we
will
download
the
templates
from
the
internet
at
initialized
time
of
the
of
the
smart
contract.
That's
obviously
super
kind
of
that's
a
really
aggressive
stance
to
take.
You
might
not
want
to
take
that
stance.
A
You
might
want
to
take
the
template
archive
and
kind
of
statically
bundle
it
with
your
smart
contract
code,
so
the
two
things
are
baked
together
and
you
get
sort
of
real.
You
know
cryptographic
assurance
that
this
is
that
smart
contract,
so
you
could
do
that,
but
doing
it.
This
way
allows
me
to
essentially
change
this
reference
and
use
any
of
the
other
accord
project
templates
that
have
been
published
so
there's
template
for
fragile
goods,
for
example.
A
A
Would
be
using
a
URI
which
was
fragile
goods
at
zero
thirteen
with
this
hash,
so
this
hash
is
kind
of
interesting
in
there.
It's
a
content-based
hash
of
the
structure
of
the
template
itself.
So
when
I
address
a
template
with
a
version
number
and
a
hash
I'm
pretty
certain
about
what
it
is
that
I'm
referencing,
because
if
any
bytes
changed
inside
that
template
that
the
hash
would
be
would
also
change.
A
A
B
A
A
Yeah,
so
if
I,
if
I
went
back
into
template,
studio
and
I
start
changing
the
text,
the
model
or
the
logic
or
the
metadata
for
the
contract,
typically,
what
I
always
do
is
I
would
you
know,
bump
the
version
number
and
then
re-exported,
which
gives
us
this
Cicero
template
archive
the
zip
file
CTA
and
it
will
have
a
new
hash.
So
I
would
say
you
know,
I
accept
your
redline
I've
made
the
changes
to
the
legal
text.
A
A
You
know
that's
a
written
process
where
we
would
negotiate
and
we
would
agree
on
an
amendment
to
the
contract
which
in
this
world
essentially
means
probably
potentially
changing
the
text
or
the
logic
of
some
of
these
clauses,
which
would
give
us
a
new
version
of
the
template,
and
at
that
point
we
need
to
upgrade
the
smart
contract
code.
That's
running
on
fabric,
so
you
know
within
the
the
fabric
tooling.
A
Here
you
can
see.
I
have
a
whole.
You
know
because
this
it
took
me
a
little
while
to
get
this
right.
This
demo,
so
I
have
a
whole
bunch
of
versions
of
that
smart
contract
that
that
I've
installed
on
my
peer
right
now,
I
have
version
zero.
Four
four
instantiated,
but
I
can
upgrade
it.
So
if
I,
if
I
build
a
new
version
of
the
smart
contract,
perhaps
as
a
result
of
negotiation
for
an
amendment,
then
I
could
do
a
sort
of
a
hot
upgrade
of
the
smart
contract
code
that
it's
running.
A
Yeah
you
you
so
if
I
do
a
docker
PS
here,
you
will
see
or
maybe
not
that
I
have
version
0
for
4
of
the
smart
contract
running
but
you're
quite
right,
because
I
did
an
upgrade.
I
still
have
version
0
for
3
running,
but
I
as
a
sort
of
a
peer
admin.
I
could
remove
version
0
for
3.
It's
not
currently
being
used
anymore.
You
know
all
of
the
transactions
are
being
handled
by
version
0
for
4
I,
think
they
lead
it
there
so
that
you
can
do
a
rollback.
A
A
So
the
person
that
built
that
late
delivery
and
penalty
template
allowed
the
person
sending
the
request
to
the
template
to
state
whether
they
you
know
were
declaring
force
majeure
but
yeah
exactly
the
mechanics
for
that
would
probably
vary
from
from
case
to
case
I.
Don't
have
a
out-of-the-box
solution,
driver.
A
They
could
yes
yeah,
they
could
yeah
so
in
in
in
in
this
data
model.
Force
missouri's
is
super
simple
right,
it's
a
boolean,
but
you
could
define
it
as
an
enumeration
and
say
right.
Well,
what
are
the
what's
the
type
of
force
majeure
that
you're
declaring,
and
then
you
have
to
tell
us
why
you're
declaring
force
measure,
that's
really
a
sort
of
a
modeling
exercise,
any
more
questions.
A
So
we
so
within
the
technology
working
group
of
the
Accord
project,
we
really
focus
on
providing
these
libraries
that
upstream
consumers
can
then
use
so
useful
libraries.
So
that's
very
generic.
We
don't
want
to
tie
it
to
one
specific
industry
or
all
use
case,
but
what
I
can
say
is
that
the
sweet
spot
for
this
kind
of
technology
is
when
you've
got
not
every
contract
is
a
snowflake
right,
because
if,
if
every
contract
is
a
snowflake,
then
it's
really
hard
to
build
the
templates
by
building
a
template.
A
That
is
an
investment
and
it
takes
time
so
there's
an
assumption
here
that
there
are
templates
and
it's
sort
of
a
dirty
little
secret,
I.
Think
in
the
legal
industry.
Then,
when
you
go
to
your
law
firm
and
you
say,
give
me
a
contract
to
sell
cane
sugar
in
Europe
or
something
you
know
they.
They
sell
it
to
you
as
a
bespoke
contract,
but
they
do
actually
assemble
it,
usually
from
templates
right.
They
have
a
library
of
reusable
texts
that
they
use.
A
Whereas
if
you
sign
one
of
these
ten
times
a
day,
then
the
operational
overhead
can
be
very
large.
So
our
sweet
spot
is
really
they're,
not
snowflakes,
but
they're,
not
all
exactly
the
same
and
there's
a
there's
a
significant
volume
of
them,
so
that
tends
to
occur
in
like
supply
chain
procurement,
in
particular,
Cyrus.
A
Because
within
the
text
there's
actually
a
there's,
an
Ergo
function
call
so
we're
saying
I
want
to
take
out
a
loan
for
this
amount.
It's
at
this
rate
over
this
duration
and
therefore
your
monthly
payments
or
a
recalculation
right.
But
you
want
the
monthly
payment
to
appear
in
the
legal
text
that
someone's
gonna
sign.
So
in
that
example,
we've
inlined
and
I'll
go
call,
so
you
can
call
any
ergo
function
from
from
within
Cicero
mark
and
if
we
look
at
the
sample,
if,
as
I
change
the
interest
rate
I
don't
know
how
to
refresh
it.
A
A
A
Yeah,
so
the
question
is:
around
clauses
are
often
not
atomic
right.
There
are
relationships
between
clauses
and
contract.
State
is
often
shared
between
clauses,
so
contractors
can
be
kind
of
like
a
state
machine
right.
It
starts
in
a
state
and
then
you
do
something
and
it
enters
another
stage
and
I
do
something
and
it
ends
as
an
other
state
and
often
that
state
needs
to
be
shared
across
all
the
different
clauses.
So,
yes,
we
approach.
I
would
guess
we're
probably
50%
of
our
of
the
way
through
dealing
with
that
problem.
A
We
can
reference
contract
variables,
contract,
scoped
variables
from
within
clauses,
so
for
the
computer
scientists,
the
clauses
essentially
become
methods
or
functions
and
they're
hosted
by
something
that
looks
a
bit
like
a
class
except
it's
immutable,
so
they
can
reach
back
out
and
reference
the
contract
variables.
The
part
that
we
haven't
yet
solved
is
when
one
Clause
emits
an
obligation.
Often
other
clauses
would
want
to
be
notified,
so
there's
sort
of
a
data
flow
within
the
contract
and
we
have
a
project
where
we're
working
on
that.
At
the
moment.
A
A
A
A
A
So
within
accord
right
now
we
don't
deal
with
signature.
Main
DocuSign
is
a
member
of
a
chord
and
you
know
they're
they're.
Obviously
the
big
gorilla
around
that
space,
putting
my
clothes
hat
back
on
the
clothes
platform
does
deal
heavily
with
signature.
So
you
know
often
you
wouldn't
just
download
the
markdown
for
this
contract.
You
would
download
the
PDF
of
the
contract
and
you
know
we
have
an
integration
with
stock.
You
sign
and
hello
sign
so
that
you
can
send
that
PDF
for
signature.
A
A
Yeah
I
think
I
just
caution
that
the
the
reason
DocuSign
is
the
huge
company
that
is
is
because
they
did
all
the
hard
work
of
convincing
all
the
various
jurisdictions
in
the
world
that
DocuSign
was
legally
enforceable.
So
that's
like
it's
not
really
a
well.
Five
percent
of
the
problem
is
technical.
Ninety
five
percent
of
it
is
actually
relational.
I
mean
you
know,
making
sure
that
when
you
and
I
DocuSign
something,
if
I
renege
on
my
commitments,
that
you
can
take
it
to
a
judge.