►
From YouTube: Arweave Intro to DataFI - Part 2 - Atomic NFTs
Description
In this workshop, we walk through step by step the Atomic NFT concept from creating a smart contract to minting, to checking owner balance and transferring ownership.
DataFi
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.
AtomicNFT
Atomic NFT is a standard where the media assets and the contract metadata are stored together immutably under a single unique identifier. -- https://atomicnft.com/en/General-definition-of-an-atomic-NFT/
Workshop Notes:
Permanotes: https://permanotes.app/#/notes/KmLNIowE2DhWHnW-YQzWwTO0O1r7PAlFCj29vPq4BQ0
Github REPO: https://github.com/twilson63/datafi-atomicnft
Data Asset we will use for this workshop
Winston
https://arweave.net/je2PgRDv0XRbqQiUrCovofwlZHeYOS7WJrFJGigqNoY
A
So
in
this
workshop
we
are
going
to
talk
about
atomic
nfts
to
get
the
most
out
of
this,
you
should
be
familiar
with
the
concept
of
blockchains
the
concept
of
nfts
and
have
some
some
good
skills
around
being
a
full
stack
developer,
primarily
html,
css
and
javascript,
also
rwev
concepts,
understanding
the
data,
storage
and
smartweave
concepts.
If
you
don't
understand
those,
you
know
check
out
rweeb.org,
or
you
know,
check
out
the
previous
workshop
where
we
talked
about
the
web
and
combining
the
perm
web
in
smartweave.
A
A
So
on
r
weave
we
have
a
trustless,
permissionless
and
composable
platform
where
we
can
deploy
data
and
we
can
deploy
applications
and-
and
we
have
these
tools
like
the
permaweb
and
smartweave
contracts
and
atomic
nfts
and
psts,
and
I'm
kind
of
composing
those
together
into
this
datify
concept.
So
what
is
an
nft.
A
You
know
the
basic
kind
of
definition
is
it's
a
token
that
shows
ownership
of
an
asset
in
most
situations,
a
digital
asset,
and
that
digital
asset
can
be
many
things
and
and
part
of
the
atomic
workshop
is.
It
can
also
be
application
rb
html,
so
you
can
have
html,
css
and
javascript
part
of
that
stored
on
the
perma
web.
A
So
nft
shows
ownership
to
a
digital
asset.
An
atomic
nft
is
where
media
assets
and
the
contract
metadata
are
stored
together,
immutably
under
a
single,
unique
identifier.
So
I
like
to
kind
of
visualize
this.
As
this
box
is
your.
Are
we
transaction
your
identifier
and
then
you
have
your
data
or
your
digital
asset,
and
then
you
have
your
smart
weed
contract,
the
actual
code,
the
initial
state
and
then
your
metadata
that
really
lets
these
tools
know
what
it
is
that
that
you
have
so.
A
A
So
the
initial
attributes,
you
have
an
initial
state
in
a
smartweave
contract
and
here's
kind
of
the
initial
attributes
of
an
atomic
nft
based
on
the
atomic
nft.com
site.
You
have
an
owner
which
is
the
address
of
the
creator
of
the
nft.
Now
that
that
will
never
change,
even
if
the
ownership
is
transferred.
So
it's
it's
the
creator
and
then
the
title
is
the
name
of
the
nft
description
as
a
description
of
it.
And
then
you
have
these
name
ticker
attributes
which
can
associate
to
a
pst
and
two
examples.
A
One
could
be
a
virto
pst
another
another
could
be
a
koi
pst
and
we'll
explore
others
in
in
later
workshops.
And
then
you
have
this
balances
object
and
this
basically
keeps
track
of
the
the
owners
of
the
nft.
So
you
have
address
as
a
property
and
quantity
as
a
value,
and
you
know
with
nft
since
they're
non-fungible
there's,
you
know
kind
of
one
owner
at
a
given
time.
A
The
locked
array-
this
is
for
a
extended
feature
of
this
atomic
nft
to
bridge
other
l1s
like
ethereum
or
solana,
et
cetera.
We
won't
talk
too
much
about
that.
I
don't
know
you
know
how
that's
going
to
evolve,
but
definitely
not
part
of
this
workshop.
It's
just
a
requirement
to
this
nft
standard.
Then
we
have
the
content
type,
which
will
be
the
type
of
digital
asset.
In
our
case,
it'll
be
an
svg
for
this
workshop.
Then
we
have
created
at
which
is
a
unix
timestamp.
A
A
A
A
But
the
basic
atomic
nft
is
what
we're
going
to
do
today
and
we're
going
to
take
our
friend
here
winston
and
we're
going
to
make
winston
and
nft.
So
with
that.
We're
going
to
go
ahead
and
jump
into
the
workshop
and
we're
going
to
open
our
visual
studio
code
window
right
here
and
we
have
just
an
empty
repository
and
I'm
going
to
see.
If
I
can't
get
my
notes
up
really
quick.
A
So
we'll
run
ar
local
on
this
terminal
window
and
we'll
a
new
terminal
window
where
we'll
do
our
work,
so
we'll
have
a
new
window
here
where
we'll
work
in
our
projects.
While
we
have
ar
local
running
in
the
background-
and
we
can,
you
know-
kind
of
go
check
out
ar
local
here,
we'll
pop
that
up,
and
you
can
see
that
it's
running
under
local
host
port
1984.,
now
we're
going
to
create
a
new
directory
called
atomic
nft
demo
and
in
that
new
directory
we're
going
to
create
a
project.
A
A
A
A
A
A
Then
we're
gonna
generate
a
jwk
for
our
wallet
and
then
we're
going
to
grab
the
address
of
that
wallet
and
we're
going
to
save
it
to
wallet.json
and
then
finally,
we're
going
to
mint
100
ar
to
that
wallet
and
that's
going
to
really
help
us.
You
know:
write
our
transactions
to
the
devnet,
so
we'll
just
run
that,
and
hopefully
we've
got
a
wallet
json
and
it's
minted.
So
I'm
going
to
mine
our
local
devnet,
so
we
say:
curl
local
host,
calling
1984,
slash,
mine
and
I'll
just
process
those
transactions
on
the
devnet.
A
So
now
that
we've
got
our
wallet,
we've
got
our
data,
which
is
winston.svg
and
now
we
need
a
contract.
We
need
a
smart
contract,
so
we
could
use
one
that's
already
out
there,
but
since
we're
in
a
workshop,
we're
gonna
actually
create
one,
because
I
think
it'll
give
you
a
really
good
idea
of
how
all
of
this
stuff
works.
So
we're
gonna
create
our
own
smart
contract
code,
our
source
to
use
in
this
nft,
so
we'll
open.
A
That,
and
one
of
the
things
to
keep
in
mind
is
that
the
contract
should
be
pure
functions.
There's
a
lot
of
great
new
features
coming
with
redstone
and
they're,
going
to
call
it
warp
instead
of
smartweave
contracts,
which
is
a
pretty
cool
name,
but
you
can
do
like
internal
rights
and
you
can
use
you
know
other
languages
and
and
different
different
virtual
machines.
A
So
that's
gonna
be
really
cool
to
see
how
that
kind
of
comes
together,
but
for
now
we're
using
javascript
and
kind
of
this
reducer
pattern.
So
the
main
method
that
a
smart
contract
has
is
the
handle
function,
so
we'll
say,
handle
state
and
action,
and
then
I've
got
a
little
boilerplate.
I
put
in
here.
Just
to
you,
know
kind
of
keep
my
functions
kind
of
stand
alone,
so
I
can
easily
write
unit
tests
with
them.
A
A
However,
you
want
this
pattern
works
well
for
me,
but
again,
whatever
works
the
the
end
of
the
day,
it's
just
a
reducer
pattern
and
you
have
an
accumulator
and
a
value
which
is
state
and
action,
and
then
you
have
to
return
either
a
new
state
in
an
object
or
a
result
if
it's
a
read-only
function
or
an
error
right.
So
those
are
what
you
have
to
return.
A
So
what
we're
going
to
do
with
the
balance?
Let's
go
ahead
and
de-structure
some
things
and
then
make
sure
that
everything's
a
string.
So
what
we're
going
to
do
is
destructure
action
in
the
input
and
caller
and
make
sure
input
target
is
set.
If
so,
that's
our
target,
if
not
we'll,
use
the
caller
and
then
we'll
destructure
our
state
into
a
ticker
and
balance
and
we'll
just
make
sure
target,
is
equal
to
string.
A
A
Now
our
next
function
is
our
transfer
function,
so
we'll
transfer
ownership
from
one
owner
to
another
and
that's
you
know,
state
and
action,
and
what
we're
going
to
do
is
go
ahead
and
destructure
the
action
in
the
input
to
get
input
and
color
and
target
and
quantity.
So
with
the
transfer,
it's
a
right
transaction
and
we
need
target
and
quantity
from
our
input
in
order
to
properly
write.
A
A
If
not,
we
want
it
to
exit
and
then
we're
going
to
implement
our
transfer.
So
here's
our
code
to
do
that.
Basically,
we
decrement
the
quantity
from
the
balance
of
the
caller
and
then
we
increment
the
quantity
to
the
balance
of
the
target
and-
and
it's
that
simple
and
now
we
just
need
to
update
our
state.
A
And
return
state
so
that
we
we
get
a
new
state
in
our
contract
and
that
will
essentially
move
the
nfp
from
wallet
one
to
wallet
two.
If,
while
it
wants
the
caller,
they
have
to
be
the
owner
and
they
can
move
the
quantity
from
themselves
to
a
new
wallet
and
now
that
wallet
becomes
the
owner
of
the
nft,
pretty
cool.
A
A
We'll
need
to
bring
in
our
wallet
and
our
source
code,
that's
what
I
was
looking
for.
So
let's
go
ahead
and
load
those
from
the
file
system,
so
we'll
load
our
wallet
and
our
source
code
from
the
file
system
and
we'll
go
ahead
and
get
the
address
of
the
wallet
too,
because
we'll
need
that
as
well
and
then
we're
going
to
create
our
source
code
transaction
on.
Are
we
so
fonts
c
source
equals
away
our
weave,
create
transaction,
and
our
data
will
be
our
source
code
right?
A
A
Setting
data
to
winston
and
now
we
need
to
add
several
tags
and
I'll
go
ahead
and
just
paste
those
in
and
talk
through
them
content
type
is
image
sbg
the
network
koi.
This
is,
you,
know,
kind
of
a
requirement
of
the
koi
version.
Then
action
marketplace
create.
I
think
both
virto
and
koi
network
uses
that
and
then
we
have
app
name,
smartweed
contract
app
version.
A
Where
we're
mapping
to
a
pst,
then
the
balances
with
the
address
which
is
the
owner.
We
give
it
a
one
and
then
content
type
create
it
at
tags.
We'll
leave
that
empty
and
then
is
private
faults.
So
we've
got
all
of
those
things
in
and
we've
added
all
our
tags.
Now
all
that's
left
is
to
sign
and
post
the
nft
and
that
will
complete
our
minting
process
right.
So
we
sign
the
contract
and
we
post
the
contract
to
the
block
weave
and
we
can
print
out
the
contract
id
with
that.
A
A
Now,
let's
try
that
again
sweet
and
we
will
just
pearl
and
do
localhost,
1984,
mint
or
mine
just
to
to
mine
that
now
we've
got
this
contract
id
and
it's
also
an
nft.
So
if
we
go
to
the
url
here
that
we
had
in
ar
local
and
just
do
slash
and
paste
our
transaction
id,
we
get
our
nft,
which
is
pretty
cool
and
we
can
actually.
A
Address
and
tags
name
value:
we
can
take
a
look
at
our
transaction,
so
our
id
and
our
address
and
we
can
see
that
it's
a
smartweave
contract
and
we've
got
our
contract
source
and
we've
got
our
state
stored
here
as
well.
So
pretty
awesome.
So
it's
a
smartweave
contract
and
it
is
a
nft
or
the
the
url,
the
data
asset
of
the
nft,
and
we
can
read
that
right.
So
let's
go
ahead
and
create
a
new
file
called
read
contract
and
let's
work
through
what
we
need
to
do
to
read
the
balance.
A
And
we're
going
to
set
up
this
read
content
with
some
basic
stuff
we
want.
Are
we
we
want
redstone,
smart,
we
and
we're
going
to
use
the
smartweave
node
factory
to
basically
call
our
balance
method
on
our
smart
contract,
so
we're
going
to
initialize
that
using
our
weave
gateway.build,
so
it
will
use
our
localhost
now,
if
you're
using
mainnet.
A
Basically,
you
would
use
the
redstone
gateway
because
it's
much
faster
than
the
r-weave
gateway.
So
it
would
be
something
like
this
to
initialize
that
gateway
on
production
are
on
mainnet.
Now
we're
gonna
grab
our
contract
and
our
contract.
Identifier
is
the
identifier
of
the
smart
contract
that
we
just
ran.
Are
our
atomic
nft
we'll
grab
it
here
and
that's
our
contract.
A
A
A
A
A
And
mine
just
to
make
sure
and
then
let's
do
read
contract.
Yes,
we
have
balance
one
just
a
typo.
That's
why
it's
important
to
test
your
contracts,
because
you
don't
want
to
deploy
that
on
the
main
net
and
it
be
wrong.
So
now,
let's
go
ahead
and
transfer
an
nfg
from
this
wallet
to
another
wallet
so
in
in
order
to
do
that.
A
A
Open
our
local
and
go
that
up
yep
we've
got
our
nft
okay,
so
we've
we've
got
our
contract.
We
need
to
connect
it
to
our
wallet
of
the
owner
of
the
nft.
So
we
need
to
do
that
and
now
we
can
initiate
the
transfer.
So
we'll
call
await
contract
right
interaction
and
we're
going
to
pass
in
our
function,
which
we
want
to
call
which
is
transfer
and
transfer
requires
a
target
which
we
have
above
in
a
quantity
which
we
want
to
be
one,
and
then
we
can
say
console
log
transferred
nft.
A
A
A
A
And
if
everything
is
working
well,
when
we
read
the
contract
of
the
new
wallet,
it
should
be
one
right
and
it
is
so.
We
transfer
the
nft
from
one
wallet
to
another
wallet,
pretty
cool
so
with
that.
That
kind
of
concludes
the
workshop
and
shows
how
to
create
a
smart
contract,
create
a
nft
inside
that
using
that
smart
contract
and
then
using
the
balance
function
to
get
the
balance
of
an
owner
or
wallet
in
the
transfer
function
to
move
it
from
one
wallet
to
another
wallet.
A
Now
this
is
the
very
basic
stuff,
but
I
felt
like
it
was
important
to
work
through
this
work
through
it
at
the
lowest
level
possible.
So
you
can
get
a
full
understanding
and,
as
we
start
to
compose
these
things,
it
will
start
to
make
more
sense.
So,
hopefully
you
enjoyed
this
workshop
and
if
you
have
any
questions,
feel
free
to
hit
me
up
on
discord.