►
From YouTube: ZK HACK - Introduction to SnarkyJS and Snapps with Mina
Description
The ZK HACK is brought to you by ZKValidator and Zero Knowledge Podcast: 7 weeks of workshops to learn about zero knowledge tools and concepts alongside a puzzle competition.
In this video, Izaak Meckler and Jason Borseth from Mina protocol host a workshop introducing SnarkyJS and Snapps.
Check out the website for ZK HACK https://www.zkhack.dev/
To stay up to date with ZK HACK follow the Twitter - @__zkhack__
And get involved with the community by joining the discord https://discord.gg/tHXyEbEqVN
To Follow the Zero Knowledge Podcast us at https://www.zeroknowledge.fm
To the listeners of Zero Knowledge Podcast, if you like what we do:
- Follow us on Twitter - @zeroknowledgefm
- Join us on Telegram - https://t.me/joinchat/TORo7aknkYNLHmCM
- Support our Gitcoin Grant - https://gitcoin.co/grants/329/zero-knowledge-podcast-2
- Support us on Patreon - https://www.patreon.com/zeroknowledge
A
All
right,
it's
great
well
thanks
for
joining
us
today,
so
my
name
is
jason.
I'm
a
product
manager
at
one
labs
focusing
on
snaps
and
we
have
isaac,
who
is
the
cto
of
owen
labs
as
well,
so
we're
really
excited
to
introduce
snaps
and
tell
you
more
about
it.
Snaps
is
our
smart
contracting
platform
based
off
of
starks
zk
starks,
and
it
has
some
unique
characteristics
because
of
that.
A
A
B
A
A
An
enormous
amount
of
research
spanning
decades
has
gone
into
this
across
multiple
teams,
and
in
recent
years
there
has
been
significant
progress
around
zk
starts
recently,
our
cryptography
team
at
owen
labs
has
created
a
new
zk
snark.
We
call
kimchi,
which
is
setupless
efficient
and
extensible.
It's
based
off
15-wire
plug
and
with
the
amino
blockchain
based
on
zk
ckstarx,
we're
able
to
re-envision
the
design
of
a
smart
cartridge.
Smart.
A
Platform,
so
on
ethereum,
smart
contracts
execute
on
the
chain.
Users
send
a
transaction
specifying
one
of
the
methods
of
the
smart
contracts
to
the
chain
with,
along
with
data
arguments,
every
node
across
the
ethereum
network
executes
these
same
instructions.
It
was
once
groundbreaking,
but
it's
woefully
inefficient.
A
Mena
snaps
use
a
totally
different
model.
Users
execute
one
or
more
methods
of
the
smart
contracts
locally
and
privately
on
their
own
computer,
and
then
they
generate
a
zero
knowledge
proof.
They
send
a
transaction
containing
the
serial
knowledge
proof
and
a
description
of
associated
state
updates
to
the
chain.
A
The
amino
network
then
verifies
that
this
proof
is
correct,
for
that
particular
snap
account
and
if
it
is,
the
state
is
allowed
to
be
updated
and
if
not,
the
transaction
is
rejected.
Clients
down
the
line
can
then
verify
the
correct
state
of
the
snap
account
just
by
quickly
verifying
proofs
sent
to
the
snap
accounts.
There's
no
need
to
execute
the
full
program
like
ethereum
would,
over
and
over
in
order
to
confirm
it.
So
the
program
is
only
executed,
off-chain
locally
on
the
user's
machine
before
it's
sent
to
the
blockchain.
A
This
gives
us
a
few
advantages.
We
achieve
blockchain
scalability
through
succinctness,
because
that
source
of
truth
remains
a
constant
22
kilobytes
in
size.
We
also
have
the
opportunity
for
user
privacy
through
zero
knowledge
groups,
because
these
smart
contracts
are
running
locally.
Data
can
remain
private
or
public
depending
on
the
developer's
choice.
When
you
write
your
smart
contracts
and
then
because
it
runs
off
chain,
you
also
get
essentially
unlimited
option
execution.
A
A
A
A
Secondly,
is
the
verification
key
which
is
stored
on
chain
it's
sent
on
chain
when
the
developer
deploys
their
smart
smart
contracts
and
it's
used
to
verify
the
correctness
of
the
execution,
and
so
as
mentions
to
to
deploy
a
new
smart
contract
or
to
update
it.
A
developer
has
this
verification
key
that
they
generated
during
the
build
process
and
they
send
a
transaction
to
the
chain
to
their
snap
to
their
meena
address,
and
when
that
meena
address
contains
the
verification
key.
We
now
call
that
a
snap
account
because
it
now
functions
as
snap.
A
So
to
dive
into
one
last
part
of
of
kind
of
how
this
works
before
isaac
jumps
into
the
next
section.
The
smart
contract
methods
can
take
certain
inputs
and
certain
outputs.
So
this
will
be
good
to
know
when
we're
looking
at
how
snarky.js
works,
the
inputs
can
be
certain.
It
can
be
method
arguments,
so
this
could
be
data
specified
by
the
user
in
the
local
web
browser
when
it
when
it
runs.
So
that's,
for
instance,
your
private
data.
A
You
can
also
have
on-chain
smart
contract
states,
so
existing
states
for
that
particular
staff
account
and
you
can
have
also.
You
can
also
have
other
values
for
this-
the
state
of
the
world,
so
you
could
have,
for
instance,
the
current
block
height
or
account
balances
that
type
of
thing
and
then,
additionally,
the
smart
contracts
method,
outputs
updates
to
the
state
of
the
smart
con
to
the
state
of
the
smart
contract
and
updates
potentially
to
the
state
of
the
world
all
right.
C
A
C
C
C
So
basically
it
uses
existing
open
technologies,
that
is
to
say,
you
know,
node.js
and
the
browser,
and
because
it's
just
a
typescript
library
you
can
use
existing
javascript
and
typescript
libraries
and
tools,
so
you
don't
have
to
learn
a
whole
new
development
environment,
a
whole
new
syntax.
You
know
a
whole
new
set
of
tools.
You
just
use
kind
of
the
existing
typescript
tools
which
are
really
robust
because
there's
been
thousands
and
thousands
of
person
hours
invested
in
them
and,
moreover,
you
know
a
specific
instance
of
that
is.
C
We
have
really
good
vs
code
support,
so
we'll
we'll
be
seeing
that
later
on.
In
in
the
presentation,
so
yeah
so
like
the
intended
development
environment
for
snarky
gis
is
using
vs
code,
I
mean
you
can
use
whatever
typescript
or
javascript
environment
you
want.
But
I
can.
I
can
report
that
the
vs
code
support
is
very
good,
so
just
to
kind
of
start
things
off.
C
The
basic
unit
of
data
in
zero
knowledge
programming
is
a
field
element
and
I'm
sure
you've
heard
about
this
a
lot
throughout
all
the
presentations.
So
hopefully
this
is
familiar
to
you,
but
basically
a
field
element
is
is
like
a
number,
a
very
big
number,
so
a
number
which
is
almost
256
bits
in
size.
Actually,
our
specific
field,
it's
a
little
bit
less
than
255
bits,
but
you
know
you
can
think
of
it
as
being
something
quite
similar
to
256
and
solidity.
C
So
what
can
you
do
with
field
elements?
Basically,
the
basic
operations
you
can
perform
with
them
are,
like
addition,
multiplication
division
subtraction
that
kind
of
thing,
but
we
can
build
all
sorts
of
things
out
of
them
and
in
fact
the
standard
library
for
snarky.js
has
already
done
done
so
so
in
starkey
js.
This
is
represented
by
a
typescript
type
called
field
and
yeah.
So
in
typical
you
know
typescript
or
javascript
programming
you
could
write.
You
know
this.
C
Like
sum,
the
sum
of
two
numbers
is,
you
know
one
plus
three
in
starkey
js,
because
field
is
kind
of
its
own
type.
You
need
to
you,
know,
kind
of
wrap
it.
So
the
way
that
you
write
like
a
new
you
know
create
field
elements.
Is
you
write
new
field?
You
know
some
input,
which
would
be
a
number
or
a
string
representing
you
know
the
valid
field
element
and
then
you
can
do
use
dot.
C
Add
on
that,
and
actually
so
here
you
know
we
we
have
like
new
field,
one
dot,
add
new
field
three
for
convenience.
This
can
actually
just
be
simplified.
To
just
say,
like
dot.
Add
the
number
three
then
snarky.js
can
you
know
figure
out
how
to
wrap
that
cool.
So
I'm
I'm
gonna
be
looking
at
the
questions
every
now
and
then
but
looks
like
we're
all
good.
So
there's
a
lot
of
other
built-in
types
besides
field
elements.
C
So,
as
I
said,
there's
fields
there's
also
un-64,
un
32
public
key
private,
key
and
signature.
So
there's
a
built-in
signature
scheme
libra
into
the
center
library,
because
that's
a
really
common
kind
of
functionality
that
people
would
want,
you
know
want
to
use
in
smart
contracts.
There's
also
types
for
sort
of
representing
optional
data.
C
Booleans,
a
group
type
for
sort
of
you
know
representing
an
elliptic
curve
which
is
useful
for
a
lot
of
cryptographic
schemes
and
these
all
have
built-in
methods
on
them
that
we'll
see
in
a
little
bit.
So
to
sum
up,
there's
a
whole
bunch
of
useful
functionality
providing
the
standard
library-
and
it's
has
an
all-
has
a
nice
typescript
interface
and
we'll
we'll
see
that
a
little
bit
so
just
a
bit
of
a
primer
on
some
of
the
basics
of
snarky.js.
C
So,
as
I
said,
it's
a
typescript
library
and
programming
is
very
much
as
it
is
in
typescript
or
javascript.
So,
just
to
give
a
really
simple
example:
here's
a
function
that
takes
in
an
input,
field,
element
x
and
outputs
a
field
element.
So
this
is
how
you
write
this
and
it
works
by.
You
know
the
function
is
called
add
one
and
double
so:
what's
it
going
to
do
it's
going
to
take
an
x,
it's
going
to
add
1
to
it,
and
it's
going
to
multiply
it
by
time,
multiply
it
by
2.
C
If
you
want
to
create
an
intermediate
variable,
you
just
do
it
like
you
do
in
javascript
or
typescript.
You
can
use
let
or
const.
If
people
are
familiar
with
javascript
and
you
know
you
can
define
this
intermediate
value
x,
plus
one
just
do
x,
dot
one,
and
then
you
just
return.
You
know
x,
plus
one
double
two,
so
so,
okay,
so
just
to
kind
of
sum.
This
up,
like
the
basic
syntax
of
it,
is
just
typescript.
It's
just
javascript,
it's
just
typescript.
C
So
if
you're
familiar
with
that,
this
circuit
js
will
be
very
familiar
to
you
from
here.
We're
going
to
basically
look
at
a
hello
world
snap
example
to
kind
of
get
our
feet
wet
with
how
programming
smart
contracts
and
stock.js
looks
so
to
get
set
up.
There's
three
things
that
that
we
need
to
do,
and
I
know
that
this
takes
basically
five
minutes,
because
I
just
did
it
right
before
this
workshop,
because
I'm
on
a
mac
which
I
usually
don't
use.
C
If
you
have
vs
code
installed
already
great,
otherwise,
there's
a
link
in
the
slides,
the
slides
should
be
in
the
chat
and
then
the
second
thing
you
want
to
do
is
install
node.js
with
npm
version
16
or
later
you
can.
You
can
use
the
link
here
and
then
the
third
thing
is
you're,
going
to
clone
the
gear
repo
specific
to
the
workshop.
A
C
C
Oh
sorry,
I
my
bad,
I'm
gonna,
I'm
gonna.
I
forgot
to
put
https
on
the
thing.
I
guess!
Oh
no!
No!
No!
It's
that
actually,
that
they
delete
the
http
yeah;
okay,
that's
annoying,
so
so
yeah!
So
basically
I
oh
wow.
Someone
figured
out
how
to
do
it.
Right.
Click,
paste,
okay,
so
yeah!
Thank
you
to
to
jeff,
arnold,
for
and
and
you
and
younansha,
for
putting
the
right
way
to
clone
the
get
repo.
C
C
Oh
there's
some
questions
in
the
q:
a
tab:
okay,
okay,
so
I'm
gonna,
while
we're
waiting
for
people
to
get
installed.
I'm
gonna
wait
a
few
more
minutes.
I'm
just
gonna
read
some
of
the
questions
in
the
q.
A
tab,
so
anonymous
asks
well.
No,
no
I'll
go
in
reverse
order.
Harass
g
asks
since
the
computation
is
off
chain.
Is
it
fair
to
say
user
could
be
censored
to
use
the
snap
so
haresh
that
depends
on
how
the
snap
is
set
up.
So
in
the
typical
setup?
C
No,
the
user
cannot
be
centered
because
there
will
be
a
permissionless.
You
know
way
for
the
user
to
run
the
application
and-
and
they
will
just
execute
it
on
their
own
hardware
like
on
their
laptop
or
on
their
phone
or
whatever,
and
then
posted
proof
to
mena-
and
you
know,
mina
is
like
a
normal
blockchain
like
censorship
resistance,
so
that
execution
proof
is
going
to
get
incorporated
into
mina.
C
C
That's
a
good
question,
so
let
me
put
it
like
this
well.
First
of
all,
there
are
certain
settings
where
you
just
want
field
elements
so
like,
for
example,
if
you're
doing
operations
with
an
elliptic
curve
or
with
some
kind
of
scheme
cryptographic
scheme.
Very
often
you
need
to
you
need
to
use
field
elements
because
you
need
to
be
able
to
divide
basically,
so
in
a
field
you
can
divide
in
a
nice
way
in
in
with
you
ant,
256
or
whatever.
You
can't
really
divide
exactly.
C
C
That's
the
same
in
our
proof
system,
the
native
kind
of
operation.
It's
supported
is
field
arithmetic,
so
that's
kind
of
the
native
value.
Okay,
so
just
moving
along
mursad
ayanovich
asks.
Do
we
have
to
put
along
you
don't
have
to
it's
up
to
you,
oh
man,
so
many
questions
kobe
asks
is
a
snapdev
company
going
to
be
running
their
own
proofs
or
will
they
part
of
be
part
of
the
snark
marketplace
or
some
kind
of
distributed
worker
pool?
C
So
again,
it
kind
of
depends
on
the
setup
of
the
application.
You
could
deploy
a
snap
that
has
you
know
that
is
sort
of
running,
as
maybe
kind
of
like
a
roll-up
situation.
In
which
case
you
know
you
might
have
one
operator
you
might
have
an
operator
or
you
could
have
snaps
that
you
know
the
approver,
the
user
kind
of
executes
the
proof
individually
and
then
kind
of
broadcasts
its
broadcasted
to
the
amino
network
and
it'll
be
part
of
the
stock
market
place
there.
C
Marcos
asks
is
the
work
workshop
code
yarn
compatible,
I
don't
know
maybe
gregor
or
brandon.
If
you
know
or
martin
in
the
chat
can
answer.
What's
the
equivalent
of
etherscan.io
for
mina.
Forgive
the
perhaps
dumb
question
is
code
visible
for
a
smart
contract.
How
does
this
privacy
visibility?
Tradeoff
work?
That's
a
very
good
question,
so
there
are
meena
block
explorers.
If
you,
for
example,
if
you
go
to
mediaexplorer.com,
you
can
find
a
very
good
block
explorer.
It's
not
a
dumb
question
at
all.
C
Is
code
visible
for
smart
contract
is
an
excellent
question.
By
default.
It's
not
so
what
happens
is
basically
the
when
you
deploy
a
snap
account
you
put
kind
of
like
a
commitment
or
a
hash
of
the
code
on
chain,
and
then
later
people
come
along
and
post
proofs.
That
kind
of
verify
against
that
commitment
or
hash
of
the
code,
so
by
default,
the
code
is
actually
not
available
on
chain,
but
you
know
in
most
applications
or
in
a
lot
of
applications.
C
Okay
bo
yao
asks
what
kind
of
offline
compute
calculation
can
you
use
you?
Can
you
can
do
anything?
It
won't
necessarily
be
verified,
but
you
can
do
anything
you
can
do
in
javascript.
Francesco
asks
are
snaps
composable,
yes,
they
are
we
if
we
have
time
we'll
get
into
that
a
little
bit.
Florian
asks
we
touch
on
token
as
well.
I've
seen
references
to
token
id
and
token
symbol
and
code.
I
won't
be
discussing
that
in
this
workshop.
C
C
Hopefully,
that
works
and
we're
gonna
now
go
through
hello
world
together.
So
we're
gonna
write
a
very
simple
smart
contract.
With
a
single
state
variable
named
x,
okay,
it
will
have
a
method
called
update
that
will
let
us
replace
x
with
its
square
so
like,
for
example,
if
x
starts
out
being
three.
If
we
call
update,
we
can
provide
update,
you
know
with
the
square
of
x9
and
the
smart
contract
will
say:
yup
that
looks
good.
That's
the
square
of
the
current
state
and
replace
the
current
state
value
with
nine.
C
Then
we
can
do
you
know
once
it's
nine.
We
can
do
object,
81,
81,
being
nine
squared
and
that
will
set
the
new
state
to
e1
and
just
to
kind
of
drive
the
point
home.
Let's
say
you
know
we
perform
our
first
update
x
is
nine
and
then
we
try
and
call
update
with
something
which
is
not
nine
squared
like
75,
then,
basically,
the
execution
will
abort
and
it'll
say:
hey
very
bad.
You
did
the
wrong
thing
and
it
will
not.
C
C
C
Only
by
default,
only
types
built
out
of
field
can
be
used
for
state
variables
and
I'll
get
into
a
little
bit
of
what
that
means
in
a
bit.
So
this
is
a
lot
like
how
it
works
in
solidity.
This
is
a
very
similar
concept
and
solidity.
You
know
you
declare
when
you,
when
you
write
your
smart
contract,
you
kind
of
declare
a
class
like
this.
You
decline
you,
you
define
properties
on
this,
that
class
in
much
the
same
way,
so
it's
very
similar.
C
So
the
next
ingredient
in
defining
a
snap,
is
to
define
the
constructor.
So
this
describes
how
the
snap
will
be
initialized
when
it's
deployed
there's
two
kind
of
parameters
that
you
pretty
much
are
always
going
to
have
when
you
define
a
snap
which
is
the
initial
balance
of
the
snap
account
and
the
public
key
that
owns
the
snap
account.
C
So
this
is
what
a
constructor
looks
like,
oh
yeah,
so
in
addition,
this
constructor
is
going
to
take
the
initial
value
for
the
account
state
x,
and
it's
simple
as
you
know,
so
you
call
super
address.
So
that's
just
something
you
always
do
you
basically
add
to
the
initial
balance.
You
add
to
the
balance
of
the
account
the
initial
balance.
That's
provided
and
you
initialize
the
x
state
state
variable
with
this
value
x.
That's
provided
now.
C
Once
we've
deployed
a
smart
contract,
we
want
to
start
giving
it
behavior,
so
any
smart
contract
can
can
contain
multiple
methods
that
each
have
their
own
logic.
So
the
way
that
we
define,
that
is
by
defining
methods
on
the
class
so
for
each
method,
you
you
basically
write
at
method,
then,
okay,
so
this
method
happens
to
be
async
and
I'll
get
into
that
in
a
minute.
C
C
Then
it's
going
to
square
it
and
assert
that
that
is
equal
to
the
provided
argument
and
then
it's
going
to
set
the
on-chain
state
variable
to
that
squared
value.
So
in
essence,
what
this
is
doing
is
exactly
what
we
described
on
a
few
slides
ago,
which
is
it's.
It
is
a
method
on
the
smart
contract
that
can
be
called
only
with
the
square
of
the
current
state
variable.
C
So
as
long
as
you
provide
the
square
of
the
current
state
variable,
this
assertion
here
x,
dot
squared
dot,
assert
equals
squared,
is
going
to
pass,
and
then
it
will
allow
us
to
get
through
to
this
line.
The
final
line,
which
sets
the
sets
the
on-chain
state
to
that
squared
value
and
the
methods
of
a
smart
contract
just
like
in
ethereum,
basically
describe
how
it
can
be
invoked
when
you
deploy
when
you
deploy
it.
C
So
just
a
note
on
you
know:
what's
public,
what's
private
the
state
of
a
snap
that
is
what's
defined
with
these
state
variables
is
public
it's
on
chain
and
it's
public
unless
it's
explicitly
stored
as
a
commitment
to
the
state.
So
you
know,
for
example,
a
very
common
pattern
would
be
to
store
on
chain
the
root
of
a
merkle
tree,
and
then
you
know
that's
like
a
commitment
to
the
state.
It's
hidden.
C
Now,
what's
private
any
argument
to
a
method,
oops,
sorry,
any
argument
of
a
method
is
private.
This
comes
from
the
zero
knowledge.
That's
that's
used
here
unless,
for
example,
a
method
like
takes
that
argument
and
then
stores
it
into
state,
then
it
would
become
public,
but
we'll
see
examples
later
on
of
where
it's
very
clear
kind
of
like
how
the
method
you
know
how
the
arguments
of
methods
are
are
private.
C
So
just
a
note
on
this
async
here
next
to
the
definition
of
update
the
update
method
is
async
because
it
calls
dot
get
so
it
goes
to
the
chain
and
grabs
the
value
from
the
chain,
and
so
that's
why
it
has
to
be
async,
because
you
know
we're
actually
running
this
off
chain.
So
this,
like
fetch
of
like
going
to
the
chain
and
and
grabbing
the
value
from
it,
is
going
to
be
async
and
we
can
use
this
really.
Nice
async
await
syntax
and
javascript
to
make
that
nice.
C
B
C
A
C
C
C
Actually
it's
not
async
and
the
reason
for
that
we
will
understand
in
the
next
slide,
so
I'm
gonna
go
to
the
next
slide
and
then
we
can
try
and
understand
that
a
little
bit.
So,
let's
think
deeply
about
what
happens
when
we
call
on
this
snap
in
terms
of
what
is
the
actual
zero
knowledge
proof
that
we
do.
What
is
it
that
we
actually
prove
here's
what
we
prove
quote.
C
So
I
think
jason
covered
this.
A
little
bit
when
we
actually
run
a
snap,
what
we're
doing
is
we're
generating,
like
updates
to
the
on-chain
state,
given
some
preconditions
and
then
those
preconditions
will
be
checked
on
chain
before
the
snap
transaction
is
actually
applied.
So
this
answers
the
question
of.
Why
is
set
not
async,
because
actually
it's
more
like
proposed
setting,
so
you
know
we're
kind
of
in
a
fantasy
world
on
our
own
local
computer.
We
can
do
whatever
we
want.
C
C
C
Okay,
so
now
we're
gonna
recall
that
we
downloaded
the
git,
repo
and
npm
and
stuff
and
we're
gonna
run
hello
world,
and
this
is
as
simple
as
running
the
following
command.
We
wanted
to
kind
of
show
you
what's
going
on
under
the
hood.
All
that
we're
doing
is
running
the
typescript
compiler
and
then
running
node
on
the
resulting
file.
So
I'm
going
to
paste
this
command
into
the
chat.
C
B
A
I
guess
I'll
isaac
did
I'll
reiterate,
so
why
is
set
not
awaited,
and
the
reason
is
that,
because
the
smart
contract
executes
locally
in
the
web
browser,
we
wouldn't
want
to
set
the
states,
while
that
smart
contract
is
being
updated
because,
let's
say
the
user
never
says
the
transaction
to
the
chain
or
the
transaction
is
rejected
by
the
chain.
You
don't
want
to
have
updated
it
during
the
contract
execution.
A
So
instead,
when
the
smart
contract
executes
it,
outputs,
both
a
proof
and
a
list
of
associated
state
updates
inside
a
little
more
detail,
these
state
updates
are
also
passed
as
one
of
the
inputs,
while
the
proof
is
generated.
So
when
both
these
pieces
are
sent
to
the
chain,
we
know
by
having
passed
them
in.
We
know
that
those
state
updates
are
are
valid
and
accurate
for
that
proof
in
that
transaction.
A
And
then,
if
that
proof
passes
on
chain,
we
know
that
the
transaction
is,
is
appropriate
and
has
run
the
proper
expected
code
as
well,
and
then
we
can
update
the
state
at
that
time.
So
it's
the
the
state
update
is
occurring
when
the
transaction
arrives
at
the
chain
and
not
during
the
execution
in
the
browser.
So
that's
why
it's
not
weighted
in
the
browser.
A
C
A
Possible,
oh,
what
a
pain
is
this
the
eight
field
array
publicly
visible
on
a
blockchain?
Yes,
it
is
so
what
the
question
is
about.
Is
we
have
eight
fields
of
32
bytes
of
on-chain
storage
right
now,
it's
arbitrary
in
the
sense
that
the
snap
developer
can
choose
what
data
they
want
to
store
there
and
one
thing
that
we're
exploring
for
the
future
additionally
is
using
off
chain
states.
A
B
A
Yes,
oh,
let's
also
explain
a
little
more
about.
I
saw
a
good
question
earlier
about:
where
does
the
smart
contracts
execute?
Where
does
the
contract
code
live?
So
we
mentioned
it,
it
executes
in
the
web
browser
and
then
a
snap.
It
equates
in
our
terminology,
equates
to
the
user
interface
plus
a
smart
contract.
So
as
an
analogy,
let's
say
that
you
go
to
the
uniswap
website,
there's
a
user
interface
for
people
to
interact
with
it.
A
So
the
developer
sends
that
smart
contract,
javascript
and
wism
code
with
their
website
and,
if
you're
concerned
about
security
with
this,
just
remember
that
we're
generating
as
your
knowledge
proof
so
that
zero
knowledge
proof
will
only
be
accepted
by
the
chain
if
it
matches
to
the
perimeter
function
to
the
code
that
that
developer
had
deployed.
So
you
don't
have
to
worry
about
security
risks
in
that
at
all.
But
so
where
does
the
code
live?
The
smart
contract
code
itself?
It
just
lives
as
part
of
the
developer's
website,
the
javascript
okay.
A
Value
is
sent
to
the
chain.
How
long
is
it
stored
there?
So,
let's,
let's
say
when,
when
state
is
updated
on
a
snap
account,
how
long
does
it
remain
there,
because
that's
how
volumes
would
be
stored
right
permanently,
so
it
will
remain
in
the
the
on-chain
storage
will
remain
there
permanently
and
also.
A
How
the
mean
of
blockchain
works?
We
have
the
recursive
zero
snark,
which
represents,
I
like
to
call
it
the
source
of
truth.
It's
what
allows
people
to
interact
with
the
node
without
having
to
download
the
entire
history,
but
that
history
is
still
available
through
other
node
operators.
We
call
them
archive
node
operators
and
they
have
the
opportunity
to
to
to
store
it
in
any
different
location.
It's
really
their
choice,
and
but
that
has
the
the
full
history.
B
B
And
so
jason
you
and
I
need
to
bounce
off
so
that
we
have
the
full
screen
for
folks
to
see
that
yeah,
it's
a
bit.
Sometimes
it's
a
bit
tricky
to
look
at
codes.
Also,
just
maybe
pay
attention.
You
can
close
the
chat.
If
you
want
your
screen
to
be
a
little
bit
bigger,
you
can
also
make
it
full
screen.
Okay,.
C
I'm
gonna
jump
off
too
cool
yeah.
Just
let
me
know
if
it's
hard
to
see
so
right.
So,
okay,
everyone
ran
in
hello
world.
That's
really
great.
It
looks
like
everyone
got
their
expected
output
and
I
just
wanted
to
kind
of
run
through
with
everyone
what
it
looks
like
to
actually
call
the
smart
contract.
C
So
first,
the
first
thing
that
we
do
is
we
set
the
kind
of
active
instance
of
mina
that
we're
using
could
be
this
local
mock
blockchain
just
for
testing,
and
you
can
see
like
the
vs
code,
support's
really
nice,
so
we
can
hover
over
local
blockchain
and
we
get
we
get
this
doc
comment.
Okay,
so
local
blockchain,
a
mock
mean
a
blockchain
running
locally
and
useful
for
testing
great.
That's
what
we're
doing
then
we're
gonna
set
the
active
instance.
Just
this
local
one.
C
So
meena.transaction
is
how
we
actually
like
create
a
snap
transaction
and
within
the
function
that
we
provide
to
mean
about
transaction
is
where
we
actually
run
our
computation.
So
what
we're
going
to
do
inside
of
this
first
transaction
is
just
deploy
the
snap.
So
how
that's
going
to
work
is
we're
going
to
basically
create
a
transaction
that
involves
that's
sent
involving
account
2.
C
account.
2
is
going
to
send
this
amount
and
the
way
that
it
sends
it
is
just
by
decrementing
its
own
balance
by
that
amount,
and
then
we're
going
to
call
new
up
with
our
snap
class,
with
the
the
given
amount,
the
public
key
that
we
defined
and
the
initial
state
for
the
snap
which
we
defined
to
be
three.
C
So
that
is
how
we
initialize
the
snap
instance,
and
then
we
called
you
know
that's
going
to
give
us
a
transaction,
we'll
call
that
send
on,
and
then
we
wait
for
that
transaction
to
be
sent
next
thing.
We're
going
to
do
is
create
a
new
transaction
for
updating
the
snap.
Again
we
call
media.transaction
within
that
we
can
call
our
snap
method
update
and
provide
the
square.
C
So
we
do
snap
instance.update
with
the
squared
value
and
then
we're
going
to
do
a
failed
update,
which
a
lot
of
you
already
noticed
so
we're
going
to
try
and
call
update
with
the
wrong
value
109
and,
as
people
pointed
out,
this
is
going
to
fail
because
109
is
not
9,
squared
and
yeah.
So
that's
kind
of
how
the
hell
world
looks
and
now
with
that,
I'm
going
to
return
to
the
slides.
So
one
second.
C
Cool,
can
we
see
that
yep
so
back
to
the
exercises?
So
now
that
we
have
seen
hello
world
and
we
have
kind
of
a
feel
for
how
snap
accounts
look
and
snap
transactions
look
we're
gonna
do
a
few
exercises
together
and
I
just
want
to
call
out
how
to
kind
of
get
a
sense
of
the
api.
So
there's
two
good
ways
of
doing
that.
C
One
is
we
have
an
api
reference
api
reference
docs
available
here
at
this
url,
and
you
can,
you
know,
go
through
the
slides
to
grab
this
url,
but
the
other
way,
that's
really
good,
is
just
by
using
autocomplete.
So,
as
I
mentioned,
we
have
really
good
vs
code
integration,
because
it's
just
typescript
and
on
anything
you
know
any
any
value
you
can
just
type
you
know
period
and
to
see
all
the
methods
and
vs
code
also
shows
comments.
So
there's
inline
documentation
as
well
all
right.
C
So
let's
do
our
first
exercise
together.
This
will
be
a
little
bit
of
a
warm-up,
as
we
kind
of
went
over
already
we're
going
to
be
using
a
mock
media
environment
that
just
runs
locally,
and
our
first
exercise
is
going
to
be
the
following.
So
open
the
file,
one
underscore
exercise,
dot,
ts
it's
in
source
and
what
we're
going
to
do
here
is
input
is
implement
update
so
that,
instead
of
setting
x
to
its
square,
we're
going
to
set
x
to
its
cube.
C
C
C
Your
unsure
is
asking
how
to
finish
so
right.
Yeah
just
do
the
to-do
in
the
file.
So,
if
you
open
sorry,
if
you
open
one
underscore
exercise.ts
you'll
see
online
25,
I
believe
that
there
is
an
error
and
the
goal
is
to
basically
update
update
this
method
so
that
similar
to
exercise
one
where
we
set
the
value
to
x,
squared
instead
set
it
to
x,
cubed.
C
C
C
Our
next
exercise
is
going
to
just
explore
hashing
in
smart
js,
just
to
get
a
little
experience
with
the
api,
so
you
can
open
the
file
to
exercise
dot
yes,
and
what
what
you're
going
to
do?
There
is
use,
use
the
function
poseidon.hash,
which
is
provided
by
snarky.js,
so
that
x
is
set
to
instead
of
being
set
to
its
cube,
it's
going
to
be
set
to
its
image
under
the
poseidon
hash
function.
C
C
B
C
It
does
seem
there's
some
bug
in
the
example
code,
because
it's
not
setting
the
value
to
the
correct
poseidon
value.
It's
actually
just
setting
it.
It's
not
sending
it
at
all.
It's
actually
feeling
adopted
it.
I
think
so
we'll
return
to
that
later,
but
it's
annoying
all
right,
oh
so
luca
asks.
Can
we
see
the
solution
anywhere?
Yes,
two
things.
If
you
ever
want
to
see
the
solution
there
is
a
branch
called
solve,
and
so
you
can
just
check
out
the
solved
branch.
C
So
in
this
exercise
you
have
to
call
the
side
of
the
hash
function
and
notice
that
it
takes
an
array
of
field
elements,
so
you
just
pass
it
in
an
array
of
field
elements
and
set
x
to
that
value.
But,
as
I
mentioned,
something
funny
is
going
on,
because
the
correct
value
should
be
this,
which
is
just
the
hash
of
three
with
poseidon.
But
for
some
reason
it's
not
updating.
So
I
guess
a
last
minute
update
just
to
the
this
workshop
code
introduced
some
bug
somewhere.
So
I
apologize
it.
C
C
B
A
C
C
So
if
you
look
at
how
this
is
actually
used
in
the
transaction
that
where
we
call
update
we're
able
to
create
another
account
corresponding
to
account
2
and
then
we
can
do
winner.balance.add
in
place
the
same
reward
and
the
reason
this
works
is
when
we
run
this
transaction,
it
checks
that
all
of
the
changes
to
the
balances
sum
up
to
zero.
So
what
that
means
is
nomena,
is
created
or
destroyed,
and
and
and
so
it's
a
valid
transaction.
C
Someone
asked:
how
do
you
burn
mina?
Is
there
a
burn,
address,
florian
replies?
You
can
use
my
address
as
a
burner
dress.
So
if
anyone
wants
to
burn
mina,
just
send
it
to
florian
cool
all
right,
moving
on
great
so
just
to
kind
of
review
the
payments,
you
basically
use
the
balance,
dot,
add
in
place
and
got
balance
that's
up
in
place
and
that's
how
you
can
move
me
around
between
accounts
and
then,
as
I
mentioned,
all
balance
changes
in
a
transaction
have
to
sum
to
zero.
C
Okay,
so
exercise
four
is
just
going
to
explore
how
you
can
use
functions
and
loops
in
snarky.js.
So,
as
I've
mentioned
in
snarky.js,
we
can
just
define
normal
typescript
functions
and
we
can
also
use
normal
for
loops.
So
what
that
looks
like
is
just
a
javascript
or
typescript
for
loop.
You
know
here's
a
for
loop,
for
example,
and
it's
you
can
you
can
use
it
just
as
well
on
snarky.js.
C
So,
for
this
exercise
open
the
file
for
exercise.ts
and
in
that
file.
There's
a
function
called
hash
n
times
and
the
idea
of
this
function
is
is
it
should
provide.
It
should
apply
the
poseidon
hash
function
n
times,
so
you
give
it
a
number
n
and
an
input,
and
it
should
hash
that
input
n
times
and
you
should
use
a
for
loop
to
well
or
whatever
you
want.
Maybe
you
could
also
use
recursion,
I
guess
to
implement
that
function.
We
use
normal.
C
C
So,
for
this
exercise
open
the
file
for
exercise.ts
and
in
that
file,
there's
a
function
called
hash
and
times
and
the
idea
of
this
function
is
is
it
should
provide.
It
should
apply
the
poseidon
hash
function
n
times,
so
you
give
it
a
number
n
and
an
input,
and
it
should
hash
that
input
n
times
and
you
should
use
a
for
loop
to
well
or
whatever
you
want.
Maybe
you
can
also
use
recursion.
I
guess
to
implement
that
function.
C
Double
b
said:
I
can
run
three
without
a
balance.
Actually,
yes,
so
in
the
mock
mena
environment,
it
doesn't
enforce
that
that
the
sum
is
exactly
zero.
I
believe
that
it
enforces
that
it
said
that
it's
greater
or
that
no
meena's
created,
but
it's
possible.
You
actually
can
burn
mina
in
the
mock
environment
on
chain.
You
cannot
earn
mena.
C
A
C
C
Okay,
so
let's
see
philip
was
I'm
just
gonna.
Go
back
to
philip's
question
to
me.
It
seems
like
exercise
three,
only
subtracts
smart
contract
balance
so
that
in
the
same
transaction,
anyone
can
claim
that
subtracted
balance.
But
is
there
a
way
for
the
smart
contract
to
limit
the
balances
that
the
reward
can
be
sent
to?
Yes,
you
can
you
can?
C
C
C
Res
result
to
x,
and
then
we
write
a
simple
for
loop,
so
let
I
equal
zero
oops,
I
is
less
than
m,
plus
plus
I
and
then
we're
going
to
say
res
is
equal
to
sine
n
dot
hash,
and
then
we
need
to
provide
an
input
and
we're
going
to
provide
res.
So
we
hash
ourself
n
times,
and
then
we
just
return
that
and
then,
when
we
run
it,
we
get
as
well.
C
First
there
was
to
do,
but
then
we
get
as
people
have
been
posting
in
the
chat,
this
value
ending
in
864..
So
that's
the
result
of
hatching
the
initial
state
value
into
itself.
10
times
cool,
oh
yeah,
you
know
sure,
has
their
recurs
recursive
example.
I
guess
we
could
do
that
too.
That's
pretty
cool.
A
C
C
C
Alright,
so
in
this
exercise,
we're
going
to
learn
a
little
bit
about
how
to
kind
of
implement
logic.
So
one
of
the
most
important
things
for
implementing
you
know
logic.
I
guess
business
logic
is
this
bull
class,
so
bool
differs
from
the
type
boolean,
so
in
typescript,
there's
a
type
called
boolean,
which
is
the
normal
boolean
type.
True
and
false
bool
is
a
little
bit
different.
It's
booleans
that
can
be
used
inside
of
zk
snarks,
so
they're
very
similar
to
normal
booleans.
C
We
have
the
kind
of
typical
boolean
methods,
you
can
call
dot
and
you
can
call
dot
or
you
can
do
dot
not
to
negate
it.
But
you
cannot
use
bool
in
an
if
statement
so
boolean
you
can
use
in
an
if
statement
bool
for
button
not
allowed
to
use
an
if
statement.
Instead,
you
have
to
use
this
kind
of
ternary
construct,
which
we
call
circuit.if
and
what
that
does
is
it
takes.
It
takes
either
a
bool
or
a
boolean
and
two
values
like
a
then
and
an
else,
and
it
returns
a
value.
C
So
if
the
bool
is
true,
then
it
will
return
the
first
branch
if
it's
false,
it
will
return
the
second
branch-
and
this
is
something
which
you
may
have
seen
in
other
presentations,
which
many
proof
systems,
including
kimchi.
Currently,
although
that
very
very
well
might
change
in
the
future,
does
not
really
support
branching
in
terms
of
execution,
it
supports
sort
of
branching
in
terms
of
values.
C
C
C
C
All
right,
five
exercise,
all
right,
so
the
first
thing
we're
going
to
do
is
define
a
type
so
in
snarky.js
I
I
said
that
any
value
that
you
want
to
use
as
an
argument
to
a
method
has
to
have
has
to
somehow
be
built
out
of
field
elements
and
concretely
what
that
means
in
snarky.js.
Is
you
extend
this
circuit
value
class?
C
So
if
you
want
to
have
your
own
type
that
you
can
use
as
an
argument
to
method,
you
extend
the
circuit
value
class,
and
so
this
is
just
going
to
be
a
simple
type.
That's
going
to
represent
a
signature
along
with
the
signer
of
that
signature,
so
it's
just
going
to
be
a
class
that
has
two
pieces
of
data,
signature
and
signer
a
signature
and
a
public
key.
C
Now,
let's
look
at
the
smart
contract
itself.
It's
going
to
have
a
parameter,
which
is
the
list
of
owners
of
the
account,
so
we're
going
to
do
one
out
of
n
multisig
against
some
list
of
owners
and
that's
simply
going
to
be
an
array
of
public
keys
now
notice.
This
is
not
a
state
variable,
but
a
contract
parameter.
So
what
that
means
is
this
list
of
owners
is
not
stored
on
chain.
C
C
C
C
C
B
C
C
Okay,
so
that's
the
logic
of
how
this
multisig
works
and
just
to
explain
a
little
bit
well,
actually,
let
me
go
back
to
sharing
just
to
explain
a
little
bit
how
zero
knowledge
comes
into
play
into
play
here.
As
I
said,
all
the
meth,
all
the
arguments
to
a
method
are
by
default,
private,
and
so
what
that
means
is
this
signature
and
the
public
key
along
with
it
is
totally
private.
C
So
all
the
logic
of
how
this
works
is
also
can
also
be
totally
hidden,
all
right
so
for
this
exercise,
what
you're
going
to
want
to
do
is
implement
this
contains
public
key
function
and
what
I
recommend
is
check
out
the
methods
on
public
key
and,
in
particular,
check
out
this
equals
method.
So
this
takes
another
public
key
and
returns
a
boolean
checking
if
they're
equal
so
see.
If
you
can
see
if
you
can
use
the
equals
method
to
check
that
this
public
key
x
is
equal
to
some
element
of
this
array.
C
A
C
So,
let's,
let's
take
a
look
here:
hey
jason
asks
a
good
question
and
jason
gave
a
good
answer.
Abel
b's
question
was
so
the
availability
of
such
list
of
public
keys
is
on
behalf
of
the
client
and
could
be
lost
forever.
Indeed,
to
quote
jason
in
isaac's
example.
That's
me,
he
chose
that's
me.
I
chose
to
maintain
the
privacy
of
the
list
of
public
keys.
Alternatively,
you
could
store
it
on
chain
if
desired,
but
it
wouldn't
be
private.
A
A
Result
in
a
smart
contract
that
doesn't
finish
execution
and
if
it
doesn't
finish
execution,
you're
not
going
to
generate
the
zero
knowledge
proof
or
the
transaction.
So
you
end
up
in
a
state
where,
if
you
have
a
broken
smart,
smart
contract,
the
developer
would
need
to
fix
their
code
and
redeploy
in
order
to
have
successful
user
interactions
again.
B
C
C
C
C
C
C
Typescript's
type
system
is
very
powerful,
and
this
can
enable
us
to
you
know,
program
in
a
really
nice
way.
For
example,
we
can
write
a
generic
version
of
the
contains
public
key
function,
which
would
check
that
anything
is
contained
in
a
list
as
long
as
it
implements
this
eek
interface
that
I
defined
right
here.
So
this
function
can
take
a
list
of
anything,
an
array
of
anything
which
implements
the
eek
interface
and
return
to
boolean,
and
it
works
in
exactly
the
same
way.
The
code
is
identical.
C
C
C
C
B
C
C
Don't
think
we
need
to
so
I'm
gonna,
I'm
gonna
go
to
the
end
of
the
presentation,
and
then
I
will
and
and
then
we'll
we'll
do,
questions
perfect
all
right.
So
we're
very
close
here.
Thank
you.
Everyone
you've
been
a
beautiful
audience
in
the
chat,
very
patient
and
as
a
little
as
a
little
treat
we're
going
to
talk
about
how
recursion
looks
like
in
snarky
jazz,
so
recursion
is
oh
recursion
is
a
very,
I
feel
like
currently
kind
of
an
arcane
thing.
C
So
what
I
mean
by
that
is,
it's
very.
It
seems
kind
of
complicated
and
like
specialized,
and
you
know
blah
blah.
So
what
is
recursion?
It's
verifying
zero
knowledge
proofs
inside
of
a
zero
knowledge
proof-
and
this
is
a
really
powerful
technique
because
it
lets
you
do
a
lot
of
things.
For
example,
like
implementing
roll
ups
zk
roll
ups
is,
is
really
easily
done
using
recursion
and
a
lot
of
the
teams
that
are
implementing
zika
roll-ups.
Do
it
using
recursion,
but
it's
really
complicated
and
you
know
kind
of
hard
to
get.
C
Around
and
really
hard
to
implement
because
it
requires
all
this
crazy
cryptography
and
in
snarky.js
we.
This
is
not
yet
fully
public
publicly
available,
but
we
have
an
interface
for
making
recursion
a
snap
which
is
an
idiom
meaning
making
it
very
easy,
and
we
can
it's
so
easy
that
you
can
define
a
simple
zk
row
up
in
like
only
150
lines
of
code.
So
let
me
show
you
what
that
looks
like
if
you
open,
if
you
open
in
the
repo
this
bonus
file,
you
can
get
a
feel
for
it.
C
It
makes
defining
this
under
the
hood.
This
uses
recursion,
but
it
can
be
defined
really
simply
and
easily,
so
this
rollup
is
going
to
be
like
defined
as
a
proof
system,
and
it's
going
to
have
sort
of
three
three
branches
to
that
proof
system,
one
for
processing
deposits
into
the
roll-up
one
for
transacting
on
the
roll-up
and
one-
and
this
is
where
the
recursion
comes
in-
for
combining
two
proofs
together
to
get
a
single
proof.
C
So
this
is
kind
of
the
magic
secret
sauce
of
recursion
is
that
you
can
combine
proofs
together
to
this.
This
takes
two
different
roll-up
proofs
and
returns
a
roll-up
proof,
and
this
is
actually
a
lot
home
like
how
mena
works
so
the
logic
for
merging
two
two
things
and
don't
worry
if
this
is
confusing,
because
well
it's
just
supposed
to
be
cool.
C
C
It's
really
nice
and
simple,
and
I
hope
you
know
we'll
see
a
lot
of
cool
applications
of
recursion
because
it's
been
something
to
this
point.
That's
been
really
specialized
and
not
really
available
for
developers
to
play
with,
so
that
should
be
cool,
and
this
kind
of
goes
back
to,
I
think,
a
question
I
can't
remember
who
asked
it,
but
about
kind
of
defining
peer-to-peer,
zk
roll
ups.
Well,
you
can
implement
something
very
similar
to
this
and
you
know
it
could
run
in
a
browser.
It
could
run
on.
C
C
Yeah
yeah
yeah
and
just
let's
just
wrap
up
here
so
there's
a
couple
things
we
didn't
cover
one
is
we
didn't
cover
how
you
interact
with
the
mean
of
state,
for
example
like
getting
the
current
block
height
or
like
current
timestamp,
to
do
things
with
time
and
that's
pretty
simple,
but
we
didn't
cover
it.
So
you
know
sorry,
you
can
read
the
docs.
C
We
also
didn't
cover
the
whole
api.
That's
provided
in
the
standard
library,
for
example,
group
operations
and
operations
with
merkle
trees,
which
is
really
useful
for
kind
of
interacting
with
off-chain
storage
and
yeah.
So
that's,
unfortunately,
we
didn't
cover
check
out
the
docs
or
you
know
future
presentations
of
ours
and
if
you're
in
the
meena
builders
program
or
coming
to
boot,
camp,
see
you
soon
and
we'll
talk
about
some
of
these
things
and
yeah.
A
C
If
you
go
to
mediaprotocol.com.js,
I
believe
there
is
a
feedback
form
if
you
want
to
provide
any
feedback
or
help
shape
the
future
development
of
snarky.js,
and
otherwise
we
have
our
links
on
github
where
to
follow
us
on
twitter
and
how
to
you
know,
join
our
discord
where
you
can
come
chat
about
snaps.
So
thank
yous.
Everyone
you've
been
a
beautiful
audience
and
now
we're
gonna.
I
guess,
do
questions.
B
And
do
stick
around
because
we
are
doing
the
closing
ceremony
of
the
ck
hack
right
after
this,
but
we
still
have
20
minutes,
and
I
know
that
there
was
a
lot
of
questions
and
a
lot
of
them
got
answered.
But
it
might
be
interesting
for
our
video
viewers
to
actually
hear
some
of
those.
So
even
if
there's
answers
on
some
of
these
in
the
q,
a
potential
wondering
jason,
I
mean
I
think,
jason
and
isaac
you'll
be
able
to
pick
out
the
really
kind
of
good
ones.
But
I
think
it'd
be
great.
A
A
So
a
couple
couple
things
are
done
differently
and
one
is
you
instantiate
a
bool
using
new
bull
as
opposed
to
javascript's
new
boolean?
So
that's
one
and
then
secondly,
there's
not
turn
standard
ternaries
are
not
supported
inside
of
a
stark,
so
we
have
circuit
dot
if
to
to
provide
provide
that,
as
as
isaac
discussed.
C
I'm
just
going
to
take
another
question
here,
so
this
was
I'm
just
going
through
questions
in
the
q,
a
a
lot
of
them
already
answered,
but
I'm
going
to
try
to
add
some
a
little
bit
of
extra
to
them.
So
jeff
asked
with
tools
like
snark,
snark,
js,
plus
circom.
That's
another
tool,
there's
a
limit
to
the
number
of
constraints
with
the
was
improved
generator,
something
like
1
million
other
analogous
proof
limitations
here.
C
So
yes,
actually,
so
there
is
a
limit
to
the
number
of
constraints
that
you
can
use
in
a
single
method.
It's
a
bit
like
the
gas
block
limit
in
ethereum.
So
there's
a
limit
to
what
you
can
use
in
one
method,
but
you
can
have
as
many
methods
as
you
want
and
that
you
know
all
have
up
to
that
limit
and
as
mentioned
by
brandon,
you
can
also
use
recursion
to
have
an
arbitrarily
large
computation.
C
So,
typically,
you
know
what
a
computation
looks
like
is
not
a
random
giant
circuit,
but
something
with
a
lot
of
structure.
That's
kind
of
repeated
and
if
you
use
recursion,
then
you
can
you
can
you
can
do
this
and
you
can
even
actually
have
arbitrary
kind
of
structure
too.
But
it's
it's
a
little
more
involved.
C
Let's
see
moving
on,
let's
see
so
fabrizio
asks.
Do
you
have
to
use
the
extra
circuit
size?
Even
if
you
did
not
use
recursion,
I'm
not
exactly
sure
what
the
question
is,
but
no
you
don't
need
to
use.
You
use
what
you
pay.
You
pay
for
what
you
use.
So
if
you
don't,
you
know,
go
up
to
the
max
limit
of
constraints.
You
don't
you
don't
really
pay
for
that.
C
Okay
vm
asks
which
hash
functions
are
supported
for
verification
on
chains.
So
currently
in
sarcoges,
the
only
thing
exposed
is
poseidon.
So
this
is
a
poseidon
hash
function,
that's
used
in
mina
and
that's
what
you
can
use
in
stark
jazz.
There
is
an
undergoing
you
know.
There
is
planned
work
to
implement
other
hash
functions
that
are
more
commonly
used
in
other
situations
like
shot
256,
for
example,
and
that
you
know
will
eventually
be
easily
available
in
snarky.js.
C
So
we're
currently,
you
know
finishing
up,
testing,
snaps
and
kind
of
you
know
making
sure
it's
it's
ready
to
be
deployed
in
maina,
and
you
know
there
should
be
an
announcement
sometime.
You
know
in
the
not
too
distant
future
about
you
know
what
kind
of
times
you
can
expect,
but
there's
nothing
publicly
announced
yeah,
let's
see
so
anonymous
asks.
Is
there
a
bridge
over
to
ethereum?
This
is
a
great
question.
C
There
is
a
bridge,
so
we
so
mina
foundation
has
been
working
with
a
theorem
foundation
and
nil
foundation
on
a
bridge
between
me
and
ethereum,
which
will
enable
mean
a
state
to
be
verified
on
ethereum
and
that's
really
cool
because
it
uses
the
succinctness
of
mina
to
just
verify
the
full
mean
of
proof
and
the
full
mean
of
blockchain
in
ethereum.
So
you
get
basically
a
bridge
with
like
full.
C
C
C
C
Basically,
when
you
try
and
generate
the
proof,
so
when
you
try
and
run
the
contract
locally,
it
will
fail.
If
you
do
something,
that's
not
allowed
like
for
money
out
of
thin
air,
and
you
know
yeah,
so
that's
kind
of
that.
But
if
you
somehow,
you
know,
created
a
proof
like
circumvented,
what's
going
on
in
smart.js
and
created
a
proof
if
you
broadcast
to
the
network
it
would,
it
would
fail
at
that
point,
because
the
network
would
see
oh
you're
trying
to
put
money
out
of
thin
air.
That's
not
allowed.
C
A
C
C
C
C
C
The
answer
is
not
exactly
because
the
hash
function
needs
to
be
needs
to
be
redefined
to
work
with
the
types
of
snarky
js,
so
it
would
need
to
be
redefined
to
accept
field
elements
or
bool
as
input,
and
for
that
we
would
need
to
you
know
you
need
to
re-implement
it
either
directly
in
constraints
using
snarky.js
or
what
we
are
planning
on
doing,
which
is
actually
integrating
it
into
our
kimchi
proof
system
itself.
So
it's
available
very
efficiently.
C
Okay,
so
francesco
asks
any
plans
to
reduce
block
time
and
introduce
deterministic
finality.
That's
a
great
question.
It
is
something
that
you
know
where
that's
definitely
on
our
mind,
there's
no
concrete
plan.
Yeah,
that's
in
place
to
address
that,
but
I
I
you
know.
I
believe
you
should
stay
posted
on
that
because
I
think
you
know
that
will
be
something
that
is.
B
C
C
The
real
reason
is
amino
was
created
by
people
like
myself
who
have
their
own
history
and
you
know,
abilities
and
whatever,
and
you
know
I
guess
my
own
history
involves
writing
a
lot
of
o'camel
code
and
that
was
kind
of
the
the
reason.
I
guess
you
know,
realistically
speaking,
that
we
chose
a
camel,
but
I
think
ocam
was
a
very
nice
programming
language
and
you
know
good
for
writing
secure
code.
So
there's
all
sorts
of
reasons.
C
A
B
B
So,
thank
you
so
much
for
the
mina
session.
This
is
the
last
workshop
of
zk
hack.
It's
been
amazing
and
I
know
for
a
lot
of
people.
This
is
their
first
look
into
the
snaps
world
and
they're
so
excited
you
can
kind
of
get
that
from
the
crowd:
very
cool,
okay,
so
yeah
thanks
again
for
doing
this
session
and
people
have
asked
the
videos,
for
this
will
be
on
the
youtube
channel
as
soon
as
we
can
get
them
there.
So
ex
we've
shared
the
link.
B
Let
me
share
it
again
in
here
after
a
bit,
but
for
right
now,
if
you
can
head
over
to
the
stage
I'm
going
to
be
doing
sort
of
the
zika
hack,
wrap-up,
closing
ceremony,
where
we
look
at
you
know
the
six
weeks
and
the
prizes
that
some
of
the
hackers
have
gotten.
So
I
hope
you'll
see
me
there
and
yeah.
Just
remember:
there's
a
40-second
delay
on
that.
So
if
I'm
a
little
like
stumbly
with
the
with
the
chat,
I
apologize.