►
From YouTube: vRAM part 2: Preparing the Cardgame Contract for the DAPP Network (Blockchain Dev Tools)
Description
Advanced Blockchain Development Tools is an Everything EOS course sponsored by Cypherglass. Please vote for my sponsor! https://cypherglass.com
In this lesson, we get the cardgame contract (from the Elemental Battles game built in Everything EOS course #1 and the Block.one official tutorial) ready to use with Zeus SDK, and ready for adding some DAPP Network services.
**CODE DOWNLOAD**
Prepared Contract and Frontend (merge into cardgame folder after running "zeus unbox cardgame"): http://bit.ly/abdt-lesson7
**More Everything EOS Developer Videos**
Learn more about EOSIO and DAPP Network development by visiting our Everything EOS Developer Series Playlist:
https://www.youtube.com/playlist?list=PLRK9ZLYOWiXPJ2ThcTpn4e9Y6MyqqY49r
**GETTING HELP**
Stay tuned for updates on this course's learning platform launch! For now, follow the playlist and reach out to the Everything EOS telegram or https://twitter.com/bitgensteinx with any issues or questions.
Sign up for occasional updates at https://everythingeos.io/dev
Take the first course, which teaches the basics of building a smart contract and dApp frontend in ReactJS+Redux+NodeJS and C++, at https://www.udemy.com/course/eos-blockchain-dapp-development-tutorial
A
Hey
everyone
welcome
back
to
advanced
blockchain
development
tutorials
today,
I'll
be
showing
you
something.
I
did
to
the
card
game
contract
to
start
getting
it
ready
for
us
to
add
dab
network
services,
so
we'll
be
back
in
the
card
game
contract
which
you
might
remember
from
the
first
developer
course
or
from
the
block
one
online
elemental
battles
developer
course,
if
you've
done
it,
otherwise
you
can
go
ahead
and
download
the
information
in
a
bit
and
let's
go
ahead
and
pull
up
a
terminal
here.
A
It's
gonna
take
a
little
while,
but
because
it's
spinning
up
a
whole
bunch
of
things
but
go
ahead
and
run
it
now
once
that
is
done,
I'm
not
gonna,
run
it
because
it'll
just
eat
up
processor
speed
once
that's
done,
go
ahead
and
copy
the
files
in
the
zip.
That's
attached.
That's
in
the
text
description
here!
A
Alright,
so
go
ahead
and
paste
that
card
game
folder
in
with
the
card
game
folder
that
is
unboxed
by
Zeus
and
I
will
show
you
the
changes
that
have
been
made
from
the
end
of
the
block.
1
tutorial.
Ok!
So
if
you've
taken
the
first
developer
course
or
the
tutorial,
these
are
the
changes
that
the
little
differences
that
are
in
already
in
order
to
prepare
us
for
some
dab,
Network
usage
in
the
card
game.
A
Folder,
it's
clear
up
here
in
the
card
game
folder,
you
can
see
there's
a
number
of
things
that
Zeus
unbox
has
created
for
us
more
than
just
the
contract
and
front-end
folders
that
we
have
normally
in
our
card
game
folder.
When
we're
working
with
the
elemental
battles
card
game,
a
couple
of
changes
have
been
made,
though.
If
you
go
into
contracts,
there's
an
EOS
folder,
because
maybe
there
will
be
other
blockchain
folders
in
here
later
right
and
then
now
you
can
head
to
the
card
game
directory
within
that
EOS
folder.
A
So
we
are
in
this
directory
right
now
and
in
that
directory,
I'm
going
to
go
ahead
and
open
the
card
game
CPP
file,
which,
if
you
remember,
is
the
the
C++
part
of
the
contract
that
has
all
the
public
facing
actions
right.
There's
actions
you
can
actually
call
on
the
blockchain,
not
the
private
functions.
Those
are
in
game
play
CPP,
and
here
we
have.
This
is
the
familiar
card
game
CPP
file.
A
This
is
the
one
basically
that
the
block
1
tutorial
ends
up
with,
and
if
you
took
the
developer
course,
these
will
probably
all
say
action
instead
of
void.
It's
just
a
macro.
It's
fine
either
way.
The
major
change
that
has
been
made
to
the
contract
is
that,
instead
of
passing
in
variables,
one
by
one
to
all
these
functions,
sorry
passing
in
arguments
one
by
one
to
all
these
actions,
like
name
username
and
whatever
else
we
we
passed
in
here,
you
know
I,
don't
know
we
didn't
have
that.
But
you
know
there
were
lists
of
parameters.
A
We
include
them
all
in
a
struct
that
is
entitled
payload.
Alright,
it's
it's
of
the
player,
struct
type,
it's
which,
which
is
defined
in
the
header
file
as
usual,
and
we
call
it
payload,
and
this
will
pass
in
all
the
information
from
the
front
end.
A
JavaScript
object
will
be
passed
in
and
on
the
contract
side,
it's
received.
It's
destruct
called
payload.
That
way
we
can
do
where's
that
a
play
card
action
now,
you'll
notice.
A
This
is
actually
a
play
struct
here,
whereas
in
the
other
functions
it's
a
player
struct
because
normally
we're
just
passing
in
the
player
name
in
order
to
login
in
order
to
start
a
game
in
order
to
end
a
game
or
just
passing
a
player
name.
But
in
order
to
actually
play
a
card,
we're
passing
something
different:
we're
not
only
passing
a
player
name,
we're
also
passing
the
card
index
that
the
player
has
selected.
So
we
need
to
go
check
out
our
header
file
as
well.
A
A
And,
of
course
our
declarations
have
been
updated
to
not
have
name
username
but
to
have
these
Struck's
and
then
a
place
struct
as
well,
which
not
only
has
the
username
serialized,
but
also
the
player
card
index,
which
is
the
index
of
the
card
in
the
players,
hand
that
the
player
has
picked
to
play.
Okay.
So
here's
the
play
card
action
in
the
old
version
we
had
name
username
and
then
au,
int,
8,
T
and
I,
don't
remember
what
it
was
called,
maybe
something
like
card
index
or
selected
card,
or
something
like
that
now.
A
Instead,
all
that
is
put
together
in
this
struct
called
payload,
and
if
we
head
back
out
to
where
contracts
was
alright,
we
see
there's
also
a
front
ends
folder,
which
is
very
similar
to
the
front
end
folder
that
we
had
in
the
earlier
tutorial.
If
we
head
in
to
front
ends,
there's
one
main
front
end.
This
is
a
little
bit
of
new
territory.
It's
called
main
just
remember.
The
main
front
end
here
is
called
main
we're
gonna
reference
that
later
and
there's
our
source
folder.
A
That
looks
very
familiar,
this
public
source
and
node
modules
thing,
because
we've
worked
in
the
front
end
folder
before
in
the
card
game
tutorial
and
we
had
a
source
folder.
So
let's
go
into
that
source
folder
and
inside
we
see
the
familiar
actions,
components,
constants,
reducers
services
in
store
for
our
react,
Redux
node
setup
that
we
had
going
on
in
the
elemental
battles
tutorial
itself.
We
also
have
EOS
js2
wrapped
in
right
here.
I
think
we
are
using
an
older
version
of
EOS
Jass
earlier,
but
now
we've
upgraded
the
EOS
js2.
A
So
if
we
head
to
the
services
folder
and
our
old
friend,
the
API
service,
JavaScript
file
handles
everything
related
to
the
blockchain,
so
the
front-end
does
its
work
and
you
know
when
it
needs
to
post
to
the
blockchain
post
an
action
to
EOS
one
needs
to
push
an
action
when
it
needs
to
get
any
information
from
the
blockchain
it
does
that
via
API
service.
So
let's
look
at
API
service
and
see
what
has
changed
well.
First
of
all,
like
I
said,
there's
es
js2,
but
the
second
change
is
that
I
actually
implemented
this
change.
A
For
now
we
might
be
restructuring
this
a
little
bit
later.
Our
take
action
function
where
we
posted
the
smart
contract
action
Ahlul
on
a
call
and
also
the
data.
We
want
to
send
to
that
action
that
wasn't
that
wouldn't
work
with
the
new
contract
setup
with
a
payload
struct
right,
because
this
data
could
be
any
number
of
variables
and
we're
sending
them
all
in
the
contractors.
A
Object
and
say:
wait:
no
I
just
want
a
payload
struct
and
you
sent
me
a
name
and
an
integer
and
a
string
or
a
like
a
vector
of
integers
or
whatever
so
right
down
here,
I
actually
kind
of
wrapped
that
data
value
object.
That
comes
in
like
into
an
object
that
has
payload
like
the
data
value.
Object
is
wrapped
in
another
object
so
that
now
it
will
be
received
by
the
contract
and
will
be
correctly
received
and
the
contract
will
receive
its
struct
that
it's
looking
for
because
of
this
one
line
here.
A
Those
are
the
changes
that
have
been
made
in
order
to
get
us
to
a
point
where
we
really
can
learn
to
implement
vram
and
then
learn
to
implement
via
accounts
to
card
game.
That's
the
only
basic
change.
There
might
be
a
little
bit
of
restructuring
here,
but
I.
Look
through
I,
don't
really
see
anything
different
from
then
it's
a
pretty
straightforward
file,
so
you
can
look
through
it
yourself.
If
you
want
there
might
be
a
few
other
minor
differences,
but
we're
going
to
implement
vram
and
implement
via
accounts.
A
This
makes
a
great
starting
point
now,
since
we're
running
in
Zeus
here,
I
gotta
go
up.
Who
knows
how
many
times?
Okay,
since
we're
running
in
Zeus
here,
we
can
actually
use
one
command
to
spin
up
no
Dios
and
deploy
this
contract
to
it,
and
then
we
can
use
one
command
to
run.
Our
front-end
I
will
have
to
create
an
account
on
the
no
Dios,
but
that's
okay,
we'll
do
that
in
a
second.
So
let's
go
ahead
and
use
Zeus
migrate.
A
There
are
various
commands.
Let's,
if
I
do
Zeus
help,
we
can
see
all
of
them
various
commands
available
for
Zeus
there's
a
build
compile
which
will
compile
all
the
contracts
and
that's
a
part
of
my
grade.
We've
got
deploy
here
to
deploy
component.
A
large
number
of
commands
available.
We're
going
to
be
using
two
test
runs
a
full
test,
we're
going
to
be
using
Zeus
migrate,
and
then
we
will
use
Zeus
run
in
order
to
run
the
front
end
which,
as
we
saw,
is
named
mein.
So
let's
first
do
Zeus
migrate.
A
A
All
right,
it
looks
like
migration
is
done
successfully.
So
if
I
do
Cleo's
get
account
which,
as
you'll
recall,
defaults
to
local,
no
Dios
and
I,
ask
for
us
IO
information
there
it
is.
We
can
see
that
there
is
indeed
an
EOS
node,
that's
running
locally
now
in
order
to
interact
with
the
card
game
contract.
That's
been
deployed
right.
A
If
you,
if
you
go
up,
you
see
that
the
card
game
contract
was
deployed
to
card
game
one
over
one,
which
indeed
has
this
information
right
and
if
I
get
the
ABI
for
card
game
one
on
one.
We
can
see
all
this
information
about
the
smart
contract.
That's
been
deployed
the
actions
that
are
involved.
We
know
that
the
contract
is
deployed.
It's
running,
local
node
is
running,
but
we
need
a
user
account
in
order
to
use
the
card
game.
So
you
can't
just
create
account.
A
You
can't
actually
do
that
because
the
eoseo
system
contracts
are
deployed,
so
you
have
to
use
the
syntax
for
Cleo's
system
new
account
and
then
wanted
steak
for
CPU
steak
for
net
and
RAM
and
stuff
like
that
in
order
to
get
the
new
account
created.
So
with
that
in
mind,
we
do
need
to
take
a
look
at
our
Clio
squall
'its
I
just
launched
ki
Asti,
but
there's
no
wallets
listed
I
think
that
we
have
a
tutorial
wallet,
though
right
Cleo's
wallet
unlock
tutorial.
A
Yes,
now,
if
you
remember
in
my
default
directory
here
that
I've
created
for
the
purposes
of
this
tutorial
when
I
CLE,
it
created
my
Cleo's
wallet,
which
I
named
tutorial
I
saved
the
password
for
that
wallet
to
a
text
file
which
is
good
because
now
I
need
it
in
order
to
unlock
the
wallet.
So
if
I
list
with
hidden
files,
I
can
see
that
wallet
text
file
right
here,
I'm
gonna,
take
a
look
at
it
and
copy
this
out.
A
Colon
cue
to
exit
and
now
I
can
Cleo
swalot
unlock
tutorial
paste
in
that
password,
and
the
wallet
is
unlocked
great
now,
I've
already
I've
already
imported
the
development
key
here,
which
is
the
the
key
that
you
need
in
order
to
control
the
local
ESI.
Oh
and
do
things
like
just
create
accounts
and
sends
this
randomly
into
things?
A
But
if
you
haven't
done
that
or
if
you
don't
know
that
private
key
go
to
developers,
da-da-da-dah,
oh
and
in
the
getting
started,
tutorial,
1.5,
create
development
wallet
and,
and
it's
a
publicly
known
key
pair,
so
don't
use
it
anywhere
else.
Right
so
I
can
say:
Cleo
swalot,
import,
it'll.
Ask
me
for
private
key
I
paste
in
that
private
key
in
my
case,
it'll
say
non-existent
wallet
because
I've
named
my
wallet
tutorial,
but
if
I
actually
give
it
a
wallet,
name
and
paste
it
in
there.
A
In
my
case,
it
will
say
key
already
exists
because,
like
I
said,
I've
already
imported
it,
but
in
your
case
you'll
need
to
do
this
in
order
to
get
that
development
key
active.
So
that
lets
you
do
things
now
like
Cleo's
wallet,
sorry
Cleo
system,
new
account
and
I,
actually
I'm
going
to
need
a
public
key
here.
So
if
you
remember,
I
also
had
a
key
pair
that
I
created
here
and
I
saved
it
to
keys
dot
text
back
in
the
Clio's
tutorial.
A
So
let
me
get
that
up
this
private
key
right
here,
so
that
8f
7
can
be
the
public
key.
That
controls.
My
wallet
so
I
need
that
public
key,
actually
system
new
account.
The
creator
of
the
account
I'll
actually
need
options.
First
and
the
options
are
steak
net
steak
CPU
and
by
Ram
Kbytes.
So
what
I'm
going
to
do
is
clear
system
new
account
and
then
the
options
steak
net
10
sis
which
is
then
the
local
version
of
yose.
A
When
you
have
a
development,
know
Dios,
you
use
sis
instead
of
use
and
then
by
Ram
kilobytes.
Let's
do
3,300.
Why
not?
And
then
the
Creator
is
eoseo,
the
account
we'll
call
it
game,
player,
42
and
then
the
public
key,
and
if
you
just
paste
the
public
key
once
it
assumes
that
that's
the
owner
end
active
key.
If
you
wanted
a
different
one,
you
could
paste
a
different
active
key
afterwards
that
should
work
it
did.
We
we
create
an
account
new
account.
A
We
bought
some
RAM
for
it
and
everything's
all
good
to
go
with
that
account.
We
can
check
to
make
sure
Cleo's
get
account
game,
player,
42
and
there
it
is.
It's
got
like
we
said,
10,
sis
delegated
to
net
and
CPU
both,
and
it's
got
some
RAM.
It
is
using
a
little
bit
because
every
account
uses
a
little
bit,
but
it's
got
most
of
the
300
kilobytes.
We
gave
it
so
now
that
we
have
an
account.
We
can
head
back
to
our
card
game
folder,
alright,
we're
in
our
card
game
folder.
A
This
is
where
our
Zeus
unbox
was
and
where
we
made
those
updates
to
get
rid
of
vram
and
V
accounts,
but
also
to
to,
on
the
other
side,
to
have
that
struct
right-
and
this
is
where
we
run
our
Zeus
commands.
So
I
already
ran
Zeus
migrate
here
in
order
to
deploy
the
contract
to
know
do
so,
don't
no
need
to
do
that
again.
The
contracts
compiled
the
contract
is
deployed
to
a
local
version
of
it's
ready
to
go,
but
I
don't
have
a
front
end
going.
A
I
can't
actually
interact
with
it
in
any
way
other
than
just
sending
it
Cleo's
commands,
which,
while
I,
could
do
that.
It's
not
particularly
fun
gameplay
experience
for
actions
that
require
things
like
card-index,
and
so,
let's
run
Zeus
run
front.
End
mean,
if
you
remember
in
the
front
ends
folder
there's
a
main
folder,
and
that
is
where
our
front
end
is
located.
This
will
run
our
react
redux
front
end
right
here
and
so
that
we
can
access
it
from
a
browser
and
interact
with
our
local
version
of
the
contract
running
on
local,
no
Dios.
A
That
was
fast.
We
started
up
quickly,
alright,
so
if
we
open
any
browser
and
go
to
that
address
that
it's
showing
us
it's
running
on,
it
will
take
us
to
elemental
battles
all
right.
This
front
end
is
running
locally.
We
go
ahead
and
enter
our
account
that
we
have
created
and
also
the
private
key
that
matches
the
public
key
that
we
use
to
create
the
account.
Ok,
that
we
just
did
that
right.
A
It
might
be
in
that
keys
text
file
if
you're,
really
following
along
private
key
that
matches
we
login
and
hey
we're
in
and
it
looks
like
everything
is
working
great.
Let's
start
a
game
alright,
so
this
is
running
locally.
We
can
go
ahead
and
check
that
right
now,
alright,
so
I'm
going
to
check
I'm
going
to
open
a
new
tab
since
we're
running
the
front-end
in
this
one.
If
I
clio's
get
table
alright
locally
and
I
need
to
specify
the
account
the
scope
and
the
table
name,
let's
get
the
table.
A
What
was
it
called
users
whoops?
Let's
get
the
table
from
the
account
card
game,
1,
1,
1
1,
and
then
we
need
the
scope
which
I
believe
we
don't
scope
the
tables
to
users
right
and
then
we
need
the
actual
table.
Name:
users:
hey
there
we
go.
Ok,
we
have
yes
locally.
We
have
user
gameplay,
42,
he's
playing
a
game
right
now:
there's
5
player
life,
5
AI
life
and
here's.
A
The
deck
Zeus
has
spun
up
a
node
for
us
locally
with
Zeus
migrate,
and
then
we
did
have
to
do
some
account
creation
stuff,
which
that
was
a
little
bit
of
a
hassle.
But
one
command.
Zeus,
migrated
spun
up
a
local
node,
built
the
contract,
deployed
it
to
the
local
node
right
and
then
that
one
command
zeus
run
front-end
main
ran
a
front-end
force
that
we
can
actually
play
our
app
alright.
A
So
this
is
the
framework
that
we'll
be
working
within
and
the
zeus
development
kit
in
order
to
add
vram
to
this
very
game
because,
like
right
now
this
all
this
stuff
takes
a
huge
amount
of
RAM.
It
would
be
feasible
to
deploy
this
game
to
main
net,
maybe
because
the
users
are
paying
for
the
resources
right,
but
it
wouldn't
be
feasible
to
hope
to
do
it
at
scale
and
have
the
developers
pay
for
the
users
ram
and
resources,
which
is
a
more
adoptable
model.
A
The
users
data
is
only
kept
in
RAM
when
the
users
active
session
is
going
and
when
the
user
is
away
its
evicted
to
vram
we'll
be
adding
that
strategy
over
the
next
few
lessons
so
install
the
IDE
of
your
choice:
ok,
vs
code,
if
you
don't
know,
install
the
IDE
of
your
choice
before
next
lesson,
so
that
we
can
just
open
that
folder
and
start
working
with
the
code
and
a
more
comfortable
environment
may
be
for
you,
then
those
command
line
editors
that
we've
been
using
so
far.
Alright.