►
From YouTube: Learning about Zero Knowledge Proofs in 2 months & Building a ZK App on the Mina Protocol 🔥
Description
Curious about Zero Knowledge Proofs but you haven't spent time learning about it yet? In this video, Jen and I present our apps that use zero knowledge proofs on the Mina Blockchain. We built these apps as part of a programme, hosted by O1 Labs, which taught how to build ZK apps on the Mina Protocol.
These apps were created with Typescript and we were both new to zero knowledge proofs and building with SnarkyJS prior to this programme.
What do you think about Zero Knowledge Proofs?
Some ZK writings by moi here https://medium.com/@alysiatech/learning-about-mina-as-a-developer-part-1-what-is-a-zkapp-how-to-create-one-f1f49bb2df49
00:00 Context
00:16 YK Proof (Alysia)
15:30 ZK Schinzelhunt (Jen)
Schnitzelhunt (Jen)
https://github.com/jenpaff/zk-schnitzeljagd
https://twitter.com/jenpaff
YK Proofs (Alysia)
https://github.com/alysiahuggins/code-on-chain-with-mina
https://alysiahuggins.github.io/code-on-chain-with-mina/ (You need an Auro Wallet on the Berkeley Testnet with Testnet Mina if you'd like to use YK Proofs)
https://links.alysia.tech
https://lenster.xyz/u/alysiatech
(Sorry for the video quality, this was recorded by Google Meet)
A
This
video
is
a
presentation
conducted
by
Jennifer
and
myself,
where
we
show
what
we
created
as
part
of
the
ZK
app
Builders
program.
In
this
program
we
learned
how
to
utilize
zero
knowledge.
First
and
smart
contrast
on
the
main
blockchain
I
definitely
recommend
the
zkl
builders
program.
If
you're
curious
about
ZK,
let's
look
at
the
presentations
say:
hi
everyone.
This
is
my
presentation
as
part
of
the
Z
key
Builders
program
with
the
mean
of
protocol
and
my
application
that
I
built
at
the
end
of
this
protocol
is
called
proof
of
knowledge.
A
So
a
lot
of
times,
you
have
to
prove
that
you
know
something
whether
or
not
you
have
to
prove
that
you
understand
investing
Concepts,
you
can
be
an
accredited
investor
or
you
may
need
to
prove
that
you
know
some
knowledge,
so
you
can
get
access
to
a
job
or
an
interview.
Now,
when
you
prove
your
knowledge,
there
are
many
different
places
where
that
can
be
stored.
A
The
point
of
this
application
is
to
prove
your
knowledge
and
that's
why
it's
called
YK
proofs,
which
is
your
knowledge
proved
on
chain,
so
I
will
be
using
the
Mina
blockchain
for
this,
and
the
reason
why
the
mean
of
blockchain
is
used
is
because
we
can
take
advantage
of
the
ZK
apps
and
by
creating
a
ZK
app,
we
can
get
private
inputs
now.
This
is
really
important
because,
since
you're
proving
your
knowledge
on
chain,
the
transactions
that
you
send
will
contain
normally
will
contain
revealing
information
such
as
your
answer
for
a
particular
quiz.
A
So
once
one
person
gets
the
question
correctly,
anyone
can
go
back
and
look
at
the
blockchain
history
and
see
the
answer
to
the
question.
But
by
using
a
zero
knowledge
proof
we
can
have
private
inputs,
which
is
very
important
for
application
success,
because
that
way,
you
can
prove
that
you
know
the
answer.
With
all
that
information
being
leaked,
we
also
have
on-chain
proofs.
A
We
can
also
store
large
data
sets
using
something
called
Miracle
trees
on
Mena,
and
we
also
benefit
from
lower
transaction
fees,
because
a
lot
of
the
competition
is
done,
offline
or
off
chain,
I
should
say,
and
then
you
just
send
your
proof
to
the
chain,
which
is
the
mean
of
blockchain.
So
let's
go
straight
to
a
demo.
I
already
have
it
loaded
on
this
tab
here.
So
I
will
just
show
this
so
because
we're
testing
your
knowledge,
one
of
the
trend
and
tested
ways
of
testing
knowledge,
is
via
a
quiz.
A
So
in
this
case
we're
testing
your
knowledge
about
Mina,
since
we
just
wrapped
up
the
Mina
ZK
Builders
program.
So
what
is
Mina?
So
you
know
these
are
the
four
questions
here:
I'll
quickly
go
to
the
right
one,
which
is
a
layer,
one
blockchain,
that's
based
on
ZK
proofs
and
has
a
blockchain
of
a
fixed
size
of
20
kilobytes.
So
just
going
to
click
submit
this
application
is
running
on
GitHub
pages
and
it
is
connected
to
the
Berkeley
test
net.
A
I
have
more
features
implemented,
so
let's
go
there
so
I
already
have
it
loaded
here,
as
you
can
see,
the
first
question
is
what
is
Mina
so,
if
I
put
the
wrong
answer
to
that
question
just
so,
you
can
see
that
the
proof
is
checking
to
see
if
your
knowledge
is
actually
correct.
Let's
say
I
say
it's
only
a
2
blockchain.
It
encountered
an
error,
and
that
is
because
the
value
that
the
proof
was
expecting
is
not
the
actual
value
or
not
the
correct
value.
So
let
me
do
retry
and
let's
go
again.
A
What
is
me
now?
So
the
answer
is
a
layer,
one
blockchain,
that's
based
on
CK
proofs
and
has
a
fixed
size
of
20
kilobytes,
the
other
question.
So
we
have
10
questions
to
go
through
here.
It
would
be
great
if
something
like
this
could
be
interactive,
but
let's
just
keep
going
so
a
zero
knowledge
proof
is
a
way
of
proving
the
validity
of
a
statement
without
revealing
any
information.
Apart
from
the
fact
that
the
statement
is
true,
all
right,
let's
go
so
what
is
a
consensus
model
proof
of
stake?
A
We
all
should
know
that
what
was
the
key
apps
Amino,
so
we
know
for
sure
DK
apps
use
zero
knowledge
proofs,
for
which
type
it
actually
is
the
ZK
snacks,
so
balances
number
two.
What
programming
language
is
used
to
create
ZK,
apps
I
think
this
is
a
really
great
feature.
The
fact
that
you
can
use
typescript
because
it's
very
much
like
JavaScript,
which
is
one
of
the
most
popular
programming
languages.
A
A
How
is
a
small
contract
before
deployed?
So
if
you're
familiar
with
ethereum,
you
probably
have
used
something
like
the
remix
ID
to
deploy
your
smart
contract.
But
in
the
case
of
me
now
you
can
deploy
a
small
contract
simply
by
sending
a
transaction
to
the
address
where
the
smart
contract
will
be
contained.
That
contains
the
verification
key.
So
the
answer
is
number
four:
is
they
are
limited
on
Jane
States
on
Mina?
The
answer
is
yes
and
you're
limited
to
it
feels,
and
how
do
you
store
more
data
on
chain?
A
Well,
you
can
store
the
root
of
a
miracle
tree
which
I
imagine
many
of
us
would
have
used
for
this
program
because
we
have
a
lot
of
data
to
store.
I
definitely
had
to
use
that,
for
example,
storing
the
question
and
answers
for
this
quiz.
So
now
it
has
minted
a
token
because
you
have
successfully
completed
the
quiz,
so
it
says:
congratulations
you
won
so
now
it
says:
do
you
have
an
account
with
us?
A
Yes,
and
it
is
now
going
to
create
that
by
the
way
this
is
using
a
local
blockchain.
That's
why
it's
so
fast.
Would
you
like
to
claim
your
rewards
now?
Yes,
so
that
question
and
answer
I
mean
that
username
and
password
is
stored
in
the
miracle
tree
and
to
your
username
enter
your
password,
and
now
it's
going
to
approve
the
transaction
for
claiming
the
tokens
so
for
some
reason
that
one
takes
a
little
bit
longer,
so
you'll
just
wait
for
that
to
load.
A
Meanwhile,
let's
just
check
up
on
this
one
and
go
to
the
console,
so
it's
still
creating
the
proof,
no
problema
alrighty
and
let
me
go
back
to
the
code
actually,
so
let
me
show
you
the
code,
that's
involved,
so
just
now,
I
showed
you
how
you
can
run
it
within
your
terminal.
This
is
using
the
local
blockchain.
So
if
you
go
to
my
code,
repo,
you
can
see
that
here
and
I
can
show
you,
for
example,
where
you
would
answer
the
question.
A
Oh
wonderful,
so
this
is
a
confirmed
transaction
that
is
coming
from
this
application,
which
is
where
you're
confirming
the
transaction,
which
is
to
send
your
answer
for
this
particular
quiz.
So
I'm
just
going
to
click
confirm
so
that
can
be
sent
to
the
Berkeley
blockchain.
The
transaction
has
been
sent.
I
do
have
a
link
here
which
I
can't
see
okay
yeah.
A
So
you
can
see
that
link
that
goes
to
the
blockchain
and
it
probably
will
take
a
minute
or
two
to
be
confirmed
immediately
once
you
have
sent
the
transaction
I
am
now
sending
you
to
the
other
question
and
the
reason
why
I
did.
That
is
because
the
fact
that
the
transaction
is
sent
shows
me
that,
more
than
likely,
you
have
the
correct
answer.
So
if
it
fails
for
some
reason
it
might
be
because
of
gas
fees,
so
the
transaction
is
not
found
yet.
A
Just
yet
so
going
back
to
my
code,
let's
just
go
to
the
section
where
you'd
be
answering
questions
so
here
you
see
we're
going
through
the
list
of
questions
and
it
waits
for
your
response
and
once
I
find
your
response,
it
looks
for
that
particular
one
within
the
miracle
tree
and
then
a
sense
of
transactions
where
you're
validating
the
question
response
then
sign
in
the
transaction
and
then
doing
a
proof
and
then
finally
sending
it.
So
this
is
the
code
required
to
validate
that.
A
You
have
answered
the
question
correctly
and
if
we
look
at
that
within
the
actual
smart
contract,
what
that
looks
like
it
is
right
here
validate
question
response.
So
it
looks
at
the
at
first
gets
the
root
of
the
Merkel
tree,
which
is
stored
in
the
state
of
the
small
contract,
and
then
it
takes
in
the
path
to
your
response
and
then
it
checks
to
see
whether
or
not
that
is
equal
to
the
path.
That's
on
the
Miracle
tree,
which
is
stored
in
a
small
contract.
A
So
once
that
is
correct,
then
the
transaction
will
go
through
and
that's
the
behavior
we
saw
within
the
application
when
we
run
it
here,
but
also
the
fact
that
you're
confirming
a
transaction.
Similarly,
for
the
front
end,
let
me
see
if
I
can
show
you
yeah.
Similarly,
for
the
front
end,
this
is
the
form
where
you
see
the
question
responses
coming
up
and
then
the
method
handles
submit
is
called
so
and
handle
submit.
A
You
are,
then
calling
this,
which
is
called
on
the
send
transaction
and
you're
passing
the
question
response
and
understand
and
that
oh
sorry
on
send
transaction
and
calls
create
update
transaction
and
if
you
go
into
the
code
that
actually
shows
where
it's
calling
the
CK
app
code.
So
that's
what's
happening
on
this
side
here.
Let's
see
the
transaction
is
now
showing
up
wonderful,
so
it
has
it
went
through,
so
that
was
the
first
transaction.
A
So
let's
try
to
put
the
wrong
answer
for
this
one
and
let's
see
what
happens
on
the
UI
version,
so
it
already
says
incorrect.
So
there's
no
need
for
a
transaction
to
be
sent
and
let's
just
put
the
correct
one
and
send
that
through
and
yeah
so
now,
you've
seen
the
code
you've
seen
it
run
in
command
line.
You've
seen
it
running
the
UI.
A
A
It
can
be
used
in
many
fields,
knowledge
providers,
so
you
can
do
many
courses
right
now
online
with
Coursera
Even
build
space
and
they
might
all
want
to
have
one
way
to
prove
that
you
know
your
knowledge
and
I
think
everyone
can
use
this
application
sort
of
like
a
widget
and
they
prove
their
knowledge
and
they
get
a
token
and
that
token
is
stored
on
chain
and
it
can
be
nice
at
websites
like
LinkedIn
as
well
show
these
tokens.
So
the
features
that
this
app
has
you
have
a
quiz.
A
So
you
can
claim
your
rewards
later,
so
the
ZK
app
components
used
so
I
use
zero
knowledge
proofs,
of
course,
and
the
zero
knowledge
proofs
were
used
so
that
the
user
can
send
their
answer
response
privately
and
that
is
proven
chain
I
deployed
on
the
test.
Net
I
use
Miracle
trees
so
that
I
can
store
like
lots
of
question
and
answer
data
recursive
proofs
I
did
start,
but
I
didn't
actually
get
to
the
Finish
Line
with
that
one.
A
But
that
would
be
great
so
that
I
don't
have
to
send
one
transaction
per
question
and
I
also
tested
out
custom
tokens,
as
you
saw
so
design
challenges.
So
I
would
say.
A
design
challenge
is
the
fact
that
you're
limited
to
each
state
variables,
but
that
was
easily
solved
using
Miracle
trees.
Michael
trees
were
my
best
friend
throughout
this
program.
A
Far
too
many
times
when
I
was
searching
for
issues
and
also
creating
Amina
proof,
while
also
keeping
the
data
required
for
the
proof,
private
was
something
that
I
had
to
think
about
as
well.
So
this
is
me
I.
Am
a
content
created
I
like
to
talk
about
blockchain
on
social
media,
and
this
is
where
you
can
find
me,
and
that
is
my
presentation.
I
really
would
love
to
show
you
the
end
screen,
because
there
is
confetti.
B
A
Let's
just
see
how
long
this
transaction
takes
to
go
like
if
you
just
give
it
two
more
seconds,
you
probably
could
see
that
confetti,
but
that
is
the
front-end
application.
You
can
access
it
here.
You
can
find
my
code
on
GitHub
here
and
I
have
instructions
showing
you
how
to
run
it
in
the
readme,
so
you
can
run
from
a
terminal
if
you
would
like
to
run
the
local
blockchain
or
you
could
also
simply
just
go
to
the
front
end,
but
you're
limited
to
just
the
quiz
app
Feature.
A
So
definitely,
if
you
find
this
interesting,
please
reach
out
to
me.
I
would
love
to
continue
working
on
this
and
I
have
lots
of
steps
here
that
you
can
go
through
to
understand
why
I
did
what
I
did
and
as
well.
You
can
find
the
small
contract
address
on
the
Berkeley
test
net
here,
Come
on
load.
For
me,
let's
see
so
yeah,
so
this
is
the
Smart
contract
here
on
the
Berkeley
test.
Net
is
deployed
to
this
particular
address.
A
A
So
two
Miracle
trees
were
stored
here
and
one
Miracle
tree
is
the
one
that
has
the
question
and
answers
so
that
we
can
validate
question
responses
and
the
second
Moogle
tree
is
where
I
stored
user
accounts.
So
whenever
you
see
that
interaction
where
I
had
to
create
a
user
account,
it
was
actually
stolen.
A
miracle
tree
I
didn't
actually
demonstrate
that
in
the
front
end,
but
it
was
deployed
to
the
small
contract,
because
I
did
have
like
some
usernames
like
hard-coded
username
and
passwords
hard-coded.
So
that
is
why
that
fees
is
populated.
A
As
you
can
see,
I
have
a
list
of
transactions
that
I
would
have
been
working
on
from
even
weeks
ago.
The
ones
here
that
failed.
This
is
where
I
was
testing,
sending
tokens
to
another
address
and,
as
you
can
see,
I
have
like
two
accounts
here.
For
some
reason,
those
didn't
work
because
of
the
valid
fee
access.
This
error
has
been
the
being
of
my
existence
for
this
program.
So
definitely
I
need
to
figure
out
how
to
solve
that.
But
these
are
the
successful
transactions
from
verifying
that
you
submitted
the
correct
transactions.
A
So
it
seems
like
I'm
not
able
to
show
this
in
time,
so
I
guess
still
pending
I
guess
I
will
just
leave
it
there
for
now.
I
really
want
you
to
see
the
confetti,
but
actually
that's
probably
motivation
for
you
to
go.
Try
the
application
yourself
confirm
the
transaction
and
see
the
confetti.
So
thank
you
so
much
for
watching
I.
B
B
You
know
a
lot
of
times
you
have
to
go
through
like
security,
Audits
and
like
what
it
says
would
kind
of
like
want
to
see
whether
employees
would
have
done
a
course
or
something
and
the
way
they
usually
do
it
is
like.
Oh
yeah
show
me
kind
of
your
page
where
you
did
the
course
or
something
and
like
I,
don't
know
with
your
app.
You
could
just
simply
verify
the
proof.
That's
already
Unchained
yeah.
It
was
job
much
easier.
Yes,.
A
B
Let
me
find
the
correct
screen
to
share
all
right.
Yes,
so
as
part
of
the
ckl
builders
program,
I
created
a
treasure
hunt,
game
and
I
called
it
as
UK
schnitzel
hunt
comes
from
the
fact
that
in
Austria,
where
I'm
from
we
call
it
schmizzle
hands,
so
schnitzel
is
a
famous
Austrian
dish
and
apparently
that's
our
trailer
at
the
end.
So
let
me
just
kind
of
like
give
you
an
overview
how
how
the
game
works.
B
So
the
user
would
start
a
game
and
they're
presented
a
riddle
and
then
they
can
share
the
location.
Obviously,
if
it's
not
correct,
they
can
retry,
but
if
it's
correct,
AAC
proof
is
generated,
and
then,
if
this
is
like
valid,
they
would
be
able
to.
You
know
it
unlocks
the
second
riddle
and
then
you
do
the
same
thing
again.
You
share
your
location.
If
it's
correct
the
proof
is
generated
and
it
kind
of
goes
on
and
on
until
we
generate
the
final
proof.
B
So
in
my
first
iteration
I
actually
kind
of
implemented
this
picture
iteratively,
so
it
would
after
every
riddle,
we
would
generate
the
proof
and
submit
it
on
chain
and
and
then
in
my
second
iteration
I
actually
used
a
kind
of
experimental
feature
of
snarky.js,
namely
you
can
you
can
recursively
construct
your
proofs
and
the
way
it
works
is
I'll.
Show
you
also
later
in
the
contract
but
kind
of
on
a
high
level.
B
We
still
kind
of
generate
a
proof
after
the
first
riddle,
but
then,
when
we
get
to
the
second
riddle,
we
kind
of
like
wrap
the
second
proof
around
the
first
proof
and
then
we
kind
of
like
we
can
recursively
walk
through
kind
of
the
gain
State
machine
and
then
only
at
the
end.
We
submit
the
rep
proofs
on
chain
and
it's
really
useful,
especially
for
you
know.
You
see.
This
is
like
a
recursive
problem
and
it's
really
useful,
because
then
we
only
have
like
one
transaction
at
the
end.
B
So
the
way
I
implemented
it
I
was
kind
of
excited
to
free
design
decision
parameters.
We
already
talked
about
the
first
one:
Ezekiel
accounts
can
only
store
eight
fields
or
32
parts
and
then,
secondly,
if
you're
developing
zero
knowledge,
smart
contract,
you
have
to
make
sure
you're
using
smart
kids
as
compatible
data
types,
and
that
was
really
important
because
you
know
location
data
is
usually
stored
in
floating
points,
so
I
had
to
transform
the
data
that
the
user
inputs
and
then
yeah.
B
Another
thing
that
I
kind
of
realized
during
the
game
was
oh,
like
during
developing
the
game,
was
that
it's
very
unlikely
that
the
user
will
kind
of
share
the
exact
geographical
point.
So
we
have
to
allow
a
valid
range
for
the
riddles
so
kind
of
to
solve
one
of
the
problems.
What
I
did
is
I
kind
of
pre-computed,
this
valid
bounding
box
per
riddle
and
because
we
already
talked
about,
we
can't
store
all
of
these
on
chain.
B
B
And
then,
finally,
how
is
the
riddle
like?
How
do
we
know
whether
a
rhetor
was
solved?
So,
given
the
location,
we
can
generate
a
numerical
proof,
I
think
Alicia,
already
kind
of
showcansters
really
well
how
it
works,
and
then
the
smart
contract
can
validate
the
medical
proof
against
the
solution
route
that
we
stored
on
chain.
B
B
A
B
Thanks
all
right,
so,
let's
start
the
recording,
so
the
user
clicks
start
again
and
you
know
start
the
game
and
what
happens
because
we're
running
locally
I'm
loading
snarky
to
S,
we're
also
starting
the
local
media
blockchain
and
compare
the
app
and
here
the
interesting
things
that's
happening.
Let
me
actually
speed
this
up
a
little
bit
because
it's
going
to
take
quite
a
while.
B
So
basically
here
you
see
we're
building
the
solution,
Michael
trees,
that
I
talked
about
Ayah
and
then
I
initialized,
the
app
and
as
I
said
before,
like
what
we
want
to
do
on
on.
Initializing
is
actually
like
setting
setting
the
Merkle
root
of
each
each
solution,
Tree
in
a
smart
contract-
and
you
will
see
this
in
a
second.
Maybe
I
can
hit
pause
in
a
bit
because
so
I'm
like
after
initialization
is
done.
B
I,
actually
fetch
I
hear
this
I
fetch
the
state
of
the
of
the
kind
of
like
of
of
the
game
before
we
actually
start
before.
We
start
the
game.
So
here
you
see
the
basically
the
solution
roots,
one
turn
three
and
in
the
current
step
of
the
state
and
then
the
user
can
change
location
within
the
within
the
browser.
B
B
B
You
can
see
this
here
and
then,
let's
continue
and
Go
to
the
next
riddle,
now
I'm
just
going
to
speed
this
up
a
little
bit
but
basically
kind
of
what
we're
doing
here
while
we
work
through
the
riddles.
Is
that
we're
basically
constructing
these
recursive
proofs,
because
what
you
can
see
is
like
we're
doing
the
proofs.
B
B
So
that's
the
state
that
we
that
we
fetched
and
now
yeah
we
click
here.
This
button
we'll
get
go
to
the
next
step,
and
what
you
see
is
that
now
we
deploy
the
the
contract
and
then
we
can
hit
the
the
methods,
that's
in
the
contract,
which
is
spinach
and
basically
what
it
does
now
like
can
just
speed
this
up
a
lot
of
talk,
so
basically
what
it
does.
It
takes
the
recursive
proofs
and
then
just
checks
like
is
this:
is
this
game
in
the
correct
state?
B
A
B
B
If
you
go
to
my
GitHub
account
it's
genpuff
I'm
genpuff
everywhere,
and
then
you
you
can
find
a
repository
Act
in
the
context
folder
you
will
find
like
this
is
the
basically
the
the
iterated
version
that
I
did
in
the
beginning
and
then
basically
the
demo
I
showed
you
now
is
using
the
recursive
contract
I'm
not
going
to
walk
you
through
all
the
code.
Please
feel
free
to
also
read
the
docs
I
try
to
document
everything
as
well
as
possible.
B
So
here
yeah
here
is
the
kind
of
the
experimental
proof,
construction
that
we're
using
and-
and
you
can
see
here
so
what's
the
most
interesting
thing.
So
this
is
the
initialization
that
we
do
where
we
store
all
the
routes
and
as
public
inputs,
and
then
here
this
is
the
function
that
we
call
once
we
move
through
the
game
and,
as
you
can
see,
it
kind
of
like
always
uses
it
always
like
such
as
the
previous
proof,
and
then
it
does.
The
assertion,
like
you,
saw
the
assertion
earlier.
B
B
So
it
has
like
one
kind
of
field
which
is
finished
and
when
it
takes
it
takes
out
kind
of
like
recursive
proofs,
so
it
verifies
our
rep
proofs.
It
also
checks
whether
we're
in
the
correct
step,
because
otherwise,
if
we're
in
step
one,
you
can't
finish
the
game
and
then
finally
it
sets
to
finish
to
true.
So,
like
you
saw
this
in
the
console
log,
we
finished
the
game.
So
that
basically
means
you
know
finish
the
game
and
we
can
submit
a
proof
on
chain.
B
A
Oh,
that's
so
good,
really
nice
to
see
that
you
got
the
recursive
proofs
working
as
well.
So
that
way,
you
know
you
don't
have
to
submit
the
proof
until
the
very
end.
That's
nice
and
I
think
this
would
be
very
good
useful
if
you're
doing
those
Treasure
Hunt
games
like
we
were
talking
about
before
you
know
like
you,
can
prove
your
location
without
people
actually
knowing
where
the
exact
location
for
the
treasure
hunt
is
so.
Therefore,
the
composition
can
still
carry
on
so
I
think
that's
very
fun.
B
Honestly,
I
think
actually
like
doing
to
kind
of,
like
first
of
all,
like
transforming
my
problem
statement
initially
into
something
that
like
I,
can
practice
build.
Is
there
a
knowledge
contract
with
and
they're
actually
diving
into
this
recursive
contract?
I
thought
that
was
like
a
really
interesting
feature
and
kind
of,
like
you
know,
improve
the
performance
a
little
bit
with
my
app.
B
Oh
honestly,
I
think
actually
nothing
my
head
around
zero
knowledge
in
the
beginning,
I
thought
that
was
quite
challenging
for
me,
like
I,
don't
really
have
like
a
strong
mouth
background,
but
I
fell
into
the
rabbit
hole,
but
I
was
still
it's
still
challenging.
I
feel
like
I'm
still
on
the
trip
to
really
understanding
everything.