►
From YouTube: DeFi Workshops: Smart Contracts in JavaScript
Description
This event hosted by Dean Tribble (CEO) will highlight how Agoric solves DeFi’s largest problems: user fund security and lack of true composability. You'll get a detailed walkthrough of how to build a smart contract on Agoric and an early taste of what's to come!
How to prepare:
https://bit.ly/agoric-alpha
Get support:
https://agoric.com/discord
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
A
We
do
have
a
agora
discord
up
and
there
is
a
channel
in
d5
workshop,
for
which
is
the
best
place
to
ask
questions.
We
will
also
try
and
keep
an
eye
out
on
chat
here,
but
mostly
the
chat
here
will
be
santi,
relaying
things
and
links
and
pasting.
The
links
here
so
at
the
top
of
the
zoom
chat
is
the
link
to
discord
and
if
you
jump
in
there
it'll
be
easier
to
record
and
follow
and
have
people
join
in
afterwards.
A
So
thank
you
much
for
that.
Oh
let
me
skip
that.
So
I'm
going
to
talk
introduce
some
of
the
key
concepts
in
a
gorek
before
I
before
I
dive
into
specifically
the
code,
and
no.
This
is
not
chilling
or
anything
like
that.
You
just
need
to
be
oriented
in
what
we're
doing
our
focus
is
a
blockchain
which
will
be
a
public
blockchain
for
next
year
for
rapid
development
of
d5
right
d5.
A
Has
you
know?
Projects
have
gone
from
taking
years
or
months
to
ship
down
to
mere
weeks,
in
the
case
of
something
like
uni,
the
uni
token,
but
it's
really
a
new
frontier
for
finance,
so
it
is
like
most
new
frontiers.
It
is
exciting,
but
quite
but
but
very
dangerous.
You
know
the
kinds
of
things
that
we
address
are
the
poor
performance
of
the
underlying
execution
engines,
whether
it's
volatile
gas
prices
or
the
slow
finality.
A
We
we
we
care
a
lot.
You
know
those
those
kind
of
come
out
of
proof
of
work
systems,
but
proof
of
stake
systems
have
their
own
challenges,
with
economic
pressure
towards
centralization
and
missing
economic
structure
that
you
need
for
the
proof-of-work
world
to
to
flourish.
Those
are
merely
background
for
what
we're
doing
here.
A
The
the
uni
governance
stuff
fit
exactly
what
they
needed
and
they
had
background
information
to
be
able
to
pull
all
this
stuff
together,
and
so
they
had
kind
of
everything
working
for
them,
lend
f
dot
me
did
the
same
thing
where
they
took
compound
governance
code,
put
it
together
with
their
stuff
rolled
out,
a
system
which
they
then
lost.
25
million
dollars,
as
as
the
resulting
system,
had
a
bug
right
code.
Copying
for
reuse
is
something
that
people
have
done
since
you
know
there
have
been
computers,
but
it's
unsafe.
A
A
I
won't
go
into
the
gas
economics
this
round,
but
but
what
you'll
be
seeing
and
what
I'll
be
showing
you
code
wise
is
that
we
build
smart
contracts
in
a
secure
version
of
javascript
using
familiar
patterns.
So
the
reason
why
npm
took
off
the
reason
why
react
took
off
is
that
you
could
build
software
using
components
and
building
on
components
that
are
other
people
built.
So
it's
not
that
you're
copying
their
source
code
and
modifying
it,
though.
That
of
course
was
possible
as
well.
It's
that
most
react
applications
right.
A
I
can
have
security
and
and
and
risk
management
as
part
of
individual
components
where
they've
already
been
reviewed,
I'm
using
them
unchanged
rather
than
taking
source
code,
modifying
it
and
invalidating
security
reviews
and
analysis
that
people
have
already
done
all
right.
So
let
me
by
the
way
I
do
have
the
the
various
chat
windows
up
here.
A
A
It
has
some
of
these
smart
contract
components
that
I'm
talking
about
here
are
actually
used
as
part
of
the
infrastructure,
so
the
same
smart
contract
infrastructure,
you
would
be
able
to
have
the
staking
and
rewards
and
derivatives
and
all
that
sort
of
thing
as
part
of
the
overall
economy
of
the
system.
That's
as
much
as
I'm
going
to
say
about
this
here
until
we're
until
we're
done.
The
fundamental
thing
is
this
simple
composition
of
financial
logo,
legos
and
and
I'll
and
I'll
be
showing
code
for
that
in
a
moment.
A
Okay,
so
the
technical
stack
of
agorak.
As
I
mentioned,
it's
cosmos
sdk,
underneath
we
have
an
infrastructure
for
having
separate
contracts
and
separate
components
all
securely
confined
from
each
other.
That's
the
eugoric
vm,
so,
unlike
so
so
so
agoric
extends
cosmos
or
polkadot,
or
these
systems
that
we
are
connected
to
with,
with
with
with
interop
protocols,
extends
them
with
having
a
vm
chain.
So
instead
of
you
know
so
so
like
with
ethereum,
you
can
permissionlessly
deploy
smart
contracts
to
cooperate
in
an
ecosystem
of
other
smart
contracts.
A
A
So
let
me
dive
into
the
ertp
and
I'm
going
to
introduce
a
few
more
concepts
and
then
we'll
start
looking
at
code,
get
a
few
more
concepts
and
then
really
dive
in
so
ertp.
The
electronic
rights
transfer
protocol
is
this
api
developed
literally
over
decades
right
agoric
was
founded
by
pioneers
in
the
space
of
smart
contracts.
We've
been
doing
some
of
these
things
in
commercial,
large-scale,
interesting
disruptive,
financial
systems
outside
of
blockchain
and
a
lot
of
the
ideas
of
percola.
A
You
know
we're
percolating
back
in
so
the
key
elements,
and
I
talk
about
the
issuer
kit.
The
key
element
is
for
every
new
kind
of
digital
asset.
There
are
a
set
of
of
helper
objects
that
work
together.
So
first
there
are
persons
I
can
have
generic
purses
and
I
and
I
have
purses
that
contain
a
particular
kind
of
assets.
I'll
have
purses
that
contain
my
my
pegged
ethereum
lab
purses
that
contain
my
underlying
token
I'll
have
purses
that
contain
my
concert
tickets.
So
it's
a
it's
an
account
for
a
specific
kind
of
asset.
A
You
know
it's
an
object-oriented
system,
if
you
hand
me
an
object,
I
want
to
verify
that
it
is
a
payment
of
the
simoleon
cash
that
I
was
expecting
and
not
a
payment
of
your
favorite
pirate
cash
for
the
refer
for
the
store
down
the
street
and
then
finally,
there
are
mints
where
mints
are
the
engine
that
let
you
mint
new
payments
right,
so
so
for
a
given
currency.
I
will
have
this
kit
of
things
to
be
able
to
mint,
verify,
save
and
store
all
these
payments.
A
Okay
or
all
the
all
these
digital
assets,
and
then
these
are
organized
or
identified
or
analyzed
with
two
more
elements.
The
brand
is
just
an
atom
that
says
yes,
this
this
is
distinctly.
You
know
the
the
the
peg.
This
is
distinctly
atoms.
This
is
distinctly
concert.
Tickets
for
this
particular
concert
venue,
whatever
kind
of
asset
it
is
the
the
the
the
atom
is
exactly
that
brand
and
then
finally,
there
are
amounts
where,
with
the
fungible
token,
an
amount
is
simply
a
a
a
number.
A
So
I
have
you
know:
40
simoleons
I've
got
2
000
atoms,
whatever
it
is,
but
for
non-fungible
tokens
amounts
just
work
and
there's
a
math
that
goes
along
with
them,
where
it
is
seat,
e4,
e5
and
e6,
of
a
particular
of
a
particular
theater
so
and
who
asked
the
question:
what's
the
difference
between
a
person,
a
mint,
a
purse
is
an
account,
it's
the
thing
that
holds
it:
it's
not
able
to
create
it.
I
can
only
get
assets
into
a
purse
by
having
a
payment
and
depositing
it.
A
The
mint
is
the
currency
is
the
thing
that
that
creates
the
underlying
new
instances.
So
if
I
want
to
have
a
currency
that
there's
a
fixed
amount,
I
mint
you
know
50
000
units
and
then
I
throw
away
the
mint
and
now
no
more
units
can
be
minted.
We
can
all
transfer
them
around
with
per
with
payments
and
deposit
them
into
purses
and
verify
that
we
got
the
right
thing
by
issuers
and
describe
you
know
it's
20
bucks.
It's
not
I'm
not
handing
you
a
20
bill,
I'm
just
telling
you
the
price
is
20
bucks.
A
That
would
be
an
amount
right
and
so
all
of
those
things
we
can
do
after
having
destroyed
the
mint.
But
the
mint
is
necessary
if
you're
going
to
keep
issuing
new
new
elements
of
that
particular
currency,
that
particular
token
non-fungible
or
fungible
token
dean.
Can
you
we
have
a
question
that
what's
the
primary
difference
between
a
person,
mint
yeah,
that
was
what
I
just
answered.
Yes,
thank
you.
A
Great
okay,
so
actually
I
conveniently
have
another
screen
here
with
these
with
these
chat
windows
up.
So
so
you
please
do
break
in,
as
you
see
any
and
I'll
try
and
know
when
I'm
answering
questions.
Okay,
so
we're
going
to
talk
about
a
bunch
of
d5
legos,
you
know
the
two
columns
here
there
are
more-
and
this
is
you
know
this
is
just
the
start.
A
The
more
are
the
ones
that
that
that,
hopefully
you
all
build,
but
the
first
four
are
already
covered
by
your
ertp
they're,
the
fundamental
glue,
the
electronic
rights
transfer
protocol
elements.
So
the
purses
are
just
you
know.
I
can
have
a
purse
object
and
I
can
hand
it
to
you.
That
is
the
thing
that
my
wallet
deals
in
is
it
has
a
collection
of
purses
for
different
currencies
that
I
can
put
things
into
payments?
A
You
do
the
linear
transfer
of
fungible
and
non-fungible
tokens
underneath
and
then
functional
and
non-fungible
tokens
they're,
just
automatically
supported
by
the
existing
mint
infrastructure
and
I'll,
be
showing
you
how
that's
created,
but
it's
pretty
much
a
one-liner
to
add
your
own
currency,
so
every
dap
under
the
sun
that
you
know
that
needs
a
liquidity.
Token
they'll
end
up.
Having
a
make
me
a
mint.
Now
I
can
mint
out
liquidity
tokens
or
or
nfts.
I
can
mint
those
up
and
then
finally
we'll
dive
into
the
other.
A
The
so
everything
that's
not
in
bold
on
this
slide
is
a
smart
contract
implemented
using
ertp
using
those
those
those
four
elements
there
and
the
ones
that
I
showed
you
in
the
screen
and
then
using
our
smart
contract
framework
I'll
be
diving
in
in
into
the
ones
on
the
left,
the
faucet,
the
otc
desk
and
the
covered
call
and
showing
how
they
work
and
how
they
wire
together.
All
these
different
elements:
okay,
so
we're
going
to
dive
into
some
contract
code.
A
Here
there
is
a
new
you
know,
so
so
in
the
prep.
For
this,
for
this
workshop
was
a
link
to
the
getting
started
with
alpha
and
that
showed
how
to
get
your
world
prepared,
where
you've
got
a
command
line,
where
you
can
issue
the
agora
commands
and
then
and
then
we're
going
to
go
through
the
steps
of
this
particular
dap,
the
the
the
fungible
faucet
so
now,
first
off
I'm
going
to
jump
over
to
another
workspace
here.
A
My
question
is:
can
you
see
this
other
workspace
or
not,
or
are
you
still
seeing
the
presentation
slide?
Santi,
you
can
see
the
other
workspace
great.
That
means
I
can
hop
around
between
workspaces,
which
will
make
life
a
little
bit
easier,
all
right.
So
what
I'm
going
to
do
is
I'm
going
to
go
ahead
and
go
into
a
directory,
so
so
I
have
up
here
the
instructions
that
I
just
described
on
that
link.
A
A
Oh
sorry,
I
need
to
go
into
workshop
now.
I'm
gonna
do
that
again.
Okay,
so
it
is
going
to
just
like.
With
with
other
example
syste.
You
know
other
systems
with
templates
it's
going
to
create
a
new
directory
based
on
that
command.
Just
so
you
can
read
the
command
here,
agorak
init
and
it
grabs
as
a
template
that
fungible
faucet
and
makes
the
directory
my
fungible
faucet.
So
I'm
now
going
to
cd
into
my
fungible
faucet
and
what
you
can
see
here
is.
I
got
a
directory
tree
here.
A
That
has
a
contract
subdirectory
with
an
initial
smart
contract,
an
api
subdirectory
with
a
cloud
application
server
to
be
able
to
connect
to
this
smart
contract,
any
ui
sub
directory
with
a
with
a
a
page
to
be
a
with,
with
a
user
interface,
to
be
able
to
interact
with
this
smart
contract
right.
If
what
you're
building
is
adapt,
you
might
have
all
three
of
these,
and
so
this
is
an
example,
smart
contract
that
has
all
three
of
them
wired
together
and
it's
very
simple.
A
A
Agoric
is
the
command
that,
if
that
that
is
used
for
you
know,
I'm
going
to
go
ahead
and
make
this
bigger,
so
the
so
the
text
is
it
is
readable
here
is:
is
the
command?
Is
the
command
line
tool
for
for
being
able
to
manage
the
development
environment
here?
So
if
I
go
to
work,
install
that's
going
to
connect
to
my
already
deployed.
You
know
my
my
algorithms,
my
gork
sdk
installation.
A
It's
going
to
leverage
libraries
that
were
already
built
and
installed
there
following
the
the
getting
started,
preparation
steps
in
the
links
previously,
let
me
grab
these
instructions.
I
will
then
agoric
start
reset,
and
what
that
will
be
doing
is
that
will
actually
launch
a
simulated
chain
here
so
that
you
know
it
so
that
I
can
deploy
debug
iterate
with
interact
with
chains
running
locally
on
this
machine,
and
I
can
no,
I
can
see
the
zoom
chat,
but
I
can
no
longer
see
discord
here.
A
So
all
right,
the
install
takes
a
minute
here
and
then
what
I
will
do
is
I'm
going
to
deploy
the
two
contracts.
So
if
I
go
to
one
of
these
windows,
I'm
going
to
go,
let
me
get
them
to
the
right
to
the
right
place
here.
So
cd,
cd
to
dev,
slash
workshop,
slash
my
fungible
faucet
and
I'm
going
to
bring
up
vs
code
all
right.
So
I
have
now
done
this
installation
here.
I'm
now
going
to
start
the
chain
in
the
empty
state.
That's
what
the
reset
does.
A
Okay
and
now
the
the
chain
has
started,
I
will
go
to
you
know
following
the
the
instructions
here.
I
will
now
go
to
another
window
and
I'm
going
to
deploy
the
the
I'm
going
to
deploy
the
contract
to
the
chain
and
then
I'm
going
to
deploy
the
api
to
the
server.
So
what
I've
instantiated
here
is
I've
got
a
chain
running
and
I've
got
and
I
effectively
have
a
separate
environment
that
represents
the
cloud
environment
to
which
the
api
server
will
be
deployed.
A
A
And
go
to
the
ui,
and
now
I'm
just
starting
the
react.
The
normal
react
development
environment
right.
So
that's
starting
up
the
react
server
so
that
I
can
actually
run
an
app
on
this
server.
Okay,
and
so
let
me
just
open
a
new
browser
here,
and
this
is
now
the
application
that
is
the
fungible
faucet
okay.
A
A
Okay,
where
was
I
oh
yeah,
so
I
was
bringing
up
the
wallet
here.
We
go
so
in
in
a
normal,
in
a
normal
application
or
in
in
a
normal
platform.
You
would
be
able
to.
This
would
happen
automatically
right.
So
so
it
would
come
up
when
you
said
aguero
all
right,
so
you
can
see
the
app
on
the
right.
You
can
see
my
wallet
on
the
left
and
what
has
appeared
in
the
wallet
is
the
mention
of
that
app.
That
wants
to
connect
right
now.
A
I
have
not
given
the
app
the
app
permission,
so
it
can't
see
anything
in
the
wallet
it
can't
get
any
of
the
assets
and
it
claims
that
it
wants
to
be
called
fungible
faucet.
I
will
now
enable
that
app
and-
and
so
now
it
can
talk
to
it
now
the
app
can
talk
to
it
and
you
can
see
that
it
is
that
up
here
in
the
upper
right
it
is
connected
to
the
wallet.
A
The
only
thing
I
can
do
in
this
app
is
mint
some
fungible
tokens
right,
so
I'm
going
to
mint
fungible
tokens
and
what
that
did
is
that
sent
and
and
I'll
go
into
the
mechanics
of
this
that
sent
an
offer
to
the
user
right
and
the
offer
to
the
user
is.
Is
you
know
the
offer
that
sends
an
offer
to
the
user
in
the
wallet
for
the
user
to
approve
sending
it
to
the
contract?
So
it's
not
that
the
user
interface
got
to
act
on
behalf
of
the
user.
It
got
to
propose
to
the
user.
A
Here's
a
thing
that
in
my
application
you
chose
to
maybe
want
to
do.
Did
you
want
to
approve
that
or
decline?
And
so
in
this
case
the
fungible
faucet
instance
running
on
port
3000
over
here
said:
go
ask
the
app
for
a
thousand
fungible
tokens
and
see
if
you
get
them
right,
so
I'm
not
paying
them
anything.
It's
not
an
exchange
in
an
interesting
fashion.
In
this
case,
we're
just
gonna
go
ask
for
some
money
out
of
the
faucet
and
I
say
yeah.
A
But
but
here
I
have
the
one
for
getting
the
fungible
tokens
from
this
from
this
faucet
dap
and
I
will
say,
accept
and
what
happens
is
you
can
see
here?
The
fungible
dapp
said
the
wallet
said
I've
offered
I've
completed
the
offer
the
fungible
dap
said:
I've
sent
you
a
thousand
tokens,
and
indeed,
as
soon
as
I
let
my
browser
proceed,
you
will
see
that
a
thousand
tokens
appeared
in
my
in
my
wallet
in
in
my
in
my
wallet
in
the
purse
that
takes
fungible
tokens
right.
I
could.
A
I
could
do
that
again.
I
would
get
exactly
the
same
interaction
or
I
could
accept
that
offer,
and
now
I've
got
two
thousand
right,
so
it's
just
a
very
simple
application
for
requesting
money.
In
this
token
type
and
tomorrow,
it'll
have
another
wrinkle
on
it.
Where
we
will
add
the
ability
to
then
buy
things
with
that
token,
I'm
going
to
show
you
that
kind
of
thing
in
another
application.
Okay,
so
we're
going
to
now
we're
going
to
now
dig
into
some
of
these
code.
These
things
after
I
first
hit
a
couple
of
more
concepts
here.
A
A
You
know
where,
where
the
thing
that's
weird
about
this
is
yeah,
it's
all
about
this
number
down
below
and
that's
true
in
cosmos
as
well.
It's
true
in
all
of
these
various
systems.
Where
I'm
sending
money
to
my
good
friend,
you
know
1g
hkm
right,
that's
not
how
businesses
work!
That's
not
how
humans
actually
like
to
do
trade.
A
I'm
going
to
make
an
offer
right,
I'm
going
to
say
I
will
provide
3000
lula
from
my
savings
account.
If
you
give
me
back,
2
000
or
I'm
going
to
provide
30
quat
lose.
If
you
give
me
back
a
concert
ticket
right
and
the
infrastructure
of
our
smart
contract
system
and
the
infrastructure
of
our
wallet
honors
that
directly
right.
So
what
happens
is
let's
say,
I'm
bidding
in
an
auction
for
a
concert
ticket
right?
Oh,
yes,
that's
that's!
That's
the
thing
that
happens
right
is.
A
I
will
pay
this
much
money
in
order
to
receive
that
much
those
much
goods
right.
So
I
I
will
give
you
one
thing
and
I
want
another
in
return.
Okay,
and
so
we
have
this
pervasively
in
the
framework
for
smart
contracts.
That
is
built
above
ertp,
where,
in
that
scenario,
where
there's
an
auction
for
a
concert
ticket,
the
seller
is
just
making
an
offer.
That
says
I'll
I'll
offer
someone.
I
will
give
this
concert
ticket,
but
what
I
want
in
exchange
is
at
least
xmula,
okay
and
the
buyers
in
this
auction
they
say.
A
Well,
I
will
offer
you
at
most.
Why
mula
and
what
I
want
in
exchange
is
a
concert
ticket
and
you
know,
as
I
showed
you
with
the
assets
and
the
ertp
and
the
and
the
issuers,
I
can
be
much
more
specific.
I
want
a
concert
ticket
in
seat
thus
and
such
at
a
particular
date
at
this
venue
right
and
so
that
structure
of
of
amounts
lets
me
describe
here's
exactly
what
I
want.
Here's
exactly
what
I'm
willing
to
give
you
and
what
and
and
what
the
zoe
contract
infrastructure
does
is.
A
It
will
take
those
offered
assets,
it
will
escrow
them
asynchronously
behind
the
scenes
in
the
contract
infrastructure
and
then
invoke
the
contract,
and
so
that
means
the
contract
is
running
knowing
that
the
assets
are
available,
but
not
in
the
position
to
steal
them
or
do
something
bad
with
them.
The
only
thing
it
can
do
is
reallocate
who
has
what
in
a
way
that
satisfies
their
requirements.
A
So
in
the
case
of
this
auction
right,
it
can
reallocate
the
concert
ticket
to
the
highest
bidder
and
the
money
from
the
highest
bidder
to
the
seller
of
the
concert
ticket
and
that's
a
reallocation
that
happens
atomically
and
safely
and
only
succeeds
if
it
meets
these.
I
want
x
for
no
more
than
why
if
it
meets
the
constraints
on
the
offers
that
the
participants
in
the
contract
provide
okay.
Now
in
that
per
in
that
faucet
example,
the
only
constraint
was
you
know,
this
offer
will
succeed.
A
And
offer
safety
to
the
clients
is
that
they
will
get
their
desired
payout,
the
concert
ticket
or
a
refund
of
their
money,
the
quatloos
or
mula
or
whatever
currency
it
happens
to
use
for
that.
For
that
exchange,
regardless
of
the
behavior
of
the
contract,
it
doesn't
matter
whether
it
was
buggy.
It
doesn't
matter
whether
it
was
malicious
or
on
purpose.
It
doesn't
matter
whether
it
was
upgraded
to
have
smarter
behavior.
A
Nothing
that,
because
that
the
auction
can
do,
can
cause
someone
who,
who
was
a
losing
bidder
who
did
not
get
the
concert
ticket
to
not
be
able
to
get
their
money
back.
The
only
way
that
the
auction
can
get
the
money
from
a
bidder
is
if
they
provide
the
requirements
of
the
bidder,
which
is
a
contra
ticket
on
the
other
side.
A
A
But
the
client
side
of
that
starts
with
an
invitation.
I've
got
an
auction.
You
are
invited
to
take
a
seat
at
the
table
to
participate
in
this
auction.
So
you
have
an
invite
that
you
got
through
various
mechanisms
and
there's
then
it
depends
on
the
dap.
In
this
case,
behind
the
scenes
I
went
to
the
website,
it
has
a
service
that
can
just
provide
me
an
information
to
get
money
from
the
faucet
right
or
I've
got
a
website.
You
know
that
I've
got
an
application
that
gives
me
an
information
to
bid
for
a
concert
ticket.
A
A
I
want
that's
the
on
demand,
which
is
the
default
case,
but
I
just
put
it
in
here
because
we'll
be
talking
about
an
over-the-counter
trading
desk
and
covered
calls
where
I
might
actually
have
to
in
order
to
place
a
bid
be
able
to
say-
and
my
offer
is
good
until
next
thursday
right
and
so
the
the
this
is.
What
what,
under
what
circumstances?
Can
I
demand
my
money
back
and
have
the
contract
infrastructure
deliver
it
to
me,
independent
of
the
behavior
of
the
contract
right?
A
Okay,
so
a
proposal
is
here's
what
I
want:
here's,
what
I'm
willing
to
give
for
it
and
here's
here's
how
I
get
my
money
back
or
when
I
can
get
my
money
back
and
then
there's
the
payment
of
assets,
of
course
that
correspond
to
here's
what
I'm
willing
to
give
for
it.
So
I'm
just
gonna
withdraw
the
same
amount
of
mullah.
So
now
I've
got
a
payment
for
100
mulla
that
corresponds
to
the
price
that
I
described.
I
was
willing
to
pay
and
then
I
asked
zoe
I
say:
okay,
here's
an
offer!
Here's
the
invitation!
A
Here's
the
proposal,
here's
the
payment
that
together
makes
up
an
offer
and
what
I
get
back
is
my
seat
at
the
table
to
be
able
to
see.
What's
going
on
track,
the
offer
change.
The
state
demand
my
payouts
exit
completely
all
the
kinds
of
things
that
I
need
to
be
able
to
interact
with
that
dynamically.
A
While
a
long-lived
offer
is
outstanding
is
my:
what's
called
the
user
seat?
Okay
and
that's
what
the
client
gets
to
be
able
to
interact
with
their
stuff,
including
you
know,
most
importantly,
being
able
to
get
their
payouts
when
it's
all
done
so
once
the
auction
is
completed,
it'll
it
it'll
be
exited
and
the
the
client
will
get
their
payouts
standard
javascript.
They
can
await
their
payouts
and
then
deposit
it
somewhere
or
whatever.
Now
all
this
is
the
mechanic
if
I
was
doing
it
programmatically.
A
Obviously,
the
wallet
is
doing
some
of
this.
For
me,
where,
when
I
said,
here's
an
offer
great,
I
will
say:
here's
where
I
want
the
payouts
to
go
when
you
finally
get
them
approve
that
offer,
send
it
off
to
the
contract,
and
so
the
wallet
is
the
one
that
takes.
That
proposal
pulls
the
money
out
of
the
out
of
the
purses
and
sends
off
the
offer,
and
so
the
the
contract
at
the
other
end
gets
the
offer
okay.
So
before
we
dive
into
the
next
contract.
A
Let's
now
look
at
what
some
of
that
code
looks
like,
so
that
that's
you
know
back
to
the
the
the
interaction
that
happened.
When
I
said
I
want
some
tokens,
it
made
an
offer
that
was
this
one-sided
offer
of
of
you
know
I
want
something,
but
I'm
not
giving
you
anything.
So
I
we
just
don't
bother
to
show
the
git
right
okay.
So
what
does
that
code?
A
Look
like
well
remember,
I
said
we'll
just
bring
up
vs
code,
let's
see
what
let's
see
what
happened
with
that
it
might
have
gone
to
the
other,
the
other
machine.
Yes,
it
did.
Let
me
let
me
move
that
over
here.
Actually,
you
know
what
I'll
just
pop
it
up
here.
Okay,
so
I
showed
you
the
fungible
faucet,
I'm
just
going
to
dive
into
the
contract
here,
which
has
you
know,
excuse
me,
which
does
have
test
codes
now.
One
of
the
important
things
is
this
is
just
javascript
right.
So
here
is
the
contract
code.
A
Good,
so
the
contract
is
just
a
javascript
module.
It
contains
a
single
function
called
start
for
starting
the
contract.
That
takes
us
an
argument,
access
to
the
the
zoe
contract
facet.
It's
called
that's
that's!
The
inside
of
a
contract
box
is
the
thing
to
be
for
for
the
contract
to
be
able
to
talk
about
the
state
of
all
offers
outstanding
to
the
contract,
do
its
reallocates
to
assign
the
concert
ticket
to
the
winner
and
the
money
to
the
to
the
seller.
That
kind
of
thing
okay.
So
the
first
thing
this
concert
this
sorry.
A
This
is
the
faucet
right.
The
first
thing
it
does
is:
it
creates
a
mint
for
minting
those
tokens
minting
the
tokens
you're
going
to
be
able
to
demand
for
free
from
the
faucet.
This
could
have
been
constructed
to
take
a
minute
that
was
provided
from
outside.
In
this
case,
we
wanted
to
show
you
here's
how
you
know
this
is
all
it
takes
to
create
a
minute.
A
There's
one
more
argument:
if
you
want
to
create
a
mint
for
non-fungible
token,
to
define
the
the
the
you
know,
whether
it's
separate
strings
or
whether
it's
a
javascript
structure
to
describe
it
to
describe
amounts
or
what
have
you
but
but
but
you
know
fundamentally,
that's
all
you
do
now.
I
get
what
a
a
mint
object
that
has
the
ability
to
mint
new
tokens
associated
with
this
particular
mint,
and
this
has
the
set
of
elements
that
go
into
this
issuer
kit
that
I
mentioned
so
I
can
get
from
it.
A
The
issuer
that
lets
me
verify
that
you
know
the
issuer
that
I
can
hand
out
generally
and
make
generally
public.
So
anyone
that
I
want
to
be
able
to
recognize
my
tokens
can
use
the
issuer
with
a
java.
Javascript
object
and
say:
are
you
a
payment
for
those
for
those
kinds
of
tokens?
If
so,
give
me
exclusive
access
right
and
if
not
fail
right,
and
so
that's
the
issue
or
that's
the
verifier
side,
you
know
or
the
the
signing
key.
A
You
know
the
verification
key
to
correspond
to
the
mint
signing
key
if
you
will
and
then
the
amount
math.
If
you
know
people
are
familiar
with
javascript,
when
you
want
to
do
anything
beyond
plus
minus
and
times
you
use,
you
know
the
the
math
object
in
the
normal
javascript
name
space.
We
have
a
similar
kind
of
thing
for
amounts
to
be
able
to
do
interesting,
math
on
amounts.
A
So
I
can,
you
know,
take
two
sets
of
seats
at
a
concert
venue
and
combine
them
together
where
I
can
check
whether
the
one
you
gave
me
is
in
that
set
or
those
kinds
of
things,
or
I
can
add
two.
You
know
amounts
of
simoleons
and
get
another
pile
of
somalians.
So
that's
just
you
know
simple
math
abstractions
and
the
fundamental
action
this
this
contract
has
to
take
is
to
mint
a
payment
right.
That's
the
main
thing
that
happens.
Is
it
mints
a
payment?
A
A
A
Okay,
so
the
first
step,
as
I
showed
in
the
in
the
slide
before
is
the
the
the
client
gets
an
invitation.
The
invitation
is
associated
with,
with
with
a
particular
offer
handler
inside
the
client
and
I'll
show
you
how
that
happens.
So
this
offer
handler
will
be
invoked
when
someone
says
hey,
I'm
in
a
faucet.
Please
give
me
something
the
argument
here.
This
seat
is
the
internal
seat
that
allows
the
contract
to
talk
about
the
offer
position
from
the
contracts
perspective,
so
the
user
seat
is
the
seat.
A
A
This
is,
you
know,
clever,
javascript
formatting,
it's
just
straightforward
javascript,
where,
when
I
created
this
min
function,
I
said
I
wanted
a
mint
function
to
be
able
to
create
mint
payment
for
a
thousand
a
thousand
simoleons,
and
so
here
this
is
going
to
get
it.
You
know
a
thousand
is
the
number
it's
going
to
use
the
amount
math
to
make
the
the
amount
description.
That
says
not
a
thousand
which
has
no
units,
and
you
know
lots
of
systems
that
deal
in
just
numbers.
A
I
mean
plenty
of
ethereum
bugs
it's
not
just
ethereum
bugs,
but
when
you
know
brokerage
houses
are
first
going
electronic
and
moving
on
to
the
internet.
Every
single
one
of
them
had
a
bug
where
something
that
was
supposed
to
be.
You
know,
shares
instead
got
got
sent
us
dollars
and
suddenly
you
had
a
corruption
in
the
user's
account
reporting
so
having
raw
numbers
as
a
thing
that
you're
computing
financial
stuff-
that's
well
known
in
the
financial
industry
as
being
a
bad
idea.
A
If
you
can
avoid
it
and
so
amounts
really
wrap
that
up,
where
no
no
we're
not
going
to
pass
around
a
thousand
we're
going
to
pass
around
a
thousand
simoleons
and
that's
what
we're
doing
math
about,
and
you
cannot
add
a
thousand
simoleons
to
a
thousand
concert
tickets
and
get
a
coherent
number
that
doesn't
make
that's
a
bad
idea.
You
want
your
system
to
stop
you
from
doing
that
right.
A
So
this
produces
an
amount
that
is
a
thousand
mula
in
this
case
and
then
the
mint
operation
here
there's
a
couple
of
different
mint
operations.
This
internal
mint
mints
it
directly
to
the
seat.
So
this
is,
I
don't
want
to
create
the
payment
and
then
have
to
go
deposit
the
payment
and
do
all
that
sort
of
stuff.
I'm
just
saying
you
know
on
that
seat
that
came
in
the
the
the
offer
state
the
set
of
the
set
of
assets
associated
with
that
offer.
A
A
A
So
here
the
creator
facet
is,
you
know,
facet
is,
you
know
an
object
of
a
multifaceted
thing,
but
it's
just
sort
of
one
object.
The
creator
facet
is
the
object
that
the
creator
of
the
faucet
is
going
to
have
access
to
to
get
everything
set
up,
and
so
what
the
creator
of
the
faucet
will
be
able
to
do
is
make
an
invitation.
A
Oh
yes,
I
will
talk
about
that
in
just
a
moment,
so
so
they'll
make
an
invitation.
So
indeed
you
know
back
to
to
one
of
the
things
about
this
being
in
vs
code,
this
being
able
to
use
familiar
tools
right.
If
I
hover
over
this,
you
can
see
that
it's
got
the
typescript
types.
So
behind
the
scenes
we
have
all
the
typing
to
be
able
to
do.
You
know
easy
easy
complete.
A
If
I
just
you
know,
go
here
and
get
rid
of
this
and
say
dot,
you
know
what
are
the
operations
I
have
available
to
me.
You
know
I
can
do
the
various
things
or
start
typing
and
it
does
all
the
normal
kind
of
developer
experience
that
you
would
expect
in
the
outside
world,
doing
fintech
or
other
applications
we
provide.
We
bring
the
same
thing
into
into
being
able
to
build
smart
contracts,
and
so
this
is
standard
javascript
with
all
the
standard
tools.
A
A
It's
a
standard
kind
of
test
that
you
get
with
with
tdd
systems
that
it's
going
to
go
through
that
state
of
launch
the
contract
instantiate
an
instance
make
an
invitation
make
an
offer
check.
All
of
the
results
do
some
assertions
at
the
end
right
so
standard
unit,
test
frameworks,
ci
automation,
all
those
kinds
of
things
work
in
these
frameworks.
A
Okay,
so
going
back
for
my
contract,
the
thing
that
the
creator
of
the
faucet
needs
to
be
able
to
do
is
make
invitations
and
then
check
that
it
got
and
get
the
issuer
to
be
able
to
publish
it
so
that
it
can
enable
people
to
be
able
to
verify
that
they
actually
got
the
tokens
that
this
contract
is
proposing
to
produce
for
them
and
so
that
make
invitation
operation.
It's
the
thing.
A
That's
invoking
this
mint
payment
to
to
default
to,
without
you
know,
to
to
to
setting
setting
the
amount
that
you
get
from
the
faucet
to
be
a
thousand
small
answer
or
a
thousand
tokens.
Rather
so
it
then
calls
zoe
calls
the
zoe
internal
facet,
this
zcf
zoe
contract
facet
to
say
make
me
an
invitation
where
the
handler
is
mint
payment.
For
that
extent
right,
so
the
handler
is
going
to
be
this
handler
up
here.
So
when
anyone
makes
an
offer
using
that
invitation,
this
is
the
code
that
will
be
at
this.
A
This
is
the
code
that
will
be
executed
this
this
mint
payment.
Underneath
so
that's
the
wiring
that
happens,
then
some
then
then
we
have
the
additional
wrinkle
that
anyone
in
the
system
ought
to
be
able
to
just
find
out
get
an
issuer
so
that
they
can
verify
that
the
the
particular
tokens
are
what
they're
supposed
to
be.
A
I
see
that
dan.
Thank
you
for
your
excitement.
We
loved
it.
It
was
so
exciting
when
types
got
working
in
the
system
being
able
to
do
this
sort
of
thing
and-
and
you
know,
check
oh
that
returns
an
issuer.
Oh
you
know
what
what
what
does
that
take?
You
know
what
is
you
know?
What
am
I
supposed
to
return
from
this
function,
all
those
kinds
of
things
just
huge
huge,
huge
step
up
in
developer
experience.
A
Okay,
so
there
are
two
things
that
are
being
returned
from
this
from
this
from
create
from
the
start
function
here
right.
The
start
function
is
this
entire
contract
and
it's
going
to
return
a
record
that
has
multiple
different
things
in
this
particular
contract.
It
has
an
object
that
the
owner,
the
creator
of
this
faucet,
is
allowed
to
manage
in
order
to
get,
invites
and
decide
who's
allowed
to
tap
the
faucet
and
something
for
the
public
that
anyone
in
the
system.
A
Anyone
anyone
on
the
chain
is
able
to
look
at
in
order
to
be
able
to
verify
that
the
tokens
that
they
got
from
something
from
from
some
process
are
the
tokens
that
this
faucet
produced,
and
so
these
are
these
two
objects
one
is
I
can
make.
The
creator
can
make
an
invitation,
and
anyone
on
the
on
the
chain
can
get
the
issuer
to
be
able
to
verify
or
claim
assets
from
this
fossil.
Okay.
A
So
that's
the
entirety
of
this
contract
right
and
then
the
ui
just
pulls
it
all
together,
that's
the
whole,
that's
the
whole
fossa,
okay
and
then
you
can.
You
know
you
can
dig
yourself
into
the
ui
directories
in
the
api
directories,
we'll
be
talking
more
about
that
at
a
workshop
tomorrow,
but
I
want
to
move
on
to
other
contracts.
A
So
let
me
see
where
we're
at
on
our
presentation:
let's
now
move
to
the
next
contract
on
our
list,
the
otc
contract.
Okay.
So
if
I
go
to
the
now
in
this
case,
I'm
not
whoops.
Let
me
stop
here
in
this
case,
I'm
not
going
to
go
to
the
otc,
I'm
not
going
to
reinstall
it.
I'm
just
going
to
navigate
to
it
in
that
in
that
in
that
window
I
had
over
here.
So
let
me
go.
A
A
And
you
can
see
kate
commenting
on
the
types
in
the
system.
Indeed,
you
know
the
the
the
up
here
in
my
imports
is
where
I
grabbed
the
exported
types
for
zoe
and
there
are
plenty
of
other
types
in
the
system
I
turned
on
to
on.
We
turned
on
typescript
checking
here
inside
of
this
javascript.
Now
I
will
note
there
are
reasons
why
we
specifically
code
in
javascript
but
want
typescript
as
a
helper
for
us
we
can
talk
about
that
later.
Okay,
how
am
I
doing
on
time?
A
Oh,
I
will
rush
through
this
and
I
apologize.
So
this
is
the
otc
desk.
An
otc
desk
is
you
know
the
creator
of
this
contract
has
the
ability
to
create
quotes
and
give
them
to
people
who
want
them.
So
this
is
like
an
automated
market
maker.
You
know
had
a
paper
about
destructuring
uniswap,
so
this
is
like
an
automated
market
maker,
but
with
an
off-chain
oracle
that
gets
to
decide
on
whatever
pricing
they
want
to
do
right.
So
over-the-counter
desks
have
been
doing
this
for
for
a
long
time.
A
If
I,
as
a
customer,
can
go
and
just
say,
give
me
a
quote
and
it's
a
better
quote
than
I
would
get
from
from
the
on-chain
amm
and
I
get
in
a
timely
fashion,
I'm
a
happy
camper
right,
it's
better
pricing
for
me
and
the
fact
that
they
did
some
magic
behind
the
scenes.
You
know
to
figure
out
a
price.
I
don't
care
as
long
as
it's
a
good
one.
So
this
is
the
contract
for
the
otc
desk
to
be
able
to
provide
those
quotes.
A
So
I
am
the
person
answering
the
phone
listening
to
skype
or,
more
likely
you
know,
there's
a
website
that
talks
to
my
my
service
that
says:
hey
I
want
to
sell.
You
know
a
thousand
of
these
tokens
from
the
faucet.
What
can
I
get
for
them?
You
know
what
can
I
you
know
and
I
want
to
sell
them
in
exchange
for
atoms.
What
can
I
you
know?
What?
What
price
are
you
giving?
A
A
You
know
tokens
for
atoms,
okay
and
the
main
thing
that
they
behave
that
they
write.
Remember.
The
creator
facet
is
what
the
creator
of
this
contract
is
able
to
do
and
the
main
thing
that
they're
able
to
do
well,
they
can
add
inventory.
I
won't
go
through
the
details
of
that
they
can
remove
inventory.
I
don't
go
to
details
of
that
and
they
can
make
a
quote.
A
Okay,
so
that's
the
main
business
is
I'm
going
to
make
a
quote
for
someone
they're
going
to
take
the
quote:
they
will
be
paid
their
quote
out
of
my
inventory
and
I
will
get
the
money
and
put
that
in
the
other
side
of
my
inventory.
So
if
I'm
trading
you
know
tokens
for
for
atoms,
then
I've
got
an
inventory
of
tokens
and
atoms
and
I'm
buying
and
selling
out
of
those
that's
the
job
of
a
market.
Okay.
So
how
does
this
make
quote
work?
A
Well,
in
this
case
you
know
I
could
claim
that
I'm
going
to
give
you
a
particular
price
and
then
you
come
back
and
want
to
buy
it
and
I
say
yeah
I
decided
not
to
well
that's
not
a
very
useful
market
maker.
That's
not
a
very
useful
quote
desk
for
you,
because
you
know
they
can
say
anything
they
want.
You
then
decide
not
to
buy
on
on
unit
swap
and
then
you
come
back
and
you
can't
and
your
quota
isn't
on.
So
what
do
we
do?
Instead?
A
A
You
know
apple
shares
from
you
any
time
before.
You
know.
100
apple
shares
from
you
anytime
before
next
week,
for
this
mini
right
and
that's
a
call
option.
It's
a
covered
call
option
if
the
contract
is
guaranteed
to
actually
have
the
apple
shares
in
it,
so
that
I
am
sure
that
I
will
get
them
now.
I
used
apple
shares,
that's
an
off-chain
asset,
let's
say
let's
say
in
this
case:
I'm
doing
a
quote.
I
said
I'm
doing
tokens
for
atoms.
A
So
what
I
want
is
I
want
to
get
a
covered
call
where,
if
I
pay
you
100
tokens,
you
will
give
me,
you
know
five
atoms,
okay
and
so
the
covered
call
only
is
covered
if
it
actually
internally
has
those
atoms
with
it
and
has
the
ability
for
me
to
exercise
to
be
able
to
pay
you
and
get
those
atoms
out,
and
then
you
get
the
the
amount
that
I
pay.
Okay,
so
that's
what
we're
gonna
do
and
the
nice
thing
about
that
is.
A
If
we
do
that
as
a
separate
contract
that
is
separately
reviewed
now
you
as
the
client
don't
need
to
know
anything
about
how
the
otc
desk
works.
You
don't
have
to
trust
the
otc
desk.
You
just
have
to
be
able
to
get
a
new
instance
of
that
covered
call
contract
and
be
able
to
trust
it.
Okay,
I'm
going
to
say
a
lot
more
about
that,
because
that's
the
most
powerful
composition
is
when
when,
in
fact,
in
this
case
it
was
kate,
sills
who's,
answering
questions
in
chat.
A
When
she
wrote
this
otc
desk
right,
she
was
able
to
write
it
where
she
can
do
anything
she
wanted.
As
long
as
once
a
quote
happens,
it's
in
the
form
of
this
already
existing
covered
call.
Now
no
one
needs
to
you
know
no
one
needs
to
understand
this
thing
and
she
got
to
build
it
using
that
other
piece
unchained,
it's
unchanged,
it's
not
that
she
copied
it
it's
that
she
got
to
use
it
unchanged.
Okay,
we're
going
to
go
a
little.
A
You
know
a
little
bit
over,
but
not
a
lot
over
so
so
I
will
try
and
get
through
the
the
main
point
here
and
then
you
and
and
then
get
you
to
the
next
slide
and
and
we'll
be
done.
Okay,
so
here
what's
happening,
is
it's
actually
going
to
start
an
instance
of
the
covered
call,
so
this
contract
doesn't
actually
care
what
the
implementation
of
covered
call
is.
That's
a
separate
contract,
but
it
was
created
when
this
contract
was
created.
A
The
creator
of
this
that
deployed
this
desk
said
here's
the
covered,
call
implementation
that
I'm
using
I'm
probably
going
to
use
the
standard
one
that
everyone
will
recognize
so
that
when
they,
when
they
receive
it
they're,
they
already
have
an
issuer
in
their
wallet
that
will
verify
and
go
yup.
That's
the
trusted
coverage
implementation,
that's
one
that
was
reviewed.
You
know
four
stars
on
on
on
contract
yelp,
whatever
it
is
right,
and
so
I'm
going
to
instantiate
a
brand
new
instance.
A
Just
for
this
quote
right,
and
that
means
it's
now
independent
of
all
the
other
quotes.
You
know
they
all
they're,
all
independent
of
each
other.
I'm
going
to
propose
to
it
that
I
will
give
the
assets
that
the
person
requested,
so
they
said
they
want.
You
know
five
atoms.
I
will
give
five
of
my
atoms
for
the
price
that
I'm
sorry,
the
quote.
Is
I'm
willing
to
give
them
five
atoms
for
the
amount
of
of
tokens
they
said
they
were
providing,
so
I'm
going
to
give
them.
That
quote.
So
I
provide
the
atoms.
A
I
provide
the
description
of
the
atoms.
I
say
my
proposal
is
yep.
I
will
give
you
five
atoms
for
for
your
hundred
tokens
and
it's
good
until
the
deadline
right.
So
I'm
saying-
and
this
quote
is
good
for
15
minutes.
If
you
don't
exercise
it
by,
then
it's
not
good
anymore,
and
I
get
the
and
I
get
all
the
money
back.
The
interesting
thing
is
this
is
different
from
that
on-demand
thing.
A
Where
the
quote
desk,
the
otc
desk
can't
just
get
its
money
back
at
any
time,
so
it
gives
you
one
and
then
site
pulls
the
assets
out.
No,
no,
it
has
committed
the
assets
until
this
deadline
is
over
and
that's
committed
in
a
way
that
you
as
the
customer,
can
actually
verify,
and
indeed
you
can
have
constructed
your
offer
so
that
so
that
you're
automatically
verifying
that
in
the
process
of
getting
the
quote
from
this
system.
Okay,
so
I
am
so
so
I'm
going
to
give
you
five
atoms
for
your
hundred
tokens.
A
You
can
exercise
at
any
time
in
the
next
15
minutes,
but
that
but
remember
these
are
just
the
description
of
five
atoms.
That's
like
telling
you
twenty
dollars
doesn't
mean.
I
gave
you
a
twenty
dollar
bill
right.
So
then
I
withdraw
from
the
market
maker
seat,
those
at
those
assets
right,
the
the
assets,
the
the
that
I
said,
the
five
atoms
I'm
going
to
draw
them
out
of
the
of
the
offer
seat,
and
then
I'm
going
to
go
ahead
and
make
that
offer
with
those
payments.
A
A
I'm
now
running
this,
but
again
standard
tool.
So
this
is
in
watch
mode.
It'll
run
the
test
once
oh
and
I
already
broke
it
somehow,
I'm
not
running
underneath,
never
mind
I
will
run.
I
will
run
it.
I
will
just
the
the
test
runs,
but
but
in
this
particular
instance,
I'm
not
set
up
to
be
able
to
run
it
iteratively.
A
A
A
You
know
there,
you
go
okay,
so
now
I'm
withdrawing
my
five
atoms
offering
them
to
this
brand
new
instantiated
cover
call
that
has
no
assets
in
it
and
saying
here's
the
stuff
that
are
the
you
know,
here's
here's!
What
I
want
you
to
do.
I
want
you
to
offer
my
assets
for
this
price
and
I
get
back
now
the
the
the
object,
if
you
will,
the
seat,
which
is
that
client
seat
for
the
covered,
call
I'm
now
going
to
return
that
client
seat
for
the
covered
call
as
the
result
of
this
quote.
A
So
the
quote
is
not
here's
a
number.
The
quote
is
not
you
know,
here's
something
you
could
do
and
maybe
I'll
honor-
and
maybe
I
won't
the
quote-
is
an
honest
to
god,
completely
independent
covered
call
instance
that
can
be
separately
verified
to
meet
the
covered,
call
implementation
for
a
customer
right
and
it
has
closed
in
it.
It
has
the
the
actual
atoms
that
the
that
the
covered
call
is
for
so
that
the
user
could
invoke
the
exercise
operation
in
order
to
see
those
atoms.
A
A
Another
visual
studio-
this
is
the
sdk
that
you
all
installed.
You
know
again
standard
tool,
so
I
can
go
to
covered
call
in
my
in
my
thing
there
are.
You
can
see
that
it
is
one
of
many
contracts
over
here
remember.
I
mentioned
the
several
other
contracts,
sell
items,
simple
exchange,
atomic
swap,
etc.
A
This
is
the
covered
call
implementation
and
it
has
you
know.
Fundamentally,
it
has
an
exercise.
You
know
it
has
an
operation
for
the
owner
of
the
covered
call
that
was
given
that
client
seat
to
be
able
to
exercise
the
option
and
they
exercise
the
option
by
providing
the
the
the
hundred
tokens
in
exchange,
they
will
get
an
exact
swap
of
the
hundred
tokens
for
the
five
atoms
underneath
and
this
covered
call
is,
you
know,
20
some
odd
lines
of
code
and
it
implements
that
in
a
way
where
it
can
be
reused
for
selling.
A
A
A
Okay,
so
now,
finally,
let
me
jump
back
so
what
we
got
and
wrapping
up
here
we
showed
on
the
client
side.
You
get
an
invitation.
You
make
a
proposal,
you
make
your
offer,
you
get
a
user
seat
back
and
finally,
you
get
some
payouts
and
the
net
payment
payoff
of
offer
safety
there
is
you
either
get
your
desired
payout
or
you're
guaranteed
to
get
a
refund
independent
misbehavior
of
the
contracts?
A
And
the
important
thing
is:
that's
not
just
at
the
wallet
level:
it's
not
just
at
the
user
level.
It
means
that
if
I
have
a
autonomous
portfolio
manager,
that
is
interacting
with
dynamic
markets
and
amms,
it
gets
the
same
offer.
Safety
and
so
you've
got
pervasive
improvement
in
the
safety
across
an
ecosystem
of
communicating
contracts,
which
means,
for
example,
our
stablecoin
implementation.
You
know
for
the
local
currency
of
our
of
our
of
the
chain.
We
will
be
rolling
out
next
year.
A
As
I
said
you,
you
have
the
pieces
where,
when
those
offer
come
in
comes
in
for
a
given
invitation,
it
will
evoke
invoke
a
particular
offer
handler
that
gives
it
a
zcf
seat
that
gives
it
access
to
the
state
and
execution
and
status
and
so
forth.
Of
the
current
of
the
current
offer
the
contract
can
reallocate
in
order
to
you
know,
make
multi-way
trades
between
several
different
parties,
so
a
barter
application
might
be
doing.
A
You
know
trades
of
his
chickens,
for
your
pigs,
for
his
goats,
right
and
and
and
and
so
you
can
have
multi-party
transactions
that
are
required
for,
for
example,
in
a
multiple
auto
swap
there
are
the
multiple
different
internal
seats
for
liquidity
pools.
There's
the
incoming
offer.
There
might
be
counterparties-
all
of
those
can
be
atomically
atomically
reallocated
at
once,
and
that
will
only
succeed
if
it
meets
the
offer
constraints
of
every
single
position
in
that
in
that
transaction
and
then
finally,
there's
exit
that
provides
those
payouts
that
the
clients
are
really
interested
in.
A
So
next
steps.
Please
share
your
feedback,
the
links
here.
We
we
will
paste
into
the
zoom
chat
whoops.
Sorry,
we
will
paste
into
the
zoom
chat
and
we
have
the
cosmos
d5
hackathon,
the
the
it's
called
hack,
atom.
Five
is
starting
actually
five
minutes
ago
there
will
be.
You
know
there
will
be
presentations.
There
will
be
a
wide
variety
of
of
platforms
to
build
on
we.