►
From YouTube: How To Build a Call Spread
Description
Chris Hibbert, Software Engineer at Agoric, goes through call spread implementation that includes two main features: the Zoe contract and how promises work in a smart contract.
Learn more about Zoe here: https://agoric.com/documentation/getting-started/intro-zoe.html
Access the Call Spread example: https://agoric.com/documentation/zoe/guide/contracts/callSpread.html
We suggest watching this presentation by Joe Clark about the call spread: https://youtu.be/IfgmKu78qb4
ABOUT
Build Fast, Earn Fast - Agoric enables developers to rapidly deploy dapps and DeFi markets on-chain using composable JavaScript smart contracts. Safely get your project from vision to global market.
LINKS
https://agoric.com
https://agoric.com/twitter
https://agoric.com/discord
https://agoric.com/telegram
https://agoric.com/newsletter
Click the 'SUBSCRIBE' button to follow our Youtube channel!
A
All
right
thanks
roland
good,
okay,
so
I've
got
my
screen
up
there.
Now
thanks
roland
for
the
introduction,
thanks
joe
to
joe
for
the
talk
he
gave
earlier.
If
you're
watching
this
recorded
later,
you
may
want
to
take
a
look
at
joe's
talk,
I'm
going
to
refer
back
to
some
of
the
things
that
he
said,
I'm
going
to
go
through
a
implementation
of
a
call
spread
that
that
we
wrote
here
at
gorick.
B
A
Yeah,
I'm
used
to
using
my
full
big
screen
to
look
at
code
and
looking
looking
at
it
through
a
tiny
little
window,
I'll,
try
and
make
do
with
this.
So
this
is
an
implementation
of
a
call
spread,
as
joe
clark
explained
earlier
in
my
presentation
of
this
contract,
I'm
going
to
talk
about
two
major
topics:
each
with
a
bunch
of
bullet
points.
The
the
first
overall
topic
I'm
going
to
talk
about
is
standard
features
of
zoe
contracts.
A
A
There
are
a
couple
of
things
that
are
unusual
about
the
call
spread
it
uses
promises
in
a
way
that
we
hadn't
seen
before
in
contracts
I'll
explain
why
and
how
we
do
that
and
it
uses
the
price
authority,
which
is
a
kind
of
an
oracle
and
I'll
talk
about
how
the
price
authority
feeds
into
this
and
what
it
does.
So,
I'm
going
to
start
with
the
standard
features
of
zoe
contracts.
A
A
Linear
calculation,
to
figure
out
how
much
to
give
to
each
of
the
parties-
and
so
that's
that's
the
the
calculation
that
the
contract
has
to
make
and
that
figures
in
in
a
couple
of
ways.
One
is
that
there's
a
bunch
of
the
code
that
you'll
see
that's
about
making
sure
that
this
happens
at
the
right
time
and
then
there's
figuring
out
the
right
price
and
allocating
it
to
the
to
the
right
party.
So
back
to
the
code.
A
Take
just
a
second:
I
only
need
six
clicks
to
do
that
there
there
that's
still
back
to
the
code
now.
So,
let's
start
with
the
high
level,
as
I
said,
the
things
that
every
contract
does
I've.
I've
collapsed
a
bunch
of
code
here,
there's
a
couple
of
comments
that
I've
collapsed
and
some
other
things.
The
main
thing
I
want
to
start
with
is
the
shape
of
every
zoe
contract.
A
This
contract
only
needs
to
return,
one
of
them
as
the
invitation
to
the
creator
who's
going
to
fund
the
entire
contract,
and
here
we
you
normally,
we
would
only
export
the
start
function
for
zoe
to
execute
here.
We've
also
exported
another
function,
just
for
testing
purposes,
so
that's
the
one
that
actually
does
the
calculation
of
the
share
of
the
of
the
of
the
collateral.
That
goes
to
the
long
position.
A
A
I
don't
see
it
immediately,
so
I'll
go
back
to
the
code,
the
oh!
Actually
I
wrote
it
here.
Here's
here's
the
a
listing
of.
What's
in
the
terms
for
this
as
joe
talked
through
it
there's
an
underlying
amount.
We
need
to
get
access
to
a
price
authority
to
tell
us
what
the
price
is.
We
have
an
expiration
time
and
a
timer
there's
k1
and
k2
are
strike
price
one
and
strike
price
two
and
the
settlement
amount
is
can
be
in
a
different
currency,
as
joe
referred
to
you
can
have.
A
A
We
then
start
by
asserting
that
the
collateral
and
the
strike
map
are
both
used
as
math
means
that
they're
fungible
currencies,
and
I
only
do
that
for
strike
and
collateral.
The
underlying
doesn't
actually
have
to
be
fungible.
It
could
be
the
the
price
of
of
you
could
be
doing
a
call
spread
on
the
price
of
a
magic
shield,
or
something
like
that.
There's
just
one
magic
shield:
if
there's
a
market
for
it,
then
you
can
know
what
the
the
price
is
over
time
and
be
able
to
do.
A
I
then
assert
that
the
strike
price
two
is
greater
than
strike
price,
one
just
the
nature
of
the
call
spread
option
if
you
wanted
them
in
the
other
order,
just
name
them
the
other
way.
That's
pretty
simple
here
we
need
well,
we
hadn't
needed
to
do
this
in
previous
zoe
contracts,
but
because
of
the
way
we're
issuing
options
to
the
holders
of
the
long
position
and
the
short
position,
the
the
issuer
of
the
invitation
needs
to
be
known
to
zoe.
I
may
say
more
about
that
later.
A
A
The
way
make
creator
invitation
goes.
Is
it
it's
a
javascript
function
that
does
a
bunch
of
work
and
then
calls
ccf.make
invitation
and
there's
two
sides
to
what
make
invitation
is
doing.
There's
there's
aside
from
what
zoe
sees
and
aside
from
what
the
contract
is
doing.
Zoe
is
using
this
in
order
to
to
return
the
invitation
to
the
owner
so
that
they
can
get
it
back
later
on
and
what
zoe
does
is
it
when
you
call
make
invitation
you
pass
at
the
handler?
A
B
A
So
what
what
make
creator
invitation
does
is?
It
makes
the
two
invitations
that
will
be
the
assets
that
the
long
position
and
the
short
position
get.
Those
are
pretty
simple
invitations,
because
all
they
do
is
they
don't
do
any
calculation.
They
just
give
a
payout
at
the
end,
the
so
the
the
outer
invitation
makes
the
pair
of
invitations.
A
Figures
out
the
amount
of
those
things
so
that
it
can
put
them
in
the
inner
invitations,
so
that
the
holders
of
the
two,
the
long
position
in
the
short
position
can
can
tell
what
they
are.
I
have
a
test
in
which
the
the
maker,
the
creator
of
the
outer
invitation,
let's
call
her
alice,
fully
endows
the
whole
contract
and
then
sells
one
of
the
positions
to
the
to
bob
and
and
gives
the
other
one
to
carol
just
because
that
was
easier.
A
A
All
of
this
is
this
is
about
creating
this
is
about
creating
those
two
invitations.
Those
are
here
so
these
inner
invitations.
As
I
said,
they
just
assign
a
seat
I'll
talk
about
the
promise
of
stuff
later,
but
the
these
these
make
option.
Invitations
are
really
simple:
they
don't
do
very
much.
The
then
the
when
it
when
the
outer
invitation
creates
the
inner
invitations.
A
A
A
But
what
I
want
to
point
to
right
now
is
that
at
the
time
that
the
that
we
get
the
result
back
from
the
the
payment
authority,
we'll
call
this
function
calculate
long
share,
we'll
pass
in
I'm
going
to
get
rid
of
this
point
just
so
that
you
can
see
all
of
this
we're
going
to
pass
in
the
strike
math.
That's
a
lot
allows
us
to
do
the
calculations.
A
The.
If
you
look
at
our
ertp
protocol,
we
have
these
math
objects
that
let
us
do
calculations
according
to
the
different
currencies.
This
is
a
calculation
of
the
that
has
to
do
with
the
strike
prices,
so
it
needs
to
be
done
in
terms
of
the
strike
math.
Other
calculations
use
other
maths.
I
think
I
showed
here
we
have
we.
We
do
some
calculations
in
terms
of
the
collateral.
A
That's
what
this
calculation
does
so
calculate.
Long
share
comes
up
down
here.
This
is
called
in
payoff
options,
which
is
called
from
the
scheduling
which
I'm
still
going
to
get
to
later.
The
the
reallocate
here
is,
it
calls
reallocated
to
seat
I've
got
that
collapsed.
Currently,
that's
that's
part
of
the
promised
architecture
that
that's
that's
going
on
here
and
so
I'll
I'll
expand
that
out
shortly.
A
If
it
was
a
margin
contract,
then
each
of
them
would
maybe
need
to
adjust
their
margin
as
the
price
change.
But
this
is
a
fully
collateralized
one.
So
there's
no
margin
adjustments
required,
and
so
each
of
them
just
gets
an
an
asset.
That
is
an
option
that
either
does
pay
out
up
to
a
certain
amount
or
doesn't
pay
out
at
some
future
time,
and
in
order
to
make
those
tradable
as
zoe
assets,
they
need
to
be
invitations
that
you
can
verify.
A
You
can
see
some
of
our
other
talks
we'll
talk
about
how
how
ertp
works.
I'm
not
going
to
go
into
that
in
much
detail
here.
The
consequence
is
that
the
the
those
two
options
don't
don't
exist
until
they're
created
inside
this
function
inside
make
creator
invitation,
and
so
we
need
we
we,
the
other
part
that
makes
this
hard.
A
You
saw
that
up
at
the
beginning
here,
oops
sorry,
I
don't
mean
to
scroll
around
quite
so
much
at
the
very
beginning
of
the
contract
after
we
had
done
validation.
What
I
use
is
some
an
underlying
function
that
we
have.
That
makes
a
promise
kit,
which
returns
the
ability
to
resolve
the
promise,
the
ability
to
reject
the
promise
and
the
promise
itself,
which
you
can
use
to
to
get
the
value
that
it's
eventually
resolved
to.
A
So
I
store
each
of
those
one
for
the
long
and
one
for
the
short
so
that
I
can
use
them
again
later,
and
that
means
that
this
reallocate
to
seat,
which
is
going
to
get
called
when
at
the
closing
time
that
one
is
here,
that's
the
one
that
collapsed.
What
it
actually
needs
to
do
is
sorry.
This
is
totally
faster
than
I
expect.
A
What
it
needs
to
do
is
get
that
promise
back
out
of
the
array
that
I
started
in
and
wait
for
it
to
be
resolved,
which
most
of
the
time
is
probably
going
to
be
before
the
closing
time.
But
it
might
not,
and
in
the
case
that
it's
not
before,
then
we
have
to
wait
for
that
to
be
exercised
in
order
for
the
seat
to
be
available.
And
then
we
can
do
the
settlement.
At
that
point
and
though
the
way.
A
A
We
did
that
just
as
soon
sorry
scrolling
slowly
there,
so
this
isn't
in
the
very
beginning
make
it
invitation
we
as
soon
as
we
stored
the
collateral
amount
in
the
collateral,
see
this
amount
in
the
collateral
seat.
We
will
schedule
payoffs
and
schedule.
Payoffs
is
here.
This
goes
to
the
price
authority,
which
is
a
kind
of
a
price
oracle.
A
It's
it's
built
on
top
of
the
chain
link
oracle,
patrick
collins
will
be
talking
about
connecting
up
chain
link
oracles
tomorrow
morning,
so
you
can
watch
that
talk
or
if
you
don't
watch
this
talk
until
later,
you'll
be
able
to
so.
We,
the
the
price
authority
that
we've
written
wrapped
around
the
the
the
oracle
api,
has
a
method
called
quote
it
time,
which
takes
an
expiration
time.
The
authority
has
its
own
clock
that
it
uses.
A
But
this
then
function
isn't
called
until
the
price
authority
returns
a
quote
at
the
expiration
time,
and
so
when,
when
that
happens
later,
this
calls
payoff
options
it
it
will
have.
The
the
price
quote
was
the
return
value
from
quote
at
time,
and
so
we're
going
to
pass
that
quote
amount
into
payoff
options,
so
at
some
future
time
we'll
know
the
the
value.
A
That's
be
that
that's
available,
and
this
will
take
that
and
using
the
two
strike
prices.
It
will
call
that
calculate
long
share
function
that
I
showed
you
before
passing
all
of
these
in
so
this
will
give
it
the
position
from
zero
to
one.
That's
due
to
the
long
share
inverse
is
basically
right,
one
to
a
hundred
because
inverse
assumes
that
it's
a
percent
and
we'll
just
give
the
short
side
of
100
minus
what
the
wall
side
gets
when
we
call
reallocate
to
seat.
Remember.
A
A
We
can
call
in
to
zoe
and
pass
in
the
games
that
we
decided
to
say
the
trade
function
is
saves
some
some
work
on
the
caller's
end
by
requiring
that,
if
you
say
the
gains
on
each
side,
you
don't
have
to
say
the
losses
on
the
on
the
the
losses
for
that
side.
In
this
case,
the
the
this
seat
is
the
seat
that
was
passed
in
the
seat
that
was
pulled
out
of
that
promise
and
they're
going
to
get
their
portion
of
the
payout.
A
The
collateral
keys
that
have
been
holding
on
since
the
contract
contract
was
created
and
it's
going
to
end
up
with
it
doesn't
gain
anything
and
trade
figures
out
how
to
subtract
that
out,
and
so
it's
it
gets
whatever.
Whatever
remains
from
that,
then
we
exit
the
seat.
I
keep
track
of
how
many
seats
have
exited
so
that
when
we're
done,
we
can
shut
down
the
contract.
We
don't
want
to
shut
down
the
contract
because
the
long
position
has
closed
or
because
the
short
position
is
closed.
We
need
them
both.
A
A
A
A
A
A
A
Kate
answered
some
of
these
questions.
Zimmer
tb
uses
digital
assets.
I
talked
about
the
digital
assets.
You
can't
see
them
here.
If
anybody
asks
I
could,
I
could
walk
through
the
test
and
show
how
they're
used
as
actually.
Why
don't
I
do
that?
Here's
the
test
code,
good
this
is
this-
is
the
test
case
where
we're
selling
one
of
the
options,
so
I'm
going
to
skip
skip
over
a
bunch
of
pieces.
Alice
has
set
up.
Each
of
them
gets
some
money
in
the
beginning
of
this
test.
A
We
use
a
manual
timer
if
you're
writing
your
own
contract
and
it
uses
oracle's
or
price
authorities.
You'll
need
to
use
a
manual
timer.
The
the
thing
about
manual
timer
is
its
api
from
the
contract
side
looks
just
like
the
regular
one.
Sorry,
I'm
scrolling
fast
to
get
down
to
the
bottom
of
this,
but
the
the
thing
about
the
manual
timer
is
that
the
time
only
advanced
is
when
you
say
tick
to
it
all
right.
A
A
A
She
gets
payouts
from
this
and
that's
the
two
options
that
the
that
that
will
that
hold
the
payouts
for
the
two
sides,
and
I
think
she
sells
the
long
options
so
she's
making
she's
making
a
an
invitation
here
for
presumably
because
bob
is
usually
the
second
party.
So
she
makes
an
invitation
for
an
exchange
in
which
she's
going
to
give
the
long
option
she's
going
to
ask
bob
for
200
bucks,
and
so
she
does
a
deposit
of
the
long
amount.
A
And
then
he'll
end
up
with
he'll
be
able
to
extract
this
is
this
is
where
he
he
the
long
now
option
payout
is
the
is
the
payout
that
alice
got
this,
which
was
past
mob
and
bob
uses
that,
as
an
invitation
to
zoe,
he
doesn't
pass
in.
We
usually
the
offer
call
has
an
invitation
and
it
has
a
proposal
and
it
has
a
payment.
A
A
So
that's
a
quick
trip
through
here.
If
there
are
more
questions,
I'd
be
glad
to
answer
them.
Otherwise
those
are.
Those
are
the
points
that
I
wanted
to
make.
The
the
call
spread
option.
Does
some
unusual
scheduling
and
uses
promises
for
the
seats
in
a
way
that
we
haven't
done
before,
but
it's
fairly
standard
in
the
way
that
it
deals
with
the
terms
and
the
way
it
creates
invitations
and
like
all
contracts,
it
has
to
calculate
payoffs
and
allocate
the
the
outcome
to
to
the
very
among
the
various
seats.
This.