►
Description
Dive into DeFi on the Agoric smart contract platform. We will walk you through building an “over-the-counter” market maker. The example introduces the key concepts of safe smart contracts on Agoric, and shows how to combine DeFi legos to rapidly produce a new DeFi dapp.
HOST
Kate Sills – Software Engineer, Agoric
ABOUT COSMOS
Cosmos is an open, distributed network of interoperable blockchains powered by the Tendermint consensus algorithm.
LINKS
https://cosmos.network/
https://tendermint.com/
https://interchain.io/
Subscribe to the channel to learn more about Cosmos. Join the newsletter by visiting https://cosmos.network and hitting the subscribe button. Finally, read what it's all about at https://blog.cosmos.network/
A
A
So
what
do
I
mean
by
an
otc
desk
contract?
Well,
this
the
inspiration
for
this
was
a
medium
post
by
haseeb
qureshi
called
unbundling
uniswap,
and
it's
a
really
interesting
article.
I
highly
recommend
it.
I'm
going
to
focus
on
one
part
in
particular:
haseeb
outlines
a
design
for
what
he
calls
signature
based
pricing
and
effectively
it's
a
new
form
of
over-the-counter
or
otc
trading.
So
typically
in
the
world
outside
of
smart
contracts,
you
would
tell
the
desk
that
you
want
to
trade.
A
Let's
say
a
hundred
eth
for
usdc
and
the
desk
would
respond
with
the
price
and,
if
you
like,
the
price,
you
execute
the
trade
so
without
a
smart
contract,
you're
trusting
the
otc
desk
and
you're
signing
a
legally
binding
otc
agreement,
so
haseeb
had
the
following
idea
to
use
a
smart
contract.
Instead,
he
said
that
the
otc
desk
would
reserve
the
assets
on
chain
and
then
cryptographically
sign
a
quote
off
chain
and
give
it
to
you.
A
So
if
you
like,
the
quote,
you
can
submit
it
on
chain
to
the
smart
contract
which
verifies
the
signature
and
fills
the
order
at
that
exact
price
using
the
on
chain
reserves.
So
what
exactly?
Are
we
going
to
be
building
today?
Well,
we're
going
to
be
building
an
otc
desk
where
the
trades
are
atomic
and
quote
unquote
trustless,
so
you
don't
have
to
rely
on
the
otc
desk
right.
We
don't
have
to
rely
on
them
to
keep
their
promise.
A
A
A
It
can
also
stop
quoting
when
the
market
is
crazy,
so
something
like
uniswap
famously
provides
liquidity
at
all
times,
even
when
the
market's
going
crazy-
and
we
don't
actually
know
what
the
right
prices
are.
So
our
otc
desk
contract
is
going
to
allow
us
to
make
higher
profits
because
we're
going
to
be
able
to
stop
quoting
when
we
don't
know
what
the
price
should
be.
A
Let's
see,
so
our
otc
desk
contract
is
also
going
to
be
able
to
trade,
fungible
and
non-fungible
digital
assets,
and
this
is
actually
without
doing
anything
extra.
This
is
just
part
of
our
platform,
part
of
what
I'll
go
into
in
a
bit
the
ertp
layer,
which
is
our
token
layer,
and
it
also
uses
another
contract
which
is
our
covered,
call
option
contract
as
a
reusable
component.
A
A
A
On
top
of
that
we
have
the
gork
vm,
and
this
is
what
provides
the
distributed:
javascript,
runtime
environment.
So
all
of
our
smart
contracts
are
written
in
a
subset
of
javascript
and
you're,
going
to
see
some
some
interesting
ways
in
the
interesting
ways
that
we
make
calls
to
reflect
the
distributed
aspect
of
things.
So
there
are
some
things
where
the
objects
are
going
to
be
remote
to
where
we're
coding
and
we're
going
to
have
to
call
it
in
certain
ways.
A
A
See
my
screen
now
yeah
great,
so
let's
go
ahead
and
get
started.
I
am
going
to
assume
that
people
have
followed
the
getting
started
instructions
on
our
website
and
that
you
have
a
local
version
of
our
example.
Encouragement
app,
I'm
going
to
walk
through
a
little
bit
of
that,
but
mostly
I'm
going
to
assume
that.
So,
if
you
haven't
gotten
to
that
point,
please
head
over
to
our
website
agorik.com
and
go
to
the
documentation
page
and
it'll
show
you
how
to
get
started.
A
B
A
We're
going
to
be
working
on
specifically
the
contracts
today,
but
this
sampled
app
that
you're
given
has
a
front
end.
It
has
the
deploy
scripts.
It
has
everything
that
you
need
to
kind
of
get
your
dap
up
and
running,
but
we're
going
to
be
focusing
specifically
on
the
contracts
today.
So
let's
cd
into
the
contract
directory.
A
A
A
B
B
A
A
A
A
So
we
can
call
remote
objects
as
if
somewhat
as,
if
they
were
local,
without
having
to
use
any
different
api
without
having
to
use
any
different
messaging.
It
just
works,
so
I
can
call
a
method
on
this
remote
object.
As
long
as
I
use
this
e-notation
all
right,
so
first
we're
going
to
have
to
bundle
our
software.
B
B
B
A
So
in
in
ertp,
I'm
going
to
assume
here
that
people
have
read
a
little
bit
of
our
documentation,
but
I'll
try
to
explain
as
well
in
ertp
to
create
any
kind
of
digital
assets
you
have
to
hold.
This
object
called
a
mint
and
we're
going
to
create
that,
and
it
comes
as
part
of
this
kit
of
information
about
this
type
of
digital
asset.
So
there's
going
to
be
other
objects
in
there,
such
as
a
brand
which
specifies
the
type,
an
issuer
which
is
kind
of
the
publicly
accessible
facet
or
object.
A
B
A
B
A
A
B
A
A
We're
going
to
use
the
default
math
kind,
which
is
just
natural
numbers,
so
basically
what's
happening
here
under
the
hood-
is
that
for
ertp
to
know
how
to
deposit
things
in
purses
or
withdraw
things
from
purses,
it
needs
to
know
how
to
add
and
subtract
digital
assets,
and
that
may
vary
a
lot
based
on
what
kind
of
digital
asset
it
is
right.
So
if
it's
just
a
currency,
what
we're
dealing
with
is
just
natural
numbers,
so
the
value
of
mulla
might
be.
A
A
And
what
an
amount
is
is
kind
of
the
description.
It's
not
actually
the
value
itself,
so
an
amount
is
like
saying:
hey
I'll,
give
you
five
dollars
right
like
when
you
save
five
dollars
in
that
statement,
you're
not
actually
transferring
anything
you're
just
talking
about
it
right.
So
that's
what
an
amount
is,
and
so
that's
different
than
a
payment
in
our
system
which
actually
holds
value.
A
B
A
A
B
A
A
A
So
let's
go
ahead
and
create
a
small
test
here
that
will
just
show
that
we've
created
something
of
value.
So
what
we're
going
to
do
is
we're
going
to
use
the
magic
item
kit
issuer
to
confirm
the
payment
and
give
us
the
amount
back.
So
let's
just
confirm
that
the
amount
is
in
the
payment
is
the
same
as
what
we
meant.
So
this
is
a
dumb.
A
A
See
so
we're
going
to
be
using
zoe
for
this
we're
going
to
be
calling
start
instance,
which
is
the
way
to
take
the
code
that
we
have
installed
and
actually
create
a
smart
contract
instance.
Something
that's
running,
so
we
are
going
to
use
the
covered.
Call
installation
that
we
made
earlier
and
something
else
that
we're
going
to
do
is
add
the
issuers
to
this
contract.
A
B
A
Cannot
destructure
property
creator
facet
of
undefined
decide
is
undefined
all
right.
So
let's
go
back
to
our
smart
contract
and
all
of
the
smart
contracts.
They
must
have
this
particular
format.
They
must
have
the
start,
function,
that's
exported
and
that
start
function
takes
in
zcf,
which
is
the
what
we
call
the
contract
facet
side
of
zoe.
So
this
is
going
to
be
the
side
of
zoe
that
the
contract
has
access
to
that
it
can
call
methods
on
okay,
and
this
start
function
needs
to
return.
A
It
has
a
number
of
things
a
bit
can
return,
so
it
can
return
a
invitation
that
gets
sent
back
to
the
creator.
It
can
return
what
we
call
a
creator
facet,
which
is
an
object.
That's
kind
of
the
admin
object
that
gets
returned
to
the
creator
or
it
can
return
what
we
call
a
public
facet,
which
is
an
object.
That's
going
to
be
available
to
everyone.
B
A
A
A
We
are
going
to
get
a
creator
invitation
back,
so
this
is
so
alice
is
calling
start
instance
with
this
installation
right
with
the
actual
covered
call
code,
which
is
this
that
we
are
still
building
since
we
returned
a
creator
invitation
here.
It's
getting
sent
back
out
to
her
here
so,
let's
add
a
little
test
to
make
sure
that
this
is
actually
a
real
zoe
invitation.
So
this
zoe
invitation
is
effectively
an
ertp
payment
that
allows
you
to
join
a
contract,
so
I'll
go
over
that
again
in
a
bit.
B
A
Let's
actually
get
the
zoe
invitation
issuer
so
back
up
here
in
the
the
magic
item
kit.
In
the
moonlit
kit,
we
saw
that
the
issuer
was
part
of
those
kits
right,
so
the
issuer
is
a
thing
that
can
confirm
payments
for
us.
It
can
allow
us
to
claim
them
to
make
them
exclusively
ours.
It
can
do
a
large
number
of
things,
but
it's
basically
the
source
of
truth
of
whether
a
payment
has
value
or
purse
has
value.
A
B
A
A
B
A
A
A
B
A
A
And
a
deadline-
let's
say
the
deadline
is
two,
so
the
deadline
can
be
anything
that
the
timer
understands
so,
depending
on
the
timer,
it
could
be
block
height,
it
could
be,
could
be
some
kind
of
utc
time.
It
could
be,
could
be
anything
that
the
timer
understands
so
we're
agnostic
as
to
the
exact
format
of
that
it
really
depends
on
the
timer,
so,
let's
make
sure
to
actually
import
the
timer.
A
A
A
B
A
Let's
see
so,
we
have
successfully
given
back
the
offer
result
that
we
want,
but
not
much
is
happening
still
right,
okay,
so
what
we
actually
want
here
is
we
want
to
make
an
option
for
bob,
so
we're
going
to
create
an
invitation
specifically
for
bob.
So
actually
we
want
this
to
be
a
an
invitation
so.
B
A
A
A
A
B
A
Have,
let's
actually
do
a
trade
okay,
so
we've
we've
given
this
option
to
bob
and
it
has
this
exercise
option.
So,
let's
actually
so
the
the
offer
handler
it
has
a
seat
parameter
that
gets
passed
in
and
the
seat
is
effectively
the
position
in
the
contract.
So
when
alice
exercises
her
creator
invitation,
let's
call
that
the
celsi
and
when
bob
exercises
the
option
that
he
got.
A
A
A
A
A
B
A
A
A
A
B
B
B
A
Yeah
yeah,
that's
a
very
good
question,
so
there
actually
is
going
to
be
an
offer
on
both
sides.
If
bob
chooses
to
perform
the
trade,
so
he
he'll
get
this
option,
which
is
an
invite
to
join
the
contract
and
he
can
choose
not
to
join
the
contract,
but
he'll
still
have
that
option
as
a
as
a
zoe
invitation
and
simultaneously
an
ertp
payment
and
financial
digital
asset.
A
A
This
is
this
is
the
option,
so
he
has
the
opportunity
to
perform
to
be
part
of
this
trade,
but
not
the
obligation,
and
so
he
could
take
this
and
sell
this
to
someone
else
in
a
different
contract
which
is
really
cool.
It's
kind
of
we've
kind
of
got
inception
going
here.
One
layer
can
actually
feed
into
another
layer,
so
so
he
could
go
and
and
sell
this
or
he
can
use
it
to
perform
the
trade.
So,
just
to
test
the
contract,
we're
going
to
use
this
to
actually
perform
the
trade.
A
Were
there
any
other
questions?
Yes,
whether
the
deadline
is
optional,
so
normally
in
a
contract,
the
deadline
is
optional.
Currently
in
the
covered,
call
that
we're
about
to
build
we're
going
to
require
it,
and
I
can
show
you
how
to
require
it
in
the
code,
but
the
reason
why
we
want
to
require
why
we
want
to
require.
It
is
because
we
want
the
the
quote
to
not
be
good
forever
right.
A
So
prices
move
things
change
you
don't
want
to
be
making
quotes
that
are
always
going
to
be
good
right,
and
we
also.
We
also
don't
want
alice,
to
be
able
to
withdraw
her
assets
before
bob
makes
the
trade
right.
Then
then
it
wouldn't
it
wouldn't
be
a
trustworthy
contract
we'd
be
depending
on
alice
to
keep
her
promised
to
keep
the
assets
there
so
having
the
alice,
having
the
deadline
or
having
the
exit
rule
of
after
deadline
that
ensures
that
alice
cannot
withdraw
her
assets
until
after
the
deadline
has
passed.
A
B
A
Tests
cool-
they
are
passing
all
right,
so
bob
is
able
to
inspect
his
invitation
and
he's
able
to
see
that
alice
has
put
in
underlying
assets
that
are
of
the
particular
amount
of
this
magic
wand.
He's
able
to
see
that
the
amount
that
she's
requesting
the
strike
price
is
20
20mullah
and
he's
able
to
see
that
he
better
move
quickly,
because
the
deadline
is
at
time
2
according
to
this
timer.
A
A
B
A
And
one
thing
that
I
think
is
really
cool
about
how
we've
set
up
ertp
in
these
contracts
is
that
it
doesn't
matter
the
contract
doesn't
care
whether
it's
a
fungible
or
non-fungible
good.
It
treats
it
all
the
same,
because
we
have
the
amount
math
that
we
used
up
over
here,
that
we
created
as
part
of
the
the
issuer
kit
that
handles
all
of
the
arithmetic
and
the
calculations
for
us.
A
So
we
have
bob's
proposal
there
and
bob
can
actually
use
the
default
exit
rule,
but
I'll
put
it
in
here
anyways,
so
bob
connects
it
on
demand,
and
so
that
means
that
he
can
pull.
He
can
pull
out
his
assets
at
any
point.
He
can
exit
his
seat
at
any
point,
and
this
is
fine,
because
no
one's
relying
on
on
bob,
he
gets
in
the
option
the
opportunity
to
perform
this
trade,
but
no
obligation
to
all
right.
A
A
B
A
B
B
A
B
A
A
A
B
A
Yeah
yeah,
so
that
is
a
that
is
an
excellent
question,
yeah,
so
with
zen
zoe
there's
this
invitation
issuer
and
this
invitation
mint.
That
meant
the
invitation
so
back
when
we
called
zcf
make
invitation
that
was
under
the
hood
minting
invitations
minting
ertp
payments
that
zoe
knows
about
this
invitation
is.
A
A
A
A
A
B
B
B
A
Some
things
so,
rather
than
starting
with
a
creator
invitation
as
we
saw
before,
let's
actually
return
another
one
of
the
things
that
we
can
return,
which
is
a
creator
facet,
and
this
is
just
an
object-
that
the
creator
of
the
contract
instance
can
use
without
having
to
escrow
anything.
Yet
all
right-
and
this
is
just
a
plain
object.
So,
let's
just
fill.
A
B
A
A
Yeah
yeah
yeah.
This
is
where
the
legos
all
come
together:
okay,
so
so
now,
we've
installed
the
covered
call
and
the
otc
desk
contract
that
we're
still
building
so
and
let's
actually
use
the
same
items
that
we
used
before.
So
we
had,
we
created
the
mint
for
the
magical
items
for
non-fungible
magical
items
and
we
created
the
meant
for
the
fungible
tokens,
the
mula,
which
is
our
fake
currency,
and
we
had
these
specific
amounts
that
we
used.
So
we
had
this
magic
wand
amount.
A
So
alice
is
going
to
want
to
be
able
to
well
first
she's,
going
to
want
to
be
able
to
actually
make
a
contract
instance
of
the
otc
desk.
So
let's
go
ahead
and
do
that.
So
we
call
start
instance
with
our
otc
desk
installation
and
we
don't
need
to
put
in
any
issuers
actually.
So
let's
call
this
undefined
for
now
and
then
for
the
terms
we're
going
to
be
using
the
covered
call
contract
within
this.
So
let's
actually
pass
in
the
covered
call
installation
here.
A
A
second
so
again
we're
calling
this
method
on
zoe.
What
we
get
back,
we're
gonna
have
to
await
because
it's
a
promise
and
then
any
object
that
we
get
back.
That's
not
a
record.
That's
not
just
a
flat
flat
object
with
with
keys
and
non-function
values,
anything
that
we
get
back.
That's
actually
a
real
object
with
methods
that
actually
is
going
to
be
also
remote.
B
A
A
A
B
B
B
A
You
can
see
how
easy
it
is
to
mint
fungible
tokens
non-fungible
tokens.
It's
all
the
same
thing.
The
only
thing
that
changes
is
how
they
are
described
or
what
the
value
looks
like
all
right.
Okay,
so
this
is
alice's
inventory.
We
want
to
be
able
to
add
that
inventory,
so
we're
going
to
use
this
invitation
that
we
get
to
make
an
offer
so.
B
B
B
A
A
In
zcf,
before
we
start
adding
anything,
and
basically
what
this
is
doing
is
that
this
is
creating
a
local
amount
math
and
it's
saving
the
issuer
in
the
brand
to
zoe
so
that
it
knows
about
it.
So
then
anything
that
we
do
further
can
be
synchronous
we
don't
have
to.
Even
if
the
issuers
are
entirely
remote,
we
don't
have
to
make
any
remote
calls
when
it
comes
to
the
issuers
and
making
calculations.
A
B
B
B
A
The
future,
when
alice
makes
quotes
she
could
she
could
be
trading
magic
for
moolah.
She
could
be
trading
lula
for
magic.
She
can
add
more
inventory
and
trade
for
different
currencies.
We're
not
stuck
with
just
these
currencies
or
just
these
digital
assets,
all
right.
So
when
she
adds
her
inventory,
her
proposal
has
give
want
and
exit,
so
she
is
going
to
be
giving
magic.
A
B
A
One
thing
that
we
could
do
here,
so
this
is
kind
of
an
extra
thing
that
we
could
do
if
we
wanted
to
really
take
this
to
the
next
level
is
if
we
did
want
to
have
decentralized
inventory
collecting.
If
we
wanted
to
have
liquidity,
be
decentralized,
we
could
use
something
like
uniswap
does
here,
where
we
could
hand
out
invitations
to
add
inventory
and
then
give
back
tokens
representing
a
certain
percentage
of
the
capital,
a
certain
percentage
of
the
inventory,
but
we're
not
going
to
use
do
this
here.
A
We're
just
going
to
have
alice,
has
sole
ownership
of
all
of
the
inventory
and
she's
able
to
add
things,
and
it
just
gets
dropped
into
the
contract.
Okay,
so
we're
not
going
to
want
anything
and
the
exit
rule,
we
don't
care
about
either.
So
actually,
let's
take
both
of
those
out
and
just
use
the
default.
B
A
Right
now,
nothing
is
happening
right,
there's,
no
reallocation.
If
we
were
to
check
the
the
payouts
for
alice
exercising
this
invitation
for
for
making
this
offer
to
add
inventory,
she
would
just
get
her
stuff
back,
so
let's
actually
take
the
items
that
alice
adds
and
add
them
to
the
contract.
So
we're
going
to
do
something
a
little
bit
tricky
we're
going
to
create
an
internal
seat
just
for
this
contract
that
will
be
used
as
the
store
of
all
of
the
inventory.
A
A
A
A
A
A
A
A
B
B
B
A
B
A
Yeah
yeah-
that
is
a
very
good
question.
So,
as
you
can
see
in
in
this
we're,
not
wanting
anything
so
we're
not
really
checking
offer
safety
here.
But
what
we
are
able
to
do
is
we're
able
to
use
the
escrowing
capability
of
zoe
and
not
have
to
handle
that
within
the
contract
so
and-
and
that
is
really
nice,
because
we
would
have
to
somehow
maintain
purses
within
the
contract
that
escrowed
all
of
those
we'd
have
to
be
very
careful.
A
So
you
can
kind
of
think
of
it
as
I
like
to
think
of
it
as
almost
like
a
like
paypal
or
something,
if
we're
doing
if
we
were
doing
online
commerce,
so
zoe
is
handling
all
of
the
payments
for
us.
We
don't
have
to
worry
about
that,
but
that
does
mean
that
we
are
using
the
invitation
style
here
in
order
to
take
advantage
of
that.
B
B
A
B
A
A
B
A
A
All
right
cool,
so
we
got
the
creator
invitation.
We
want
to
actually
make
an
offer
so
we're
going
to
make
an
offer
in
the
same
way
that
alice
did
but
we're
going
to
make
it
from
within
this
contract.
So
we're
going
to
use
that
creator
invitation
we're
going
to
have
a
proposal
and
we're
going
to
have
payments
okay.
So
our
proposal
is
going
to
be
pretty
simple.
B
A
Okay,
so
this
is
going
to
be
very
similar
to
what
we
saw
alice
do
okay
and
then
for
the
payments,
we're
going
to
do
something
a
little
bit
tricky,
so
we
are
actually
going
to
be
taking
withdrawing
the
payments
from
the
market
maker
seat.
So
we're
going
to
use
a
special
helper
for
that,
we're
going
to
say,
withdraw
from
seat.
A
A
B
A
Is
this
is
something
that's
on
the
user
side
side
of
things
normally
we're
talking
about
zcf
seats
when
we're
within
the
contract.
We
have
more
documentation
on
that
on
our
website,
but
this
is
going
to
be
as
if
we
were
alice
as
if
this
was
alice's
scene.
Okay.
So
what
we
saw
previously
was
that
alice
as
her
offer
result
got
an
option.
So,
let's
just
take
that.
B
B
A
And
we
have
one
last
last
remaining
task
to
do
for
this
method,
so
when
alice
actually
or
when
the
otc
desk
performs
this
trade,
what
we
saw
in
when
we
tested
for
alice
was
that
she
actually
got
payouts
back
right.
So
what
we
want
to
do
is
take
those
payouts
and
put
them
back
into
the
market
maker
seat.
So.
A
B
A
B
A
A
A
B
B
B
A
Right,
so
just
to
recap
what
we
did
so
we
built
an
otc
desk
contract
that
uses
a
covered
call
under
the
hood
to
make
a
trade
between
alice
and
bob
such
that
bob
is
given
an
option
and
he
only
has
to
trust
the
covered
call
contract.
So
what
we
did
not
do
yet
was
actually
write
the
the
code
for
the
make
removed
inventory
invitation.
A
B
I
just
wanted
to
emphasize
that
that's
actually
spawning
an
entirely
new
contract
dynamically
inside
of
this
contract.
That
is
now
a
separate
process
that
can
be
separate,
or
I
mean
a
separate
running
thing
inside
of
the
chain
that
can
be
separately
inspected
and
confirmed
and
and
and
communicate
asynchronously
with
it.
This
could
be
launching
you
know,
arbitrarily
complicated,
interesting
network
of
other
contracts,
yep.
A
A
I
would
just
be
able
to
use
the
installation-
and
you
know
perhaps
bob
has
seen
it
before
in
the
past,
so
he
trusts
that
code,
and
I
don't
have
to
ask
bob
to
trust
me
for
anything
to
to
trust
the
code
that
I'm
writing
to
trust
that
I'm
going
to
have
the
assets
between
the
covered
call
code
and
zoe.
All
of
those
things
are
guaranteed.
A
All
right,
so
if
there
are
no
more
questions,
let's
go
ahead
and
finish
this
out.
I'm
going
to
start
on
the
make
remove
inventory
invitation,
so
it's
pretty
similar
to
the
make
ad
inventory
invitation
method,
but
we'll
go
ahead
and
do
that.
So
this
is
an
offer
hand
offer
handler.
So,
of
course
it
takes
in
a
seat
we're
going
to
want
to
return
a
invitation.
A
B
A
B
B
A
B
A
Yeah,
certain
areas
of
our
system
require
things
to
be
hardened,
so
that
will
that
will
definitely
decide
things
for
you.
We
are
working
on
making
it
so
that
the
hardening
happens
automatically,
so
you
wouldn't
have
to
actually
call
that,
but
that's
still
in
the
works
okay,
so
we
got
the
offer
result
that
we
wanted,
and
so
the
inventory
was
removed.
So
there
you
have
it.
A
We
have
built
our
our
otc
desk,
it's
able
to
add
inventory
it's
able
to
remove
inventory
and
it's
able,
most
importantly,
to
make
quotes
that
are
credible.
That
are
actually
the
covered
call
options
that
we
saw
before,
and
it
does
so
by
using
the
covered
call
installation
that
we
built
today
and
so
we're
actually
using
the
the
d5
components
in
a
composable
fashion,
and
I
think
this
is
really
exciting.
So
anyone
have
any
questions
before
we
close.
B
There
are
no
questions
in
the
in
the
king
in
the
in
the
in
the
chat
list,
though
I'll
keep
an
eye
out
here.
I
just
wanted
to
add
that,
of
course,
this
is
in
the
context
of
the
agorak
init
directory,
which
has
the
contract
that
that
she
was
editing
and,
of
course,
the
the
api
side
and
the
ui,
so
in
the
last
five
minutes,
she's
going
to
no.
B
A
B
A
B
Yep
and
the
the
code
for
this
I
posted
in
chat
pointers
to
the
code
inside
of
our
repository.
The
otc
desk
is
already
there
covered,
call
has
been
there
for
for
for
months
and
predates
ott
otc
desk
by
by
quite
a
long
time
and
had
been
previously
reviewed
and
and
used
in
other
purposes
so
well.
Thank
you
very
much
kate.
For
this.
This
was
really
really
useful
and
really
great
to
see.