►
From YouTube: Arweave - Intro to DataFI Part 1: SmartWeave(Permaweb)
Description
DataFi is the concept of combining permanent Data + NFT (Non-Fungible Token) + Permaweb + SmartWeave Contracts + PST (Profit Sharing Token) in ways that provide decentralized finalization features for immutable storage in the Arweave community. So that is a mouth full of concepts. 😀 For us to get a deeper understanding of the bundled concept of DataFi, we will need to dive down the rabbit hole of each of these technologies. We will not go deep, but hopefully deep enough for you to get a full understanding of what DataFi can be. We will also discuss some use cases that are applying this concept in practice, and some potential use cases for this concept.
In this workshop, we walk through an example of embedding a Permaweb Application inside a SmartWeave Contract.
Workshop Notes: https://permanotes.app/#/notes/hfCjF9VYNjQFJa3tZ7Mb68L0Ke0LFLGLbn-rx28dSMQ
Demo: https://arweave.net/IBmNAx1Q6ZF5JkiJ4bfAou6ehtHk8VPUK_406qQRz5s
Github Repo: https://github.com/twilson63/datafi-smartweave-dapp
Community Discord: https://discord.gg/8vxJCtzBBJ
A
A
A
Smart
contract
functionality
of
atomic
nfts,
giving
you
the
ability
to
transfer
ownership
and
see
balances
of
certain
things
and
then
finally,
profit
sharing
tokens.
So
you
know
changing
the
the
dynamic
nature
of
the
ownership
from
just
instead
of
a
single
wallet
owner
to
a
collection
of
owners
that
that
all
have
tokens
to
represent
that
collection
and
leveraging
that
information
dynamically
within
the
application
itself.
A
A
So
a
permaweb
app
is
essentially
a
static
site
or
a
single
page
web
application
that's
stored
and
served
on
the
rweave
network
via
an
rwev
gateway.
So
you
can
basically
get
a
our
weave
transaction
id
connect
that
to
rwev.net
or
or
any
gateway,
saying,
slash
and
then
transaction
id,
and
then
your
application
loads.
And
that's
what
we
call
a
perma
web
application,
because,
because
it's
on
our
weave,
it
is
available
forever
that
url
will
be
reachable
forever.
A
And
what
we're
going
to
do
is
take
a
perma
web
app
and
we're
going
to
put
it
inside
a
smartweave
contract
and
then
that
permaweb
app
is
actually
going
to
execute
the
interactions
in
the
smartweave
cont
contract
and
for
our
purposes
it's
going
to
be
super
simple.
It's
going
to
just
capture
the
visits
that
are
recorded
via
the
app
and
I've
actually
got
it.
Working
and
I'll
show
you
a
quick
demo,
so
this
permaweb
app,
that
is
this
id
up
here,
is
our
app
and
what
it's
doing
is.
A
And
we
paste
that
transaction
id
and
you
can
see
that
it's
also
a
contract.
So
this
application
is
not
only
an
application,
but
it's
a
smart
contract
and
it's
got
the
the
code
here
and
we've
got
our
initial,
our
current
state
of
23
and
every
time
I
modify
that
I'll.
Just
click
visit
and
it's
going
to
ask
me
to
sign
in
and
it's
set
it's
going
to
read
and
that's
24..
So
now,
if
I
go
to
state
here,
probably
need
to
refresh
let's
refresh.
A
And
it's
now
24.,
so
this
is
really
really
cool.
You
can
have
a
herma
web
application,
that's
wrapped
in
a
smart
contract
and
then
the
perma
web
application
can
actually
execute
functions
on
that
smart
contract.
So,
let's
kind
of
walk
through
how
that
works
and
again
we'll
figure
out.
You
know
all
the
steps
and
pieces.
So
I
have
some
notes
here
where
we'll
you
know
kind
of
create
our
first
contract
and
then
we'll
actually
create
a
deployment
script
to
deploy
the
contract
source
and
so
on.
A
So
we'll
just
walk
through
that
together
and
hopefully
all
of
this
will
make
sense,
so
our
smart
contract
can
be
javascript
or
it
can
be
rust
or
go,
or
I
think
assembly
or
wasm
assembly
script.
But
for
for
this
purpose,
we're
gonna
we're
gonna
use
javascript
and
so
our
javascript
we
have
this
handle
function.
So
every
smartweave
contract
needs
an
entry
point
and
it's
this
handle
function
and
the
handle
gets
the
current
state
and
then
any
actions,
and
this
if
you're
familiar
with
tools
like
redux.
A
A
Now
there
are
features
with
the
redstone
warp,
smartweave
toolkit,
where
you
can
do
internal
contract
calls,
but
but
we're
not
gonna
talk
about
that
today.
But
that's
that's
really
exciting
stuff.
So
with
this
we
have
our
handle
function
and
it's
simply
going
to
see
if
any
functions
are
included
in
this
functions
object
and
they
match
this
action
input
function
and
if
they
do,
then
we
call
that
with
state
and
action.
A
So
we
have
this
input,
function
called
visit
and
it
takes
the
state
in
action
we
take
the
state
and
the
dot
count
property.
We
increment
it
by
one
and
we
return
state
so
that
that's
our
contract
extremely
simple,
but
you
know
a
pst
is
a
contract
and
an
atomic
nft
is
a
contract
so
in
the
future,
we'll
actually
start
to
use
a
little
bit
more
sophisticated
contracts
in
these
demos.
A
A
A
So
we
have
to
actually
call
and
put
the
transaction
directly
on
our
weave
so
that
we
can
add
custom
data
and
in
in
order
to
do
that.
We
we,
you
know
the
the
redstone
smartwave
sdk
needs
to
see
that
and
if
we
put
it
in
a
bundle
transaction,
it
won't
be
able
to
see
those
transactions.
So
I
try
to
explain
it
better
in
the
notes,
so
we'll
go
through
it,
but
the
the
gist
is
is
for
now
and
I
think
it'll
change
in
the
future.
A
A
A
A
A
A
A
A
I
think
it's
assets
slash
index
something.js
file,
so
we
need
to
deploy
those
files
and
but
you
know
we
can't
deploy
them
because
we
haven't
created
them
yet.
So
we
need
to
do
that.
But
then
the
the
final
piece
is
we'll
deploy
our
contract
with
a
path
manifest
file
inside
and
the
path
manifests
file.
You'll,
see
kind
of
demonstrates
the
the
routes
of
the
permaweb
app
it's
kind
of
the
router.
A
So
let's
create
our
permaweb
application
and
we
installed
spelt
we're
using
svelt
and
we
installed.
Are
we
wallet
connector?
So
when
we
click
our
button,
that's
going
to
pop
up
the
rweave.app
wallet
and
a
couple
of
things
when
you're
using
felt
for
perma
permaweb
apps.
You
need
to
set
this
base
equal
in
the
byte
config,
if
you're
using
svelt
and
byte
or
beat
whatever
it's
called
so
so
you
need
to
do
that.
Are
it
won't
be
happy?
A
And
now
what
we
want
to
do
is
just
modify
and
I've
already
done
it.
Our
index.html
file
added
some
tailwind
stuff
to
make
things,
look:
okay
and
then
we're
bringing
in
this
redstone
smartweave
bundle,
which
is
a
pretty
large
file.
It's
like
a
500
kb
file,
so
I
I
just
don't
want
to
embed
that
in
my
transpiled
javascript.
A
A
A
Dot,
memcached,
r,
weave,
okay,
so
that'll
set
up
our
smartweave
object
and
now
our
visits
is
a
counter,
so
we'll
declare
a
variable
called
count
and
set
it
equal
to
zero
and
then
we're
gonna
get
the
do
a
little
trick
to
get
the
contract
id
by
just
grabbing
the
location
path,
name
and
removing
the
backslashes
of
the
location
path.
Name.
A
And
if
you
look
up
here,
we
have
you,
know
kind
of
the
forward,
slash
and
the
backslash
we're
going
to
remove
those
and
get
what's
in
the
middle,
and
that
will
be
our
contract
id
now.
Maybe
better
ways
to
do
this,
but
for
this
demo
it
works
great.
So
we
will
fire
up
our
contract
smartweave
contract
and
giving
it
our
contract
id
awesome.
A
A
And
it's
simply
going
to
return,
the
contract
read
state
and
the
restate
function
will
actually
run
without
having
to
be
connected
to
a
wallet.
So
that's
why
we
want
to
run
the
re,
read,
state
function
and
and
that's
a
promise
so
we're
just
going
to
essentially
pop
the
state
property
off
of
that
promise
by
just
saying
res.state,
and
so
when
we
call
it
in
our
markdown
it'll
give
us
our
state
and
we
can
paint
state.count
and
then
the
other
function
we
want
to
create
is
the
do
visit.
A
Call
contract
dot,
connect
and
tell
it
to
use
our
our
web
wallet
right.
So
our
we've
got
app
wallet
and
you
do
that
just
by
passing
string
use
wallet
and
then
we're
going
to
actually
call
bundle,
interaction,
bundle,
interaction
will
go
through
the
redstone
library
and
actually
write
the
interaction
using
bundler,
which
will
get
a
much
faster
cache
response
time
doing
that
so
by
calling
bundle,
interaction,
our
execution
will
be
a
lot
faster
and
and
we're
gonna
pass
in
our
input
and
our
input
object.
A
So
that's
our
the
majority
of
our
app
right
there,
our
perma
web,
app
and
I'll
go
ahead
and
paste
the
markup
in
so
the
most
important
part
of
this
markup
is:
we've
got
this
await
directive,
which
is
going
to
grab
the
visits
and
while
that's
loading,
it's
just
going
to
show
this
loading
number
of
visits.
Then
we
get
some
state
and
that
state
should
have
a
count
so
we'll
display
the
count.
A
A
A
Npm
run
build.
We
want
to
build
that
into
two
files,
so
we
have
this
index.html
file
and
we
have
this
assets
index
and
file.
So
now
in
our
deploy
script,
we
need
to
write
the
code
to
deploy
that
perma
web
on
rwev
that
permaweb
app
on.
Are
we
so
we've
got
this
contract
id
and
there's
no
need
to
add
a
new
contract
id.
So
I'm
just
going
to
say:
const
contract
source
equals
this
and
that's
our
contract
source
id
and
then
what
we
need
to
do
is.
A
A
A
A
A
So
with
this
one
we
create
a
transaction
and
we
make
sure
it's
application
javascript,
because
that's
what
the
file
that
we're
uploading
is
and
then
the
the
last
piece
of
this
is
to
build
our
path
manifest
and
our
path
manifest
is
kind
of
a
json
file
and
it's
got
the
manifest
property.
Our
weave
slash,
pass
the
version
index
with
path
as
index.html
and
then
that
tells
rwev
gateway
which
file
is
the
root
file.
So
when
I
come
to
this
path
here,
it's
going
to
say,
oh,
I
need
to
load
the
index.html
file.
A
If
that
doesn't
exist,
it's
just
going
to
list
a
directory
of
all
the
paths
that
are
located
in
this
path
manifest
and
then
each
path
manifest.
You
have
the
property
which
represents
the
logical
name
and
then
an
object
with
an
id
that
represents
the
transaction
identifier
on.
Are
we
so
we've
got
index
and
then
we
have
assets
index
blah
blah
blah.
A
Data
app
just
be
our
path
manifest,
and
then
we
have
to
add
some
tags
and
I'm
just
going
to
paste
them
in
and
we
can
go
through
each
one.
So
the
content
type
is
application
x
dot.
Are
we
manifest
plus
json?
The
app
name
is
smartweave
contract.
That
has
to
be
what
it's
called.
The
app
version.
0.3.0
needs
to
be
there.
Contract
source
contract
source
is
the
identifier
of
the
contract
that
we
uploaded.
So
here's
our
contract
source
identifier
up
here
and
then
the
initial
state.
A
A
Let's
do
noi
node
deploy
and
I'm
not
sure,
just
a
little
bug
here.
Hopefully
I'll
fix
that
soon,
but
some
of
the
node
apps
are
not
working
for
that.
So
anyway,
I'm
going
to
save
this
repository
on
github,
so
you
can
kind
of
check
it
out
and
that's
really
kind
of
the
the
gist
of
the
workshop.
You
can
actually
see
a
working
version
here
and
we'll
just
add
another
visit
just
for
fun
and
yeah
check
it
out.