►
From YouTube: Tutorial Part 1: Programming Smart Contracts with Zoe
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
B
Recording
all
right
so
last
time
we
said
we
are
going
to
cover
how
to
install
so
a
sketchbook
I
investigated
the
windows,
instructions
for
Kevin
and
Kevin
that
looks
pretty
difficult.
I
got
it
started
on
my
own
computer,
but
we're
gonna
have
to
I
think
have
a
personalized
windows
session
in
the
near
future.
For
that,
okay.
C
B
B
C
B
The
way
yeah
same
cool
cool,
okay
windows,
okay,
yeah
you're,
on
Windows
as
well;
okay,
sorry!
So
for
Windows!
Let
me
let
me
go
back
to
that.
So
there
are
two
things
that
you
should
have
installed
for.
Windows
is
there's
a
Windows
installer
for
node
and
then
you
should
have
get
installed
and
that's
as
far
as
I
got
so
we'll
have
to
try
to
debug
that
offline
yeah.
C
D
B
B
B
B
E
B
Right,
okay,
so,
let's
start
from
Alice's
perspective,
so
what
alice
is
gonna
want
to
do
is
let's
say
that
alice
is
the
one
that's
actually
starting
this
contract
off.
So
Alice
already
has
the
atomic
swap
code
because
we
Agoura
have
written
it
and
anyone
can
install
that
and
use
it.
So
alice
is
starting
off
with
what
we
call
an
installation
for
that
atomic
swap,
and
so
let
me
try
to
go
into
what
that
is,
and
this
is
this
is
one
of
the
things
that
Tom
and
I
have
been
working
on.
B
So
an
installation
is
really
just
saying:
hey,
there's
this
contract
code
and
we're
gonna
tell
Zoey
about
it,
and
so
we're
gonna
upload
this
code
to
Zoey
and
then
what
we're
gonna
get.
Is
this
ID
back
that
we
call
the
installation
handle?
And
so
you
might
think
of,
like
you
know,
normally
we
think
of
an
ID
is
like
a
number
or
a
string
or
something
like
that.
But
this
ID
is
a
opaque
object.
B
This
is
something
that's
kind
of
particular
to
a
gorg
is
that
we
prefer
using
JavaScript
objects
as
unique
identifiers
because
they
can't
be
forged.
So
someone
someone
can't
ever
guess
this
identity,
because
in
JavaScript
you
can't
that's
a
good
way
to
put
this.
You
can't
just
create
an
object
that
would
have
the
same
identity.
B
So
I'm
sure
you
guys
probably
have
questions
about
that.
We
can.
We
can
try
to
work
that
out,
but
okay.
So
so
you
have
this
code
that
you
want
to
install.
So
you
call
Zoe,
don't
install
with
this
code,
and
that
gives
you
this
opaque
identifier,
this
installation
handle
and
then
once
you
want
to
create
a
contract
instance.
So
you
want
to
actually
run
this
contract
and
be
able
to
use
it.
You
can
create
many
instances
for
the
same
installation.
Then
you
use
this
installation
handle
to
be
able
to
do
that.
B
B
So
does
the
instance
installation
separation
makes
sense.
Maybe
okay,
we
can.
We
can
come
back
to
that.
Okay,
so
Zoey
needs
to
needs
to
know
what
type
of
what
kind
of
er
TP
assets
you're
gonna
be
talking
about.
So
the
way
that
you
tell
Zoey
the
kind
of
thing
that
you're
going
to
be
talking
about
with
this
contract
is
through
the
use
of
issuer
keyword
record.
B
So
this
also
needs
better
documentation
but
effectively.
What
you're
saying
is
that
in
this
atomic
swap
contract,
we're
gonna
call
one
type
of
thing:
the
asset
we're
gonna,
call
another
type
of
thing
of
the
price.
So,
in
this
case,
the
asset
is
going
to
be
moolah
and
the
price
is
gonna,
be
in
samolians.
B
These
are
two
just
fake
currencies
that
we
came
up
with
for
this
test,
and
so
what
we're
doing
is
that
we're
telling
Zoey
about
the
issuers
using
the
names,
price
and
asset
to
do
so
and
price
and
asset
are
what
we
call
keywords
they
they
have
some
unique
characteristics,
so
they
have
to
be.
They
have
to
have
a
capital
first
letter
and
they
have
to
be
ASCII,
so
we
can't
have
weird
characters
in
there.
B
These
are
for
security
purposes,
so
that
someone
can't
use
this
to
put
some
specific
characters
in
there
that
provide
an
attack
vector
so
we'll
go
into
how
the
key
word
records
are
used
in
a
bit.
So
when
Alice
wants
to
create
this
instance,
she
also
has
to
create
what
we
call
a
proposal,
and
that
was
previously
what
we
called
the
offer
rules.
B
So
Alice
is
gonna,
say
I'm
gonna
give
three
moolah,
that's
the
asset
right
and
the
price
for
this
asset
is
going
to
be
seven
samolians,
okay
and
then
Alice's
exit
rule.
So
these
are
the
conditions
under
which
she
can
her
offer
can
be
completed.
Is
that
she
wants
to
be
able
to
exit
on
demand,
so
she's
gonna
have
the
ability
to
actually
cancel
this
offer.
B
So
in
order
to
make
this
offer
with,
what's
knowing,
she
has
to
submit
a
payment
for
what
she
says
she
was
gonna
give.
So
she
withdraw
as
a
payment
of
three
mullah
and
labels
that,
under
the
asset,
a
keyword
and
these
payments
are
submitted
as
part
of
the
part
of
making
her
offer.
So
to
make
an
offer,
you
have
to
redeem
an
invite.
You
have
to
submit
a
proposal
and
you
have
to
submit
the
payments
that
go
along
with
that
proposal
and
when
Alice,
let's
see,
let's,
let's
explain
the
invite.
B
So
that's
how
Alice
got
that
invite
and
then,
when
she
redeems
that
invite
with
the
proposal
and
the
payments
she
gets
a
seat
in
a
payoff
in
this
payout
is
going
to
be
the
payments
that
she
gets
back.
So
when
the
contract
tries
to
match
her
offer
with
Bob's
offer
she's
gonna
get
what
Bob
put
in
and
Bob's
gonna
get
what
she
put
in
Hey.
C
B
B
D
B
B
Yeah,
exactly
and
some
of
our
contracts
have
a
way
to
be
able
to
get
an
invite
without
getting
it
from
anyone.
The
contract
just
allows
you
to
say:
hey
I
want
to
participate
so,
for
instance,
there's
a
decentralized
exchange
that
has
a
order
book
and
they
don't
care
who's
interacting.
You
know.
If
you
have
a
valid
order,
you
have
a
valid
order,
so
you
can
you
can
get
an
invite
without
having
to
get
it
from
anyone,
but
yes,
most
of
the
time.
That's
exactly
right!
B
Okay,
so
let's
look
at
it
from
for
Bob's
perspective.
So
in
this
case,
Alice
makes
when
she,
when
she
puts
her
assets
and
she
gets
an
invite,
she
gets
an
end
to
match
that
first
offer
so
she's
gonna
send
this
invite
to
Bob.
So
we
can
look
at
Bob's
perspective
and
I.
Think
a
lot
of
this
will
become
clear
once
we
actually
see
the
contract
code,
but
I
want
to
kind
of
outline
how
the
users
interact
with
it
first.
So.
B
And
so
that's
what
we're
labeling
as
Bob
invite
P
P
is
kind
of
our
internal
language
for
saying
that
something
is
a
promise.
So
if
you
see
the
suffix
P
that
that
means
it's
a
product,
we
can
definitely
make
that
clear
and
then
this
this
wallet
mechanism
is
saying
this
is
Alice's
wallet.
So
it's
saying
the
thing
that
you
have
a
name
for
under
Bob
sends
this
invite
to
Bob.
B
B
You
know
it's
kind
of
like
your
your
phone
book
or
book,
but
your
contact
list
in
your
phone
is
what
I
mean.
So
you
know,
I
I
have
names,
I
have
my
own
personal
names
for
everyone,
but
the
phone
number
itself
is
the
objective
reference.
But
I
have
my
own
sub
good
names,
so
Alice
King,
whatever
name
for
Bob,
that
she
wants
and.
B
Yeah,
so
through
our
object
capability
model,
most
of
the
time
there
is
no
public
reference
for
four
things.
Most
of
the
times
things
are,
you
don't
have
access
to
something.
Unless
someone
grants
you
access
to
a
specific
object,
but
we
do
have
a
mechanism
called
the
registry
or
the
registrar
that
allows
you
to
say
hey
this
object
that
I
have
I
want
to
make
it
publicly
accessible
to
everyone
and
I'm
gonna,
give
it
the
string
identifier,
so
I
can
tell
someone
about
it.
B
D
B
And,
let's
see
so,
Bob
is
getting
this
invite
here
from
from
Alice,
and
the
first
thing
that
he's
gonna
want
to
do
is
he's
gonna
want
to
check
the
invite
to
see
that
it's
it's
valid,
so
he
gets
this
invite
issuer
from
Zoey.
So
this
is
a
public
method
that
so
he
has
this
to
get
then
by
issuer
and
in
Annie
RTP.
The
issuer
is
the
decider
of
the
validity
of
the
kinds
of
things
that
it
is
associated
with.
B
So
if
I
have
a
type
of
digital
asset
and
I
know
the
issuer,
for
that
I
can
ask
the
issue
where
hey?
Is
this
a
valid
kind
of
that
sort
of
thing?
So
the
Zoey
invite
issuer
is,
has
the
final
say
over
whether
an
invite
is
a
valid
invite
or
not,
and
any
it's
that
I
call
on
the
invite
issuers
that
use
this
invite
will
error
if
it's
not
a
valid
invite
so
I
can
say
you
know,
give
me
the
amount
of
this
invite
and
that'll
that'll.
B
Give
me
some
more
information
about
what
this
invite
is
part
of
the
amount
of
an
invite.
Has
the
installation
handle
that
we
talked
about
earlier,
and
so
what
Bob
can
do
is
he
can
look
up
that
installation
handle
and
he
can
check
whether
it
matches
his
known
installation
handle
for
the
atomic
swap
code
and
if
it
doesn't,
he
can
throw
an
error,
and
you
know
tell
Alice
that
she's,
you
know
going
back
on
their
agreements
and
messing
with
him
and
that
sort
of
thing
right.
B
He
can
also
check
the
the
underlying
issuers
for
this
contract.
So
we
said
earlier
that
you
know
the
type
of
thing
that
we're
calling
an
asset
is
gonna,
be
the
moolah
kind,
the
type
of
thing
that
we're
calling
a
price
is
going
to
be
Somalians.
So
he
can
do
that
check
as
well,
and
if
he's
satisfied
with
those
things,
then
he
can
go
ahead
and
make
his
offer
in
the
same
way
that
alice
did
so.
That
takes
an
invite
which
he
got
from
alice.
His
intended
offer
rules
or
what
we
now
call.
B
That's
when
this
promise,
so
in
JavaScript
there's
the
concept
of
a
promise
that
is
a
it
is
a
let's
see,
what's
a
good
way
to
put
this,
it's
a
value
that
will
be
resolved
at
a
future
time.
So
when
this
promise
resolves
to
a
value,
that's
when
that
payout
actually
happens
and
the
users
will
get
their
their
er
to
be
payments
which,
in
this
case
fog
will
deposit
in
as
well
it.
B
C
C
C
B
You
could
imagine
it
being
handled
a
couple
of
different
ways,
so
the
first
way
is
that
the
negotiation
is
happening
in
some
other
communication
channel.
So
it
could
be
that
you
know
you
and
I
are
talking
on
zoom'
working
out
the
details
and
then,
when
we
finally
decide
we
do
this
atomic
swap
contract
or
the
other
medium
or
it
could
be.
The
negotiation
could
be
part
of
this
contract
as
well.
B
We,
you
would
have
to
write
the
contract
to
allow
for
that,
and
we
don't
have
anything
that
that
would
allow
for
that
right
now,
but
there's
nothing
preventing
that
and
what
you
would.
What
you
would
have
to
do
is
have
the
contract
kind
of
act
as
the
storage
of
okay.
This
offer,
you
know
this
proposed
offer
was
made.
Was
it
accepted
or
was
a
counterproposal
made?
You
know
that
sort
of
thing,
Dean
Dean
our
CEO
kind
of
wrote
up
a
state
diagram.
C
C
C
B
C
B
Could
have
a
contract
that
requires
people
to
put
up
some
kind
of
collateral
before
any
negotiation
starts
and
then,
if
you
know,
if
there's
misbehavior,
the
collateral
is
lost
or
you
know,
maybe
the
collateral
is
exactly
the
kind
of
thing
that
they
would
be
using
in
the
trade.
Maybe
it's
not.
Okay,.
E
I'm
calling
correctly
the
proposal
slash
offer
includes
how
the
user
can
cancel
the
offer,
so
users
could
potentially
cancel
the
offer
so
I'm
thinking
something
like
I
make
an
offer.
I
get
back
an
email
or
a
text
saying
no
we're
not
gonna.
Take
that
one,
and
then
you
cancel
that
offer
and
make
a
higher
one
or
something
like
that.
Would
that
work
yeah.
B
Yeah,
you
could
definitely
do
that.
It's
a
bit.
It
really
depends
on
whether
you
need
Zoe
for
that
step
or
not
whether
whether
you
need
to
be
s
growing
at
the
point
that
you're
negotiating
or
whether
the
negotiation
is
cheap
enough,
that
you
can
do
it
without
having
to
escrow
but
yeah.
That's
also
another
mechanism
right.
C
B
So,
let's
see
I
think
the
first
thing
to
explain
is
what
happens
when
when
Alice
creates
a
contract
instance,
so
this
is
the
code
that's
identified
by
that
installation
handle.
So
if
you
were
to
give
someone
an
installation
handle
and
say
you
know,
you
can
use
OE
to
look
up
this
code.
This
is
what
that
person
would
see
for
the
most
part.
So
if
anyone's
inviting
you
to
a
contract,
you
can
use
that
to
see
exactly
what
you
know.
The
the
terms
of
the
contract
are
or
what
the
actual
code
of
the
contract
is
right.
B
B
So
essentially,
what
it's
saying
is
that
it
needs
to
have
this
format
and
if
not,
then
we
reject
Alice's
proposal
and
then
the
next
thing
to
do
is
once
we
have.
This
valid
first
offer
is
to
make
an
invite
for
the
second
offer,
so
that's
all
but
is
happening
when
Alice
does
her
part
of
the
contract
in
terms
of
this,
this
contract
code
does
that
make
sense
so
far,
okay
and
then
for
the
second
part,
it's
a
little
bit
more
complicated.
B
B
So
we
wrote
up
a
number
of
what
we
call
helper
functions
to
help
the
smart
contract
developers
write
things
easier,
so
I'll
go
into
swap
right
now
and
we
can
kind
of
see
what
it's
doing,
but
it
turned
out
that
this
was
a
pattern
that
was
used
in
a
couple
of
our
different
contracts.
So
we
just
decided
to
put
it
in
a
function
that
could
be
used
on
this
on
the
contract
development
side,
so
that
people
wouldn't
have
to
rewrite
it
themselves.
C
B
Okay,
here
we
go
yeah,
so
we
copied
out
the
helpers
into
into
this
directory,
but
just
so
that
you
can
see
what
they
look
like,
but
normally
you
would
import
these
from
the
NPM
package
addict
or
ik
Zoey
and
when
we're
changing
how
this
works
a
little
bit
in
the
latest
release.
So
this
will
change
a
little
bit,
but
so
let's
actually
go
to
swap
and
see
how
that
works.
How
are
you
doing
for
time.
B
So
what
what
swap
is
doing
first
is
it's
checking
that
the
first
offer,
what
we're
calling
the
keep
handle
here
and
the
difference
between
the
keep
handle
and
the
try
handle
is
that
in
many
cases
we
have
this
offer
that
we
want
to
match
and
we're
going
to
continuously
try
different
offers
to
see
if
it
matches
and
if
the
second
offer
doesn't
match
thing
that
we're
trying
we're
just
gonna,
reject
that.
So
that's
that's.
Why
we're
calling
one
keep
the
keep
handle
and
the
other
the
try
handle.
B
So
we
can
ask
Zoe
if
the
first
offer
is
still
active,
if
not,
if
the
first
offer
isn't
still
active.
That
means
that
the
the
assets
aren't
still
escrowed.
You
know
we
can't
actually
trade
with
anything,
so
we
will
reject
that
second
offer,
and
then
the
next
thing
that
we
need
to
check
is
whether
the
the
first
offer
and
the
second
offer,
or
actually
a
match
in
terms
of
whether
they'll
satisfied
each
other's
wants
right-
and
in
this
case
we
know
it's
the
it's
an
exact
match.
B
They
actually
want
the
exact
opposite
of
each
other
and
they're
going
to
be
giving
what
the
other
one.
So
we
know
that
this
matches
so
this
passes
and
then,
since
we
know
that
it
passes,
the
next
thing
that
we
need
to
do
is
actually
reallocate
for
both
of
the
offers,
and
so
what
reallocate
is
saying?
It's
that
it's
from
the
contracts
perspective,
the
contract
is
going
to
ask
Zoe
to
take
the
amounts
that
are
in
in
the
database
for
both
of
these
offers
and
just
swap
them.
B
So
what
we're
gonna
say
is
that
the
amounts
that
were
under
the
second
offer,
let's
actually
give
them
to
the
first
offer
and
the
amounts
that
were
originally
for
the
first
offer.
Let's
get
them
for
this
to
the
second
offer,
and
so
that's
what
this
reallocate
called
us
and
then.
Finally,
we
want
to
complete
both
of
the
offers,
because
we're
not
going
to
do
anything
more
with
them.
B
We're
not
going
to
reallocate-
and
this
complete
call
will
actually
give
the
users
their
payouts
through
Zoe,
okay
and
then
what
we're
gonna
do
is
we're
gonna
return,
what
we
call
a
default
acceptance
message
to
the
user.
That
just
says
like
hey
your
offer
was
valid.
Let's,
let's
actually
see
what
this
the
offer
has
been
accepted.
You
know
once
the
offer
has
been
completed,
please
check
your
payout,
so
the
at
the
contract
level.
C
D
C
B
Let
me
start
over,
so
a
contract
can
really
only
know
about
things
if
it's
told
about
things
right
and
the
contract
should
really
only
care
if
it's
told
about
things,
if
it's
told
in
some
kind
of
credible
way
right.
So
what
you
could
do
is
have
you.
You
know
the
the
invite
that
we
saw
before
that
was
given
back
to
Alice
when
she
made
the
contract
mm-hmm.
B
This
could
be
associated
with
more
of
an
admin
authority
that
could
have
some
way
of
informing
the
contract.
That's
something
important
had
happened
in
the
outside
world
and
because
only
Alice
gets
this
invite.
No
one
else
would
be
able
to
have
permissions
to
inform
the
contract
that
that
event
had
happened.
So
that's
that's
one
way
in
which
the
creator
at
the
contract
can
kind
of
act
as
what
we
call
an
Oracle
in
the
blockchain
space
and
tell
the
contract
about
an
event
that
happens.
Offline.
B
Yeah,
so
we
I
think
that's
right,
so
what
you
could
do
is,
instead
of
like,
let's
say,
you're
a
bookseller
instead
of
you're
not
minting
digital
books,
right
you're
minting
promises
for
real
books,
so
are
digital
representations
of
something
that
will
happen
in
the
real
world
right.
C
B
So
in
the
smart
contract
and
offers
safety
won't
help,
you
actually,
you
know,
get
a
real
book
if
that's
what
you
purchased,
but
it
will
at
least
ensure
that
it's
very
clear
that
you've
given
money
for
the
specific
digital
promise,
so
to
speak,
that
you
will
actually
get
a
physical
book
in
the
near
future.
So.
B
That
is
a
very
good
question.
No,
we
don't.
We
don't
have
anything
like
that
right
now.
Actually,
when
a
an
offer
is
completed,
it
gets
erased
from
Zoey
yeah,
yeah
yeah,
but
I
could
definitely
see
how
for
for
auditing
purposes
and
for
future.
You
know
dispute
resolution.
You
would
want
a
receipt
of
that.
You
would
want
a
record
that
did
happen
really
good
question.
Okay,.
B
Yeah,
so
let's,
let's
actually
look
at
the
a
simple
exchange
contract
we
might
have
looked
at
it
a
little
bit
last
time.
I
can't
remember,
but
this
is
an
example
of
contract
state
or
at
least
a
bit
of
state.
So
this
the
what
the
the
simple
exchange
is
doing
is
just
it
has
an
order
book.
It's
a
it's
an
online
exchange,
so
you
know,
there's
buy
and
sell
orders
and
the
contract
itself
stores
the
information
about
the
current
buys
and
sells,
but
you
can
imagine
it
also.
B
B
So,
let's
go
into
the
test
for
this,
so
those
of
you
who
have
gotten
things
running
and
you've
been
able
to
run
the
test
successfully.
This
is
what's
this
is
one
of
those
tests
that's
running
and
basically,
what
it's
doing
is
it's.
It's
setting
up
things
like
the
Registrar
which,
as
I,
was
mentioning
Joe,
that's
kind
of
like
the
way
that
we
make
private
things
public.
B
So
if
you
put
something
in
the
registrar,
what
you're
doing
is
you're
making
it
public
to
the
world
under
a
certain
name
so
that
you
have
this
this
common
knowledge
of
what
this
thing
that
you're
talking
about
actually
is.
So
this
test
code
will
set
up
Zoey
it'll
set
up
the
Registrar.
Both
of
these
things
will
are
already
present
on
our
test
net,
so
I'll
go
into
like
what
are
with
the
test.
B
Net
scenario
and
development
looks
like
versus
the
Zoey
sketchbook
scenario,
which
is
much
more
simplified
and
focuses
really
on
just
the
contract
development,
but
I'll
go
into
that
in
a
bit.
So
we're
setting
up
the
wallet
with
just
kind
of
the
pet
names
for
different
issuers
and
things
like
that
and
we're
setting
up
Alice
and
Bob
with
their
initial
money
in
this
test.
B
B
So
this
is,
this
is
all
running
locally,
so
this
is
the
Zoe.
Sketchbook
is
kind
of
like
the
most
stripped-down
version
of
things
that
we
have
so
that
you
could
focus
really
only
on
the
contract
development
side
and
like
right
now
we're
going
through
quite
a
lot
of
changes,
trying
to
get
ready
for
our
hackathon
release.
That's
coming
up
in
a
week,
and
so
with
the
sketch
book.
B
B
But,
let's
see
so
let
me
actually
go
into
what
it
looks
like
when
it's
not
just
the
sketchbook,
because
I
think
that's
a
pretty
good
lead-in.
So
we
have
the
concept
of
adapt
and
adapt
is
short
for
distributed
application.
And
basically,
what
that
is.
Is
the
combination
of
Zoe
contract
plus
a
server
that's
running
the
back
end
and
the
front
end
for
whatever
application.
This
is
and
then
the
UI
that
is
running
both
on
the
server
and
then
a
version
that
may
be
connected
to
your
wallet.
B
So
this
is
kind
of
the
whole
like
end-to-end
application
that
a
user
might
actually
use.
We
have.
We
have
a
few
examples
of
of
DAPs.
Let
me
see
I
think
so.
We
have
the
simple
exchange
stack.
So
that's
kind
of
like
the
order
book
example,
and
then
we
have
the
auto
swap
tap,
which
is
users
are
able
to
trade
with
the
liquidity
pool.
B
So
it's
it's
based
off
of
their
iums
unis
contract
and
I
can
show
you
what
the
auto
swap
contract
looks
like
or
what
the
front
end
looks
like
I
mean
so
so
in
this
case
we
have.
We
have
the
purses
from
our
wallet
so,
and
this
is
just
what
you
start
out
with
in
our
application.
At
least
the
you
know,
the
kind
of
demo
version.
So
we
have
we
have
moolah
and
we
have
samolians.
So
let's
say
that
we're
gonna
trade,
you
know
15
moolah,
for
whatever
samolians,
and
if
this
was
actually
working.
B
This
would
fill
in
with
the
price,
and
you
would
be
able
to
see
the
price
for
per
unit
down
here
and
then
you'd
be
able
to
swap,
and
once
you
swapped,
then
it
would
open.
Your
wallet
show
you
this
proposed
transaction,
that
the
app
with
the
depth
proposed
to
your
wallet
and
you'd
be
able
to
accept
or
decline
it
here
and
when
you
accept
or
decline.
That's
the
wallet
would
actually
make
your
offer
to
Zoe
and
handle
all
of
that
interaction
for
you.
B
D
B
So
this
can
be
the
sky's
the
limit.
It's
completely
open
web
development.
So
this
is
this
is
currently
built
with
react.
You
can
use
whatever
it
is
that
you
wanted.
Our
simple
exchange.
Ui
is
a
bit
different
than
this,
but
basically
kind
of
the
same
outline.
I
guess
you
know
kind
of
boxy
you're
just
exchanging
things
right,
but
you
can
imagine
this
being.
You
know
a
a
really
well
done.
You
know
almost
video
game
type
front-end
or
something
it
really
couldn't
be
yeah
yeah.
B
So
this
is
probably
I
would
say
the
the
server
that
is
running.
This
is
probably
the
responsibility
of
the
person
who's,
creating
the
smart
contract,
but
not
necessarily,
but
you
would
imagine,
like
someone
has
a
business
idea.
They
create
the
Zoe
contract
they
create.
You
know
this
this
front
end
and
make
sure
that
whoever
is
creating
the
wallet
which
is
probably
a
quark
is
able
to
to
interact
with
that
application.
B
Okay,
so
so
there
is
documentation
on
how
to
get
the
daps
started
and
how
to
manipulate
them
and
how
to
how
to
deploy
contracts,
and
things
like
that,
we're
very
much
in
the
process
of
trying
to
smooth
out
all
of
these
steps.
So
I,
don't
necessarily
recommend
you
know
going
through
with
all
this
unless
you
just
want
to
poke
around
which
you're
welcome
to,
but
in
a
week
he'll
it'll
be
much
better.
Let's
see
so
I
think
that's
pretty
much.
All
I
wanted
to
go
over
today.
B
B
A
No
I
think
yeah.
That's
like
a
lot
to
go
through
for
the
you
know
for
day,
one
anyway.
So
at
some
point
maybe
Kevin
and
I
can
talk.
Well,
you
know
what
you
know
whether
you
want
to
have
an
example
to
work
through
on
your
own,
that
you
know
it's
probably
a
good
way
to
answer
a
lot
of
your
questions.
Yeah,
and
maybe
we
can
sort
of
attack
that
as
something
maybe
even
for
the
hackathon
project
or
something
like
that.
A
B
B
So
in
their
Zoe
sketchbook
that
you
have
locally,
there
could
be
this
launch
that
Jason
and
what
that
is.
Is
the
settings
for
actually
running
the
debugger
in
vs
code?
So
if
you
go
over
here
to
this
little,
you
know
play
symbol
with
the
bug
on
it.
That
allows
you
to
run
the
tests
and
the
the
program
that
you're
running
is
just
defined
by
this
file
path
here,
so.