►
Description
In this video series, Caleb from Mina Foundation helps you learn how zero knowledge smart contracts work and how to write your own using TypeScript. In this video, you will learn how to create a zero knowledge proof. Creating zero knowledge proofs for your smart contract allows you to make applications that preserve data privacy by executing code off-chain. This reduces total storage requirements and compute requirements of the network.
Ready to start building zkApps?
Subscribe to Mina’s developer newsletter for tips to get you started: https://bit.ly/MinaDevsNewsletter
Need some inspiration?
See examples of real-world applications being built using zero knowledge: https://bit.ly/3O0FQFv
WHAT IS MINA?
Mina is the world's first ZK blockchain, powered by participants. Rather than apply brute computing force, Mina uses advanced cryptography and recursive zk-SNARKs to design an entire blockchain of about 22kb, the size of a couple of tweets. It is the first layer-1 to enable efficient implementation and easy programmability of zero knowledge smart contracts (zkApps). With its unique privacy features and ability to connect to any website, Mina is building a private gateway between the real world and crypto—and the secure, democratic future we all deserve.
FOLLOW!
📧 Monthly Newsletter: https://bit.ly/MinaNewsletter
🐤 Twitter: https://bit.ly/MinaProtocolTwitter
📢 Discord: https://bit.ly/MinaDiscord
💬 Telegram: https://bit.ly/MinaProtocolTelegram
💻 Website: https://minaprotocol.com
👋 Caleb: @codebreakthrough
#Crypto #Blockchain #ZeroKnowledge #MinaProtocol #zkApp #ZK #ZKP #blockchain #cryptotech #smartcontract #howto #coding #web3 #developer #javascript #typescript #codingtutorial #privacy #cryptography #programming #zeroknowledgeproof
A
Welcome
to
episode
4
in
your
ZK
app
Series,
this
video
we're
going
to
learn
how
to
create
a
zero
knowledge
proof
and
update
the
state
of
a
deployed
ZK
app.
The
way
we
have
it
now
we
have
one
key
pair,
which
is
a
private
and
public
key.
This
is
the
private
public
key
of
the
ZK
app
now
when
people
interact
with
the
ZK
app
they're
going
to
have
their
own
public
key
and
private
key.
A
You
need
to
generate
some
key
pair,
we'll
say
import
and
we're
just
going
to
need
private
key
from
snarky
Js,
so
to
create
a
private
key,
we'll
just
create
a
variable
and
say
private
key
dot,
random.
We
can
also
generate
the
public
key
from
this,
so
public
key
is
going
to
be
the
private
key
Dot
to
public
key.
A
So
we
have
the
private
key
in
public
key.
So
let's
go
ahead
and
just
output,
those
so
we'll
go
ahead
and
create
an
object
in
here
which
will
contain
the
private
key
and
the
public
key
now
I
wish.
We
could
leave
it
just
like
this,
we'll
need
to
make
one
little
change
and
I'll
explain
that
in
a
second.
But
let
me
show
you
what
this
will
do
we'll
say:
generate
dot,
JS
and
executing
this
code.
We
get
some
object.
A
So
if
you
remember
from
an
earlier
episode,
we
took
a
public
key
right
here
and
took
it
from
base
58
to
a
public
key
object.
We
now
just
need
to
reverse
that
process
and
when
you
do
that,
we're
going
to
need
to
actually
use
a
colon
here
and
say
private
key
dot,
two
base
58
same
thing
for
the
public
key,
we'll
just
say:
public
key
dot,
2
base
58..
A
Now
we
should
have
a
key
pair
and
anytime.
We
run
this
we'll
get
a
new
key
pair.
So
we'll
take
note
of
these,
what
you
could
do
is
inside
of
the
keys.
You
could
create
a
new
one
and
we'll
just
call
it
interact.json.
So
this
is
the
account
we're
going
to
use
to
interact
with
our
smart
contract.
So
let's
go
ahead
and
copy
that
value
and
paste
it
here
and
similar
to
how
we
funded
our
ZK
app
address
from
the
faucet.
We're
going
to
do
that
with
this
new
account.
A
A
So
we
only
need
to
import
that
so
the
account
private
key
and
I'm
just
going
to
copy
and
paste
it
so
we'll
copy
this
value,
paste
that
here
but
again
I'm
going
to
say
private
key
Dot
from
base
58..
So
let's
do
that
real,
quick
private
key
Dot
from
base
58
passing
in
this
value,
and
now
we
have
a
private
key
object.
A
We
can
work
with
we'll
also
say:
const
account
public
key,
and
this
is
going
to
come
from
the
account
private
key
dot
to
public
key
and
just
to
make
sure
we're
not
crazy
we're
going
to
console
log
this
and
make
sure
it's
the
same
thing
as
our
public
key
and
our
key
pair.
So
let's
go
ahead
and
say
account
public
key
dot,
2
base
58
to
the
format
in
our
key
pair,
and
then
we
will
run
this
with
the
interact.js
file
and
you
can
see
that
value
which
does
in
fact
match
with
this
here.
A
So
lesson
learned.
The
public
key
can
always
be
generated
from
the
private
key,
but
not
the
other
way
around.
So,
if
you're
going
to
do
anything
like
sending
transactions,
you're
going
to
need
that
private
key
and
let's
just
go
ahead
and
delete
that
we're
not
going
to
need
that
console
log
anymore
now,
the
next
step
we
need
to
do
is
say,
await
and
then
refer
to
our
smart
contract
and
say
compile.
This
is
required
to
create
zero
knowledge
proofs.
A
So
what
we're
going
to
do
is
wrap
what
we
want
to
do
in
a
transaction,
so,
let's
say
TX
for
transaction,
and
this
is
going
to
say
a
weight,
Mina
Dot
transaction.
This
will
take
a
few
arguments.
The
first
one
is
the
fee
and
the
fee
payer,
so
the
fee
payer
is
going
to
be
identified
by
the
sender
property
and
that's
where
we're
going
to
put
our
account
public
key.
So
that's
who
is
paying
the
fee?
A
The
second
thing
is
the
fee
property
which
we
will
set
2.1,
which
you
can
do
with
0.1
E9
as
we'll
actually
be
working
with
small
fractions
of
mina.
This
is
how
we
say:
0.1
Mina.
The
second
argument
here
is
going
to
be
a
callback
function
which
we
can
Define
in
line
here,
and
this
is
where
we
will
say
what
we
want
to
do
with
that
contract,
which,
in
our
case
is
invoke
the
update
method.
A
So
if
we
take
a
look
back
at
or
add.ts
file,
we
have
this
method
update,
which
will
update
the
state
and
add
2
to
it.
So
this
is
how
we're
going
to
do
that
in
our
interact
script
we
make
a
transaction
say
who's
going
to
pay
the
transaction
fee
and
the
amount
and
then
say
what
we
actually
want
to
do
on
that
deployed
ZK
app.
However,
if
you
take
a
look
at
this
update
and
go
to
its
definition,
you
can
see
all
this
code
is
local.
A
So
it's
going
to
execute
this
code
locally,
and
this
is
where
we
see
one
of
the
benefits
of
zero
knowledge
proofs,
the
zero
knowledge
proof,
the
validation
key,
that's
deployed
on
the
network
will
be
able
to
know
if
we
executed
this
code
correctly.
If
we
tried
to
modify
it
or
do
anything
funny,
it's
going
to
catch
that
and
the
verification
is
going
to
fail.
A
Now,
if
you
legitimately
want
to
change
your
contract
code,
you're
going
to
need
to
redeploy
to
update
that
verification
key
until
then,
any
changes
is
just
going
to
cause
all
of
your
proofs
to
be
invalid.
So
to
create
the
proof
we'll
say:
oh
wait,
transaction
dot
proof,
and
this
can
take
some
time
so
we'll
just
give
them
a
Hint
by
saying
proving
and
we'll
do
something
similar
for
the
compiling,
because
that
can
take
some
time
as
well.
So
we'll
paste
that
up
here
and
change
this
to
compiling.
A
A
So
let
me
go
ahead
and
copy
this
value
and
I'll
paste
that
here,
but
we're
not
going
to
have
proxy
and
I
think
instead
of
graphql
it's
going
to
be
transaction,
then
what
we
can
do
is
just
add
in
the
sent
transaction
dot
hash,
which
is
a
function
I
think
that
should
be
correct.
So
what
we
can
do
now
is
execute
this.
A
As
a
reminder,
this
is
going
to
take
some
time
so
we'll
see
these
messages
pop
up,
it's
currently
compiling
and
then
I
said
proving,
and
then
afterwards
it
dropped
us
the
URL
to
our
new
transaction.
So
let's
check
this
out
opening
this
in
the
Explorer
you
can
see
this
is
pending.
So,
given
enough
time,
this
should
confirm
all
right:
our
transaction
is
complete
and
if
we
now
take
a
look
back
at
our
deployed
contract
and
we'll
need
to
do
a
refresh
previously,
this
was
value
one.
A
Now
when
we
explore
the
state
you
can
see,
it
has
the
value
three
so
that
state
change
was
a
success.
In
other
words,
our
proof
was
valid,
taking
a
look
back
at
our
code
in
the
add.ts
file.
This
is
what
happened.
We
added
2
to
the
current
state,
which
is
why
we
ended
up
with
three.
Any
changes
to
this
code
will
create
invalid
proofs.
A
So,
even
though
the
deployed
system
is
really
just
a
verification
key,
it's
able
to
know
using
zero
knowledge
proofs,
whether
you
executed
the
code
correctly,
showing
the
case
where
we
change
this
to
some
other
value
and
then
re-executing
our
interact
script,
we'll
again
wait
for
this
process
and
see
that
we
got
an
invalid
proof.
This
can
all
be
a
slow
process,
so
there
is
a
way
to
do
this
faster
locally
in
the
that's
what
we're
going
to
be
talking
about
in
the
next
video.
Hopefully,
this
video
was
helpful.
A
You
should
now
have
a
decent
understanding
on
building
zero
knowledge
proofs
locally
and
then
sending
them
to
the
network
for
our
ZK
app
to
verify.
If
the
proof
is
valid,
meaning
you
executed
the
code
all
correct,
then
the
State
updates
will
happen.
If
the
proof
is
invalid,
then
nothing
happens.
This
shows
the
basics
of
zero
knowledge
proofs,
but
you
can
do
so
much
more
once
you
start
dealing
with
sensitive
data
stay
tuned
for
the
next
one.
Where
we're
going
to
talk
about
improving
development,
speed
using
local
blockchain.