►
From YouTube: vRAM part 3 (Codealong): Adding Scalable Storage to Your EOSIO dApp (Blockchain Dev by Peter Keay)
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 add vRAM to the cardgame contract with a few simple additions to the C++ header file and the frontend's ApiService.js file. Scalable storage with minimal effort! Note that we do not use the newer dapp-client JS library in this lesson, but it will be introduced soon.
**CODE DOWNLOADS**
Beginning of lesson (merge into cardgame folder after running zeus unbox cardgame): http://bit.ly/abdt-lesson7
End of lesson: http://bit.ly/abdt-lesson8
**IN THIS VIDEO**
00:46 Preprocessor directives for the contract's C++ header file
03:18 Adding the necessary typedefs and shardbucket struct for our tables
07:05 Fixing a few typos
08:22 Creating a new account on local nodeos
09:16 Enabling the frontend client to work with vRAM
13:16 Running (and viewing data from) the vRAM-enabled dApp
**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
A
A
The
way
this
is
gonna
work
is
again
we're
kind
of
tricking
yose
into
having
these
features,
so
we're
going
to
do
things
that
normally
aren't
allowed
in
the
contract
and
our
DAP
service
providers
will
pick
up
that
those
are
feature
requests
in
this
case.
They
are
requests
to
use
veeram
and
we
need
to
set
a
number
of
preprocessor
directives
down
here,
including
deaf
services,
actions
and,
of
course
this,
if
you're
not
familiar
just
means
we're
continuing
the
line
will
always
need
signal
and
for
VRAM
we're
going
to
include
the
ipfs
actions.
A
So
it's
X
signal
action
and
ipfs
actions
and
then
we're
going
to
go
ahead
and
define
commands
as
well.
I
PFS
service
commands
dabbe
network
services,
while
they
do
have,
with
the
exception
of
VRAM
in
CPU,
they
have
names
like
liquid
link
liquid
Oracle's
liquid
accounts.
They
also
have
intern
names
that
you'll
see,
for
instance,
liquid
accounts
is
kind
of
unwieldy.
It's
called
V
accounts
generally
well.
A
Whenever
we
see
ipfs
ipfs
service
referred
to
you
here,
we're
usually
talking
about
vram
and
then
finally,
we
do
need
to
set
the
contract
name
as
card
game
or
whatever
your
contract
name
is
going
to
be
because
we're
going
to
replace
this
stuff
here
with
a
macro
contract
start
and
we
need
to
terminate
it
with
contract
and
the
contract
ends.
Since
we
already
served
the
name
here,
the
contract
end
statement
will
not
have
a
contract
name.
Just
all
of
our
public
actions
listed.
That's
it
for
this
stage.
A
Now
we
need
to
step
into
the
actual
contract
itself
and
do
a
little
bit
of
work
with
our
tables,
so
that
vram
will
be
used
by
the
contract.
Let's
head
down
to
where
our
table
depths
are
we're
not
going
to
touch
seed
seed,
we'll
just
remain
in
RAM.
After
all,
it's
seed
isn't
a
huge
amount
of
data.
It's
just
it's
just
keeping
a
seed,
so
we'll
keep
seed
in
RAM,
but
the
user
info
table,
which
includes
this
game
struct
and
a
game.
A
Struct
is
quite
large,
including
numerous
vectors
that
is
a
good
candidate
to
convert
to
V
RAM,
and
it
also
only
has
one
key:
there's
no
secondary
key
right
now.
Veeram
doesn't
support
secondary
indices,
there's
only
one
index
on
this
table,
so
despite
it
being
a
multi
index
table.
So
first
we're
gonna,
take
our
main
type
def
here
for
our
users
table
and
we're
going
to
change
the
type
from
yo
co
multi
index
to
dap
multi
index.
That's
what
we
included
here
with
DAP
services,
multi
index
header
file,
and
it
it's
a
drop-in
replacement.
A
Although
you
do
need
to
make
some
other
changes
that
enables
vram
for
this
user's
table,
so
the
contracts,
many
references
to
the
user's
table.
If
you
recall
user
users
is
everywhere,
it
holds
game
data,
it
holds
user
data,
it
holds
card
data,
it
holds
every
kind
of
data
that
is
held
in
this
contract
except
a
random
seed
is
held
in
users.
So
we
just
replaced
that
table
with
a
dab
multi
index
table
of
VRAM
enabled
table.
A
A
A
A
All
right,
so
we
just
created
a
shard
bucket
struct
for
this
this
table,
and
now
that's
actually
it
so
we
did
a
little
bit
of
magic
up
here
with
defines
including
these
contract
start
and
contract
and
macros.
And
then
we
modified
our
main
table
that
we
wanted
to
enable
vram,
for
we
didn't
even
modify
the
struct.
We
just
dropped
in
dap
instead
of
ESI
o
dat
multi
index
table,
and
then
we
had
to
create
this
shard
bucket
table,
and
that
is
all
we
needed
to
do.
A
A
Guys
are
ruined
it
I
ruined
it.
Guess
what
look
at
that
top
error
expected
semicolon
after
strug's
come
on
I.
Do
this?
It's
just
like
so
basic
and,
as
you
know,
every
time
I
miss
a
semicolon.
After
a
struct
declaration,
it's
reinforcing
behavior.
Also
make
sure
you
don't
have
this
closing
brace
I
know
we're
used
to
the
class
declaration
up
here
that
that
was
here
where
it
was
like.
A
You
know,
contract
card
game,
ball,
Allah
and
then
I
had
an
opening
brace
we're
used
to
having
that
class
declaration
end
with
a
closing
brace
followed
with
a
semicolon,
but
that'll
mess
you
up
because
that's
included
in
the
contract
start
and
contract
end
macros,
so
also
made
that
mistake.
I'm
gonna
save
the
file
now
and
this
time,
if
we're
not
good
to
go
I'm
quitting
my
job,
alright
looks
good,
looks
like
we
have
deployed
now.
A
Actually
we
need
to
create
a
whole
new
account
in
order
to
do
this
because
we're
running
on
a
new
fresh,
no
do
so.
I'm
gonna
open
a
new
terminal,
tab
Cleo's
is
running
and
we
need
to
create
an
account
using
the
system
contract
thing
we
did
before.
So
we
need
to
do
wallet
unlock,
which
means
I
need
that
password.
So
let's
go
to
that
passwords
file.
A
Copy
out
this
password
Cleo's
wallet,
unlock
our
tutorial
wallet
and
then
do
cleo
system
new
account
with
game
player.
4
the
public
key
and
resources
required
its
executed.
The
account
now
exists:
I'll
pull
up
brave
I
have
this
saved
here
we
go
Oh
No,
so
I'm
gonna
disappear
here
for
a
little
bit.
We
do
need
to
make
some
front-end
changes
in
order
to
enable
VRAM
here
up
here
is
the
current
api
service
file
we
have
down
here.
A
A
Okay,
we're
still
doing
basically
the
same
thing
that
we
did
before
we're
getting
table
rows,
but
instead
of
using
this
typical
method,
we
are
using
the
IP
FS
service.
One
method
forget
table
row,
of
course,
because
we
need
to
be
able
to
access
this
table
row,
even
though
it's
in
vram,
it's
not
currently
in
RAM
when
we're
just
reading
data
right.
The
simple
act
of
reading
data
outside
of
the
contract
just
in
the
front
end,
does
not
warm
the
data
up
into
RAM,
so
we
need
to
instead
of
awaiting
the
RPC
blah
blah
blah
blah.
A
We
were
getting
rows,
so
we
can
get
rid
of
limit
one
and
with
get
table
row
we're
not
looking
for
a
lower
bound,
we're
actually
looking
for
a
key
and
then
we're
just
going
to
return
one
row
rather
than
row
zero,
because
the
result
is
just
one
single
row:
we
don't
need
this
JSON,
either
and
rather
than
code.
This
is
contract
now
and
I.
Don't
really
need
to
do
this,
but
it's
a
little
cleaner,
looking
looks
more
like
the
official
sample,
so
that
diffs
will
be
easier
if
we
have
a
problem
later,
all
right.
A
So
now
our
get
user
by
name
function
is
up
to
date.
I
can
probably
head
back
over
to
the
front-end
and
give
it
a
try.
Now
it's
telling
me
post
data
and
endpoint
are
not
defined.
There
is
in
fact
a
new
post
data
function.
That's
been
added,
it's
a
pretty
simple,
looking
function,
let's
grab
it
copy
it
in
paste
it
in
here
to
our
API
service
file.
I
must
have
pasted
it
in
the
wrong
yeah,
but
plopped
it
in
the
class.
Let's
take
it
out
of
there,
declare
it
up
here.
A
Okay,
so
now
our
post
data
is
ready
to
go
where
we're
posting,
whatever
the
data
is
to
whatever
the
URL
is,
and
in
our
case
the
URL
we
want
to
post
data
to
is
our
endpoint
and
then
this.
This
is
the
rest
of
the
URL
right
here.
So
we're
posting
data
to
the
get
table
row
I
was
actually
a
little
confused
as
to
why
endpoint
is
not
defined.
It's
because
it's
declared
out
here
in
the
take
action
function.
A
Let's
declare
it
up
here
and
we're
also
going
to
do
this
thing
where
I
set
another
variable
named
URL.
To
be
the
end
point
so
now,
endpoint
is
declared
in
the
proper
scope.
When
you
declare
the
variable
inside
a
function,
as
you
know,
you
can't
then
use
it
inside
a
different
function.
So
now
endpoint
should
be
available
as
well
to
get
user
by
name
since
it's
declared
up
here
and
there
we
are
alright.
A
Let's
go
ahead
and
login
as
game
player
42
there
we
go
looking
great,
let's
see
if
we
can
actually
start
a
game,
Hey
whoa,
all
right.
We
just
started
a
game
on
vram.
Can
we
confirm
that
yeah
we
can
do?
We
can
definitely
confirm
that
let's
get
the
table
for
the
card
game,
one
one,
one
one
contract,
also
in
scope,
one
one
one
one:
the
users
table:
oh,
it
doesn't
have
the
things
we're
used
to.
It
doesn't
have
like
a
username
and
a
game
status
and
all
this
other
nonsense.
A
It
just
has
this
shard
identifier
stored
in
the
users
table,
so
our
contract
situation
in
our
card
game
contract
our
card,
that's
the
wrong
file.
The
header
file,
our
card
game
situation,
where
we
declared
the
shard
bucket
as
users
table
aid
for
the
ABI
this
table
the
user's
table
up
here
is
the
table.
The
contract
works
with
as
it's
going
through.
All
these
things
right.
We
have
users,
users,
users,
the
only
declaration
of
users
with
the
underscore
is
right
down
here.
A
It's
a
user's
table
type,
it's
definitely
adapt
multi
index
table,
and
it
definitely
has
this
struct
with
all
the
game
data
and
all
that
information
involved.
So
the
contract
is
working
with
that
table.
But
as
far
as
the
ABI
is
concerned,
when
you
call
the
users
table,
you
instead
hit
this.
The
shard
bucket
struct,
so
where's
the
users
table,
does
hold
user
data
while
the
contract
is
working
with
it.
This
table
that's
exposed
to
Cleo's
via
the
ABI,
is
not
the
same
table.
It's
this
table
based
on
shard
bucket
right
now.
A
Only
this
URI
is
being
stored
in
RAM,
no
matter
how
large
the
amount
of
information
this
is
being
stored
in
RAM
I
want
to
try
something
else
here,
right,
let's
go
and
make
a
new
account
again
we're
gonna
use
the
same
key,
but
this
one's
gonna
be
called
game
player.
43.
It's
created
all
right.
I'm
gonna
go
back
into
my
my
game
here
and
quit.
A
I
want
to
log
out
entirely
there's
no
logout
button,
so
so
I'm
just
gonna
open
this
in
a
new
incognito
browser
still
fill
the
passwords
but
game
player.
43
now
is
the
account
so
game
player.
43
has
now
started
a
brand
new
game.
Alright
42
has
this
game
going
on
43.
Has
this
verifiably
different
game
going
on?
Alright
I've
got
two
accounts
running
two
games.
A
What
does
the
table?
Look
like
two
shards
alright,
so
we've
got
two
sets
of
data
now
ready
to
be
warmed
up
when
required.
Subscribe,
follow
the
channel,
whatever
your.
If
you're,
watching
on
the
platform
make
sure
you
check
out
the
text
do
the
little
challenge
afterwards.
As
always,
so
we
have
created
affordable,
scalable
storage
for
our
adapter.