►
From YouTube: Hands-on: Integrating web3 with Unity - Taivo Pungas
Description
The NFTPort team will give a hands on workshop demoing how you can use web3 tech natively with Unity.
A
Let
me
do
a
quick
survey
to
see
who
is
awake
so
who
has
ever
minted
an
nft,
raise
your
hand,
okay,
who
has
read
the
erc71
interface,
spec,
okay,
fewer
people
who
has
deployed
the
contact
themselves
and
like
uploaded
the
metadata,
so
basically
create
an
nft
collection
and
nft
contract.
A
Okay,
a
few
people
I'm
hoping
this
is
not
too
simple
for
you
guys
so
I'm,
my
main
fear
was
making
it
too
too
simple,
but
let's
see
so.
What
energyport
does
essentially
is
there's
this
whole
lot
of
infrastructure
that
you
need
to
interface
with,
to
launch
your
nft
contract,
to
mean
to
be
able
to
maintenance
essentially
and
to
use
nfts
in
your
game,
and
what
densityboard
does?
Is
we
abstract
that
the
way
so
and
nft
Port
offers
an
API,
a
rest
API?
A
Where
you
can
do
simple
things
or
like
these
concrete
actions
with
single
API
calls,
you
can
deploy
a
contract,
maintenance,
nft
transfer
or
burn
nft?
Each
of
these
is
a
single
API
call,
and
these
all
of
these
are
like
writing.
Two
different
chains,
or
you
can
read
from
different
chains,
get
get
the
wallets
nfts
get
a
collection.
A
It
is
mostly
kind
of
a
relatively
simple
password
layer,
so
every
action
maps
to
every
every
unit,
disk
action
very
clearly
maps
to
one
of
the
API
actions
except
deploy
contract,
which
we
didn't
really
see
a
use
case
for,
but
essentially
I'll,
be
talking
through
the
API
examples.
But
in
the
latter
part
of
the
talk,
I'll
share
the
unity
SDK
link
and
essentially
it's
like
one-to-one
using
the
SDK
versus
using
the
API.
A
So
why
should
you
care
I
spent
the
year
a
bit
more
than
a
year
of
my
life,
trying
to
build
products
and,
failing
you
know
several
times
in
a
row
and
one
thing:
I
I
very
quickly
learned
with
the
first
failures.
Is
that
it's
you
don't
really
know
whether
what
they're
building
is
useful.
A
A
So
even
if
it
is
not
sort
of
like
critical
for
you,
if
you
don't
need
to
make
the
revenue,
then
to
figure
out
whether
people
are
getting
value
from
your
application
or
whether
people
are
enjoying
your
game,
then
adding
a
business
model
or
trying
to
monetize
in
some
way
it
can
be
a
very,
very
strong
signal
of
of
value
to
your
users
or
to
your
players,
and
the
typical,
like
the
standard,
webto
business
model
for
for
games
are
one
of
the
standard
ones
is
ADS
right
and
we
as
a
community.
A
We
have
sort
of
decided
that
we
we
don't
really
like
that,
so
we
would
rather
use
something
else,
some
other
model
and
the
basically
the
other
main
model
there
is.
Someone
has
to
pay
right
like
so.
In
the
end,
there
has
to
become
money
coming
from
somewhere,
and
if
that
is
the
user,
then
there's
like
direct
alignment
between
the
user
and
the
source
of
money.
A
So
if
the
user
is
paying
for
the
game,
that's
sort
of
the
ideal
now
the
question
is:
how
do
you
actually
integrate
that
or
how
do
you
actually
use
nfts
to
do
that?
Because
in
the
web
2
world
you
can
like
the
models
are
relatively
clear.
So
you
could
you
could
sell
the
game
like
buy
the
game
for
50
bucks
and
then
you
sort
of
own
it
or
you
can
you
can
at
least
play
it
in
perpetuity
or
there
may
be
some
monthly
subscription
you
can
sell
boosts.
A
Is
there
was
a
time
like
I
think
10
years
ago,
not
eight
nine
ten
years
ago,
where
there
was
this
mobile
game
called
Hill
Climb
Racing,
essentially,
like
you
have
a
car,
you
try
to
go
up
a
hill
try
to
reach
as
far
as
you
can
and
that's
pretty
much
the
game
mechanic
like
upgrade
your
car,
more
difficult
levels,
Etc
and
I
spent
I'm
sure
I
spent
like
hundreds
of
hours
on
that
game,
even
though
it's
very
simple
and
at
the
end
when
I
uninstalled,
the
game
is
all
gone
like
there's,
nothing
left
and
I'm
I
am
very
sure.
A
I
would
have
been
willing
to
spend
like
I,
don't
know
10
euros,
20
euros
to
sort
of
memorize
this
somehow
so
maybe
mint
this
as
an
entity
or
bring
it
out
of
the
game
so
that
I
am
left
with
a
memory
or
of
the
achievement
that
I
got
from
the
game,
and
it's
it's
weird
because
then
it's
sort
of
I
would
have
voluntarily
paid
for
sort
of
meeting
and
achievement
and
I
think
this
is
actually
a
model
that
not
many
people
have
tried
and
one
that
I
would
actually
like
to
see.
A
More
is
everything
being
free,
but
if
you
might
want
to
make
it
permanent,
if
you
want
to
take
the
data,
the
Milestones,
the
achievements
out
of
the
game,
then
you
pay
and
that's
that's
uniquely
enabled
by
nfts,
because
you
know
it's
off
chain.
You
can't
really
it's
not
really
permanent
on
chain.
A
It
is,
and
the
other
thing
about
nfts
is
they
are
instantly
interoperable
and
what
I
mean
by
this
is,
if
you
saw
a
couple
of
months
ago,
Instagram
released
support
for
nfts,
so
you
can
connect
your
wallet
and
and
sort
of
like
showcase.
Your
nfts
in
the
Instagram
profile,
unfortunately
not
in
Europe
because
of
gdpr,
but
you
know
like
that's
the
trend
we're
going
towards
and
if
you
imagine
the
world,
where
you
know
a
user
has
their
wallet
connected
to
Instagram,
and
now
they
come
to
play
your
game.
A
Then
the
moment
you
give
them
an
nft
or
the
moment
they
receive
an
nft
or
buy
an
nft
in
your
game.
It
is
instantly
a
social
experience.
They
can
instantly
show
it
off
on
Instagram
or,
if
Reddit,
that
supports
for
nfts
or
SnapChat
or
whatever
the
social
platforms
when
they
adopt
nfts
and
I.
Think
this
this
is
happening,
then
there's
this
interoperability,
which
again
you
just
don't
really
have
with
a
web
tour
of
chain
solution.
Right,
like
you,
could
give
some
tokens
or
Milestones
or
whatever
of
chain
in
your
app.
A
A
So
that's
the
second
pattern
that
entities
I
think
sort
of
a
reason:
I'm
optimistic
about
10fts
as
a
source
of
monetization
for
for
games
and
the
main,
like
the
the
very
obvious,
the
most
I
think
the
most
commonly
talked
about
pattern
for
how
to
monetize
with
nfts
is
token
getting
so
tokenating
essentially
like.
If
you
hold
the
token,
then
you
can
unlock
something.
If
you
don't
hold
it,
then
you
can't-
and
it's
very
I
think
the
metaphor
is
actually
pretty
good.
Like
you
walk
up
to
your
gate,
the
token
is
the
key.
A
You
unlock
the
gate
to
get
in.
If
you
don't
have
a
token
you
don't
get
in
and
there
are
many
ways
there
are
many
things
you
can
actually
tokenate.
So
you
can
token
gate
access
just
like
being
able
to
access
the
game
season,
pass,
subscription
or
monthly
pass
whatever
you
can
tokengate
particular
functionality.
So
if
you
hold
the
nft
checks
as
a
particular
part
of
the
map,
only
then
you
can
get
there
or
entities
for
particular
levels
and
at
least
for
functional
items.
You
can
only
use
a
particular
sword
or
car
or
whatever.
A
If
you
have
that
relevant
entity,
this
is
more
common.
You
can
also
tokengate
non-functional
items
so
nft
avatars,
nft
apparel
on
the
avatars
entity,
skins
Etc,
so
like
the
design
space
is
pretty
broad
here,
because,
essentially
token
gaming
is
just
like
a
form
of
authorization
and
the
users
can
sort
of
hold
the
entities
and
trade
them
as
means
of
moving
the
authorization
between
users
and
essentially
talking
heading
is
like.
Do
you
integrate
it
into
your
application?
A
You
need
basically
two
steps,
one,
the
user
needs
to
get
the
entity
from
somewhere,
and
this
is
where
like
this
is
where
you
can
build
your
business
model
around.
You
sell
the
nft
to
the
user,
that's
where
you
make
your
money
and
then,
when
they
come
to
your
application
at
runtime,
you
need
to
check
whether
the
user
has
the
nft
or
not.
A
So
you
can
tell
whether
you
should
allow
them
to
access
or
not
and
I'll,
go
to
you
through
through
two
different
ways
to
do
it
and
the
ways
you
can
use
nft
part
to
implement
those.
So
how
do
you
sell
an
ft2
user?
The
standard
way
people
do
it
today?
If
you
like
people
who
launch
nft
collections,
is
you
deploy
a
smart
contract,
you
build
minting
the
app
or
essentially
a
website
around
it.
That
makes
an
RPC
call
and
the
user
goes
to.
The
website
connects
their
wallet
signs.
A
The
transaction
pays
a
fee
and
they
get
the
nft.
So
essentially,
that's
the
the
flow
here
like
the
once.
You
know
like
you,
don't
really
need
a
website
even
as
well
like
you
could
just
use
a
polygon
scan
or
ether
scan
or
something
the
user
makes
the
RPC
call
the
get
back
to
nft.
This
is
a
very
simple,
simple
approach,
and
you
can
do
that
within
a
few
minutes
with
nft
Port,
so
I
open
up
the
documentation
website
for
the
endpoint,
where
you
can
deploy
an
entity,
collection,
contract
and
I
prepared.
A
The
parameters
as
well,
so
we
don't
have
to
write
them
from
scratch.
So
essentially,
what
do
you
need
to
specify
to
deploy
a
contact
with
entity
chain
will
be
deploying
it
on
polygon.
This
is
the
name
of
the
contract.
This
is
what
will
show
up
as
the
collection
on
openc,
for
example,
and
other
marketplaces.
So
my
game
is
called,
let's
say:
test
land
Tesla
season,
one
I'm
I'm
selling
passes
here.
A
Max
Supply
could
be
anything
I'm
saying
only
100
people
can
get
taxes,
I
mean
price,
half
a
Matic,
so
that's
like
50
cents
owner
address.
This
is
both
of
these
are
my
own.
My
own
address.
Some
of
these
other
parameters
are
not
as
important
but
the
pre-revealed
token
URI.
So
essentially,
this
is
what
will
Define
how
the
nft
will
look
like
when
people
meet
their
passes,
and
this
is
actually
where
ipfs
comes
in.
How
do
you
actually
Define
the
token?
How
the
token
looks
like
the
the
image,
the
metadata?
A
So
essentially,
you
need
to
make
upload
the
image
to
ipfs,
then
upload
the
metadata
job
ipfs,
which
refers
to
the
image
and
then
you'll
be
able
to
deploy
the
contract.
We
have
endpoints
for
that,
so
one
API
call
is
upload.
The
file
to
ipfs
literally
attach
a
file
to
the
body
of
the
post
request
and
it's
uploads
ipfs
pinned
by
filecoin.
A
A
A
So
let
me
go
ahead
and
and
take
the
contract
which
I
deployed
last
night.
So
essentially
you
can
use
this
endpoint.
We
went
through
the
parameters
Wonder
API
request
and
within,
like
10
to
15
seconds.
The
contact
is
deployed
on
polygon.
You
can
also
do
it,
but
obviously
the
costs
there
are
are
higher
in
the
contract
so
going
back
to
where
we
started.
Actually
in,
like
you
make
the
RPC
mint
call
I,
don't
I
didn't
set
up
a
meeting
website,
but
I
can
write
the
contract
on
polygon
scan,
collect
my
wallet.
A
Submit
transaction
it's
pending
and
it
should
show
up
on
openc
in
a
few
moments,
so
this
is
one
of
the
main
or
like
one
way
to
give
nfds
for
tokenating
Content
later
this
is
sort
of
the
the
least
least
Central
way,
I
would
say
so.
The
only
thing
that
you
actually
have
control
over
in
that
case
will
be
the
the
contract
that
you
deploy.
If
you
want,
and
in
many
cases
you
might
want
more
control,
so
you
might
want
to
take
an
API
approach,
and
this
is
something
that
we
enable
as
well
is.
A
So
this
is
your
app
the
game.
You're
building.
This
is
the
name
of
the
nft
API.
This
is
the
the
contract
that
you
deployed
on
chain,
this
user,
so
the
user
pays,
or
maybe
they
come
with
with
like
a
coupon
or
something
or
maybe
they
do
something
that
you
like,
and
you
want
to
drop
them
an
nft.
A
Your
application
makes
an
API
call
to
nft
Port
the
API
call
like
the
semantics
being,
please
maintenance
nft
into
that
contract.
Then
we
on
our
side.
We
do
all
do
all
of
the
gas
handling.
The
token
like
costing
the
the
coins
need
that
you
pay
for
transaction
Etc.
We
make
the
RPC
call
to
the
to
the
contract
and
the
end
of
these.
We,
like
the
RPC
call
we
make,
will
have
the
user's
address
in
it
and
the
user
receives
the
nft.
A
The
reason
you
might
want
to
do
that
is
it's
essentially
more
flexible
because
in
the
case
on
the
left
you
either
have
to
have
the
user
mean
directly
sort
of
either
in
your
app.
You
need
to
make
the
integration
yourself
or
they
need
to
leave
your
your
game
or
you
need
to
do
a
lot
of
work
to
essentially
build
what
or
replicate
what
we
have
built,
which
is
the
like
simple
interface
for
minting
programmatically
and
the
approach
on
the
right.
A
Let
me
see
how
we're
doing
for
time
the
approach
on
the
right,
I'll
show.
You
I'll
run
you
through
how
we
can
do
that
as
well.
So
we
have
different
kind
of
contract
for
that
you
can
deploy
a
contact
for
empty
products
and
I'll
do
that
live
as
well.
So
let's
do
it
right
now
chain
polygon
name.
So,
like
the
imaginary
scenario
here
is
like:
let's,
let's
have
a
contract
where
each
nft
represents
a
car
in
the
game
that
we
have
or
in
the
test
land
game.
So
let's
call
it
test
length.
A
Okay
and
with
one
API
call
I
got
back
my
transaction
hash.
Let
me
go
go
ahead
and
check
it
on
pulling
scan
pending
right
now,
including
to
block
and
within,
like
usually
within
5
10
15
seconds.
It
is
on
the
chain.
The
Next
Step
from
here
is
once
I've
deployed
the
contract.
This
I
did
this
via
the
API.
Now
I
can
make
the
minting
calls
so
again
to
do
that.
I
need
to
upload
the
image
and
the
metadata
to
ipfs
before
I.
Do
that?
So
let
me
go
ahead
and
and
do
that
here.
A
And
maybe
let's
add
some
attributes
as
well,
so
let
me
find
the
attributes.
A
A
A
Into
block
you
should
be
able
to
yeah,
we
can
also
see
it
in
the
in
the
contact.
So
again
one
API
call
the
NFD
is
there
and
it
was
minted
to
the
user
that
I
specified
in
the
in
the
in
the
API
call.
Let
me
see
if
I
actually
opens
the
it
has
already
indexed
it
so
is
going
to
be
in
the
hidden
tab,
most
likely.
A
Yep
and
and
it's
here,
it
also
shows
up
on
opposey,
so
essentially,
I
I
went
through
these
two
approaches,
and
now
the
user
has
an
nft.
All
we
need
to
do
is
figure
out.
So
once
someone
around
the
person
shows
up
at
the
gate
when
you
figure
out
whether
they
have
the
right
nft,
and
we
also
got
you
covered
here.
So
essentially
the
approach
is
the
user.
They
have
an
nft,
your
application,
the
user
connects
their
wallet
to
your
application.
You
need
to
you,
can
ask
for
an
MX
support.
Api.
A
A
This
will
have
a
you
know,
a
long
list.
These
are
all
the
tokens
that
I
have,
but
you
can
restrict
it
to
your
your
particular
contract,
so
in
general,
enough
support
indexes
the
whole
chain
right.
But
if
you
want
to
look
at
only
the
contact
or
the
contacts
that
are
relevant
to
you,
then
we
can
filter
it
down
to
that
as
well.
A
And
I
include
the
Metadate
as
well,
and
now
you
can
see
so
with.
Second
API
call
at
the
time
that
the
user
connects
their
wallet.
We
can
figure
out.
Do
they
have
their
relevant
nfts,
so
you
can
essentially
ask
for
this
user.
Give
me
all
the
cars
that
they
own
all
the
nfts,
that
they
own
in
the
CAR
contract,
and
you
can
get
back.
A
You
know
the
all
of
the
data
here,
which
is
essentially
all
of
this
allows
you
to
render
the
viewer
that
you
can
see
on
openc
and
you
can
actually
also
render
the
3D
versions
if
you
attach
a
3D
asset
instead
of
just
a
2D
image.
You
can
also
render
that
and
fetch
that
one
thing
that
we
that
I
want
to
highlight
here.
A
One
thing
that
we
do
is
I'm
sure
you
have
seen
the
if
you've
like
worked
with
the
nfts
at
all
people
store
their
assets
and
and
metadata
in
various
places,
so
can
be
an
ipfs
link.
If
it
works
well,
that's
great,
but
it
could
be
dead
or
it
could
be.
You
know
stored
somewhere,
where
the
response
time
is
like
60
seconds
or
200
seconds
times
out
of
the
time,
or
it
could
be
on
an
off
chain
storage.
It
could
be
a
Google.
A
Drive
could
be
a
link
that
is
down
and
what
we
do
is
we
essentially
catch
you
on
our
side.
We
pull
in
all
of
the
metadata
all
of
the
assets
so
that,
when
you
make
sort
of
act
as
a
kind
of
as
a
CDN
or
as
a
cache
layer
for
energy
data,
so
when
you,
when
you
want
to
get
the
image
you
can
get
it,
you
can
see
it's
in
a
Google
bucket,
which
is
sort
of
more
consistently
arrival
and
lower
latency
than
you
typically
get
from,
like
the
the
average
NFD.
A
A
The
second,
the
second
main
pattern
I
wanted
to
share
is
Milestone
drops
or
that's
what
I
named
it
I'm,
not
sure
if
there's
a
standard
name,
but
this
is
what
I
alluded
to
earlier
with
the
hill
climb
car
game
right,
like
the
user,
has
reached
some
point
in
the
game.
There's
some
achievements
a
milestone
and
you
can
give
them
the
option.
A
They
don't
necessarily
have
to
do
it,
but
you
can
give
them
the
option
to
Mint
that
Milestone
into
their
wallet
and
again
like
if
you
tie
it
all
together
with
what
I
said
before,
like
the
flow
could
be,
they
achieve
something
cool
in
your
inner
game,
the
minted
in
generality
and
like
five
seconds
later,
it's
on
Instagram
shareable
and
in
that
sense
I
would
say
this
is
a
a
powerful
pattern.
A
For
for
you,
if
you're
working
on
a
game
and
essentially
like,
like
you
said
it
could
be
completing
a
level
achievement,
discover
the
secret
item
that
was
optional
in
the
game
like
off
the
main
path
or
it
could
be
time
played
whatever
you
can
come
up
with,
where
you
sort
of
like
which
are
like
standard
parts
of
the
game
of
game
design,
you
can
monetize
them
either
one
of
two
ways.
One
is
that
you
could
just
have
like
sort
of
have
the
user
minted.
A
So
they
pay
you
for
the
privilege
of
getting
the
thing
as
an
entity
the
achievement
as
an
nft,
or
you
could
monetize
it
by
giving
it
to
the
user
for
free
or
for
like
marginal
cost
and
then
earning
royalties
off
of
that.
So
this
is
sort
of
like
you.
A
You
would
probably
want
to
make
sure
that
there
is
a
reason
to
for
there
to
be
a
secondary,
Market,
otherwise
you're
actually
not
going
to
make
money
off
of
that,
but
that's
also
an
option
essentially
and
the
the
approach
here
is
like
quite
similar
to
to
before.
Essentially,
you
need
to
give
the
user
an
nft
with
a
DF
approach.
A
You
can
do
it
with
energy
part
as
well
I'm
not
going
to
details
but
basically
like
if
you
whitelist
user,
in
a
in
a
contact,
then
that
sort
of
acts
as
a
selective
filter
for
who
can
meet
an
achievement
and
the
API
approach
is
essentially
the
same
as
before
the
user.
Either
you
take
like
off-chain
payment
or
the
user
takes
an
action,
it
may
be
free
and
your
application
decides
okay.
Now
it's
it's
a
good
time
to
Mint
to
that
user.
Make,
a
post,
endpoint
call!
A
So
I
said
before
and
I
know:
I
haven't
really
like
delivered
on
the
title
really,
which
is
you
know,
integrating
this
with
unity.
Let
me.
Let
me
show
you
quickly
the
unit
documentation
that
we
have
so
in
the
API
logs.
We
have
a
unit
section.
You
can
do
literally
every
part
of
it.
Everything
that
I
just
showed
you
you
can
do
in
unit
as
well
with
Native
function.
Calls
it's
very
easy
to
get
started.
A
You
can
use
Unity
package
matcher
to
to
test
it
out,
takes
a
few
minutes
and
there's
a
feature
list,
so
you
can
see
like
the
feature
parity
on
by
Chain.
So
what
is
available
on
on
in
the
SDK
and
what
isn't?
Let
me
show
you
a
Showcase
of
the
unity
SDK.
So
let
me
connect
my
account.
A
A
I
think
it's
there's
something
else.
I
need
to
do
which
I
forget,
but
we
can
look
at
maybe
a
better
way
to
look
at
this
take
collection.
So
let
me
explore
our
collection
and
now
using
the
nft
board.
Unity
SDK
we're
actually
loading
all
of
the
nfts
within
that
collection
and,
as
you
can
see,
we're
actually
loading
and
rendering
the
3D
assets
as
well,
because
in
many
cases
entities
hold
3D
assets.
A
So
this
was
this
is
the
sandbox
assets
contract
and
if
you
look
around,
there's,
like
you
know,
there's
a
bunch
of
stuff
by
the
way,
I'm
just
warning
you
playing
a
playground
is
going
to
crash
you
in
a
moment
because
there's
no
memory
management,
but
it's
just
the
limitation
of
the
of
the
you
know
the
the
example
not
really
the
SDK
So
within
Unity.
A
You
can
very
very
easily
fetch
both
image
assets
and
the
you
know,
sort
of
the
the
main
prize,
which
is
the
the
3D
assets
as
well,
and
they
could
do
it.
You
saw
the
load
time
here.
A
These
assets
may
be
relatively
big,
but,
like
you
can
do
it
rightly
with
us,
because
we
catch
them
in
a
centralized
storage.
You
can
also
mint
10
of
these
from
within
the
game
and
there's
a
demo
of
this
I
won't
go
through
all
that
and
you
can.
You
can
go
through
the
demo
as
well
later,
if
you
want
on
your
own.
A
To
summarize
my
talk
so
try
to
make
money
as
a
form
of
validation,
to
do
that
either
sell
nfts
that
gate
content
or
let
users
meet
meaningful
moments
to
them.
The
the
things
that
I
showed
you
you
can
find
all
that
in
docs.
That
entity
protects
with
that.
Can
you
can
sign
up
for
free?
A
You
can
mean
100
nfts,
deploy
five
contracts,
get
a
free,
API
key,
get
all
that
done
within
a
few
minutes
to
see
whether
that
would
actually
work
for
you
for
your
game,
and
if
you
want
to
check
out
the
unit
the
SDK,
then
that's
on
our
GitHub
at
nft
Port
nftportunity.
But
if
you
Google
NFC
opportunity
SK,
you
will
find
that
as
well,
and
if
you
want
to
get
in
touch
with
me,
then
my
my
email
is
at
private
nftart.