►
Description
In this workshop, we present the open Fluence p2p protocol, network and open source tooling including Aqua, Fluence's peer-to-peer programming language. Moreover, we dive into code to illustrate the use of Fluence and Aqua to create distributed services and compose them into peer-to-peer protocols and applications.
00:00 Intro. Programming Cross and Multichain NFTs With Fluence And Aqua
0:27 Overview
03:57 Fluence In A Nutshell
11:05 Aquamanire. Open Source Technology To Program Distributed Systems
12:44 Foundations: The Particle
15:40 How everything works in Fluence
18:50 Tooling In A Nutshell. Rust SDK
24:28 Fluence Java Script
27:25 Aqua
35:30 Fluence provides growing integration ecosystem. Available Integrations.
35:37 Fluence+ IPFS
37:28 Fluence+ Ceramic
38:57 Additional Building Blocks
42:51 Q&A
51:45 IPFS integration
54:50 Demo interface
1:05:00 Bounties
1:09:19 Additional resources
1:10:35 End of meeting
https://fluence.network/
https://twitter.com/fluence_project
https://github.com/fluencelabs/aqua
https://github.com/fluencelabs/aquavm
https://github.com/fluencelabs/marine/tree/master/examples/greeting
https://fluencenetwork.notion.site/fluencenetwork/Fluence-Developer-Community-Calls-2733beddb3ff4e4986c4fcc830fc796d
https://github.com/fluencelabs/marine-rs-sdk
https://t.me/fluencedev
https://discord.com/invite/5qSnPZKh7u
Speaker Bernhard Borges
Original video https://www.youtube.com/watch?v=GjJ2a9dxo_Y
A
All
right,
so,
where
was
I
all
right?
Well
welcome
everybody
today
we're
gonna
talk
about
entities
and
how
to
program
them
with
fluent
in
aqua,
and
since
this
is
the
shelling,
the
misspelled
hackathon.
For
those
of
you
not
aware,
focal
points
are
not
necessarily
a
big
deal,
but
an
important
part
of
game
theory
and
non-communicative
coordination
is
actually
a
big
deal
and
we
encounter
it
everywhere.
A
So
setting
up
the
the
making
it
a
shelling
themed
hackathon
is
really
really
cool
and
if
you
look
in
the
blockchain
and
web
3
ecosystem,
there
are
a
lot
of
focal
points.
A
lot
of
shelling
points
that,
over
the
past
few
years,
have
sort
of
emerged
and
usually
individually
without
coordination,
different
camps,
different
people,
different
minds,
arrive
at
some
pretty
interesting
solutions,
and
right
now
in
the
nfc
speed
space.
A
Some
of
those
emerging
shelling
points
or
focal
points
are
literally
cross
and
multi-chain
nfts
by
cross
chain.
We
are
looking
at
nfts
that
are
bridged
between
chains
and
by
multi-chains.
We're
looking
where
we
use
front
ends
centralized
to
decentralize
to
manage
nfts
across
multiple
chains,
who's
going
to
win
who's
going
to
lose
hard
to
say
I
don't
know
if
there's
going
to
be
a
vhs
or
betamax
or
maybe
both
fulcrums
will
will
survive
and
grow
and
prosper
we'll
see.
A
But
right
now
these
are
emerging
shelling
points
in
the
ecosystem
and
also
very
very
relevant,
and
our
bounties
are
built
around
nfts
I'll
go
through
them
at
the
end,
but
basically
everything
everything
in
the
workshop
I'm
trying
to
do
is
trying
to
basically
enable
you
to
be
successful
as
much
as
possible
and
and
and
succeed.
And
yes,
if
you're
a
beginner
stick
around
either
find
a
team
or
or
you
know,
get
inspired
sufficiently
to
dig
in
okay.
A
So
decentralization
is
a
really
big
deal.
I
think,
if
you're
coming
from
web
3,
it's
really
important,
and
particularly
the
web
3
aspect
of
how
to
look
at
decentralization
is
really
important.
It's
important
because
this
is
where
you
can
start
fighting
certain
things
like
like
loss
of
control
over
your
data
and
and
many
other
privacy
invasions,
and
and
that's
where
peer-to-peer
platforms
comes
in.
You
can
do
decentralization
in
many
different
ways.
However,
only
with
peer-to-peer
networks,
you
really
get
the
full
benefits
of
the
attributes
of
web3,
including
censorship.
A
A
Okay,
the
the
drawing
is,
is
throwing
me
off
there
for
a
second
that
allows
you
to
to
build
decentralized
protocols
and
applications,
and
the
fluence
stack
itself.
The
protocol
itself
is
all
about
compute
decentralized,
peer-to-peer
enable
compute,
and
so
as
a
developer,
you
have
to
bring
alternative
data
solutions
to
the
place,
including
which
should
be
decentralized
such
as
ipfs
and.
A
If
you
look
at
it
from
from
a
sort
of
bird's-eye
view
perspective
peer-to-peer
networks
which
are
on
the
right,
this
sort
of
a
very
small
one,
you
basically
have
clients,
and
then
you
have
peers
that
communicate
with
each
other.
Those
are
your
peers
in
the
network
and
the
relay
just
to
make
sure
everybody's
on
the
same
page.
A
A
relay
is
a
pier
that
sits
in
front
of
otherwise
non-accessible
peers,
which
could
be
behind
a
nat
which
could
be
behind
a
firewall
which
could
be
behind
or
could
be
preemptively
prevent
you
from
connecting
directly
through
various
censorship
interventions
and
on
it
goes
so.
The
big
deal
about
peer-to-peer
on
the
fluent
side
is
that
it's
a
general
purpose,
peer-to-peer
network
and
and
protocol
for
those
of
you
that
have
been
in
the
web.
3
space
you've
probably
been
either
directly
indirectly.
A
Oops
encountering
peer-to-peer
networks
as
part
of
blockchain
blockchain
is
probably
the
biggest
rejuvenation
of
evolution
of
peer-to-peer
technology
and
in
blockchains
ethereum,
for
example.
Peer-To-Peer
is
used
to
communicate
to
to
find
other
nodes
and
then
to
sync
data
across
nodes,
and
that's
where
the
decentralization
comes
in
through
peer-to-peer
on
most
of
the
blockchains
ipfs.
A
The
old
big
p2p
applications
usually
are
the
napster,
so
it
was
always
about
data
and
one
of
the
things
where
fluence
is
different.
Is
it
gives
you
compute?
So
if
you
really
really
need
an
analogy
from
the
web
to
space
or
from
from
an
alternative
space,
is
you
can
think
of
it
of
decentralized,
serverless,
so
decentralized
lambda
at
the
at
the
roughly
at
the
highest
level?
That's
what
decentralized
compute
gives
you.
A
Now
we
understand
that
not
everything
is
going
to
be
on
our
on
the
fluence
network,
which,
actually,
by
the
way,
is
open,
permissionless
and
all
the
tools
are
open
source,
apache,
2
or
mit.
So
it's
very
permissive
and
what
you
can
do
is
you
can
actually
take
those
services
and
write
adapters
for
already
existing
solutions
like
apis,
microservices
or
other
peer-to-peer
plays
like
ipfs.
A
A
A
So
that,
of
course,
is
it
sounds
very
easy.
It
actually
is
not,
but
a
lot
of
the
work
is
taking.
Care
is
black
box
for
you,
so
you
don't
really
have
to
dig
very,
very
deep.
The
big
deal
or
the
big
big
question
should
be
at
this
point,
is
how
do
you
actually
get
to
that
service?
I
mean
I'm
here
in
my
browser.
A
A
So
a
peer
id
is
actually
just
the
hash
of
the
public
key
of
the
node
operator,
so
the
peer
id
is
actually
not
related
to
the
ip
address,
which
has
a
lot
of
advantages
but
also
disadvantages.
There
are
security
risks
because
of
that,
and
we
have
a
lot
of
the
well,
not
a
lot
all
of
the
security
requirements
to
stave
off
the
majority.
Actually,
most
majority
of
all
the
possible
civil
eclipse,
blah
blah
blah
attacks.
A
You
could
possibly
get
because
one
thing
you
can
do
is
if
you,
if,
if
the
addressability
is
on
the
peer
id,
not
the
ip
address
on
a
single
ip
address,
you
could
quote
unquote
run.
You
know
a
very
large
number
of
phantom
peers
and
those
those
could
be
attacks,
but
there
are
ways
to
mitigate
those
attacks
and
they
are
in
place.
A
A
As
I
said,
you
address
them
by
peer
id
and
services,
have
a
unique
id
and
you
use
aqua
aqua
is
a
program
language
and
development
stack
developed
by
fluence,
and
it's
a
fully
dedicated
purpose-built,
peer-to-peer,
programming
language,
and
it's
super
simple
and
we'll
go
through
all
of
this,
because
that's
what
you
really
need
to
do.
That's
really
what
you
need
to
see
in
order
to
be
successful
in
your
hackathon
endeavors,
and
so
let's
just
go
forward.
So
we
have
two
big
stacks
that
are
part
of
every
node.
A
A
Aqua
is
the
programming,
language
and
part
of
and
and
the
compiler,
and
it
also
includes
a
virtual
machine.
It's
called
the
avm,
the
acro
virtual
machines
and
that
actually
executes
the
compiled
aqua
scripts
and
they're
available
on
every
peer,
and
we
go
through
exactly
how
this
works
in
a
split
second.
So
basically,
what
that
enables
you
to
do
is
that
enables
you
to
separate
your
business
logic,
your
services
from
the
actual
topology
required
to
discover
services
through
the
network.
A
That's
where
aqua
comes
in
and
that's
what
actually
enables
peer-to-peer
applications
on
top
of
it
if
you're
into
zero
trust,
type
frameworks
and
environments,
it's
it's
inherent
in
the
way
the
system
is
built
because
hang
on
where's
my
bro
here.
It
is
because
at
every
entry
ingress
in
egress
there
are
signatures
collected
and
that
allow
you
to
actually
validate
exactly
what
has
happened
on
every
state
change,
and
so
this
actually
fully
enables
the
serial
trust
architecture,
and
then
it
allows
you
to
actually
collaborate
and
compose
over
peer-to-peer
networks.
A
variety
of
protocols
and
applications.
A
A
Then
we
said
we
wanted
to
turn
it
into
emojis
and
we're
do
another
discovery
for
that
emoji
service
and
you
get
another
state
change
and
then
it
goes
back
here.
So
basically,
if
you
look
at
it
in
traditional
client
servers,
what
you
would
do
is
you
would
go
from
the
client
to
the
service
back
to
the
client,
to
the
service
back
to
the
client
and
then
to
the
recipient.
A
That's
not
what's
happening
at
all
and
what
we're
doing
basically,
is
we're
pushing
a
data
model
or
a
smart
package.
We
call
it
a
particle
and
particles
are
conflict-free
replication
data
structures
that
combine
data.
So
your
message,
for
example,
to
the
anticipated
recipient,
as
well
as
the
recipient
address
and
the
execution
sequence.
That
is
your
compiled
accuracy.
So
this
is
part
this
compile.
You
can
think
of
it
as
buy
code,
it's
not
by
code.
It's
it's!
Actually
a
list
like
output.
A
A
Is
you
create
some
transaction
contraction
gets
processed
through
the
miner
it
gets
put
into
the
block
and
then
every
node
in
the
blockchain
system,
reruns
those
transactions
and,
if
they're
validated
by
each
and
every
one
you
get
the
longest
chain
and
the
longest
chain
wins,
and
this
is
how
blockchains
work
in
fluence,
you
don't
rerun,
so
the
downside
of
blockchain
is
the
way
it
works.
If
you
add
additional
nodes
to
the
network,
you
do
not
essentially
add
scalability.
A
A
However,
as
you
execute
your
workflow,
you
end
up
with
with
a
log.
If
you
will,
that
actually
contains
a
whole
bunch
of
signed
messages
which
actually
make
up
a
proof,
so
you
can
rerun
if
you
want
to
the
execution
of
that
workflow
through
the
various
stages
of
the
particle
processing,
where
each
state
stage
is,
of
course,
the
state
change
and
verify
that,
and
so
what
basically
happens?
A
A
So
before
we
go
to
aqua,
I
want
to
sort
of
quickly
go
through
the
tooling.
In
a
nutshell,
so
we
have
a
rust
sdk.
The
web
assembly
modules
you're
building
in
order
to
create
services
are
coded
in
rust.
So
before
you
just
throw
up
your
hands
and
say
I
don't
want
to
ever
touch
it.
It's
the
easy
parts
of
rust.
If
you
know
javascript,
if
you
know
python
whatever,
you
should
have
no
problem,
because
all
the
difficult
stuff
that
comes
with
rust,
lifetimes
generics
blah
blah
blah.
None
of
that
applies
so
literally.
A
The
first
four
chapters
in
in
the
rest
book
is
all
you
need,
because
in
webassembly
everything's
passed
by
value,
and
so
basically
what
you're
doing
is
you
write
these
services
in
rust
and
compile
them
into
webassembly
modules?
And
then
you
link
these
webassembly
modules
into
services,
so
services
actually
are
virtual
constructs
based
on
actual
webassembly
modules.
A
So
if,
for
example,
you
have
you
want
to
have
a
service
that
calls
out
and
does
some
http
calls
requests,
I
don't
know
like,
for
example,
some
of
the
directly
interacting
with
an
ethereum
node,
for
example,
or
or
an
evm
whatever
it
is
using
our
json
rpc,
then
you
would
have
two
web
assembly
modules.
One
is
the
actual
adapter
to
curl
and
I'll
get
to
this
in
a
minute,
dear
http,
adapter,
and
then
one
would
be
the
business
logic.
A
And
then
you
have
a
json
file
that
links
those
two
modules
into
a
service.
So
basically,
the
modularity
of
the
service
construct
is
so
as
such
that
you
actually
can
reuse
and
repurpose
those
modules,
depending
on
the
granularity
you've
used
to
create
these
services
very
very
efficiently
and
effectively
into
many
different
configurations.
A
Why
curl
so
web
assembly?
It
is
extremely
safe.
It's
extremely
secure,
and
a
lot
of
it
has
to
do.
Is
that
it's
fundamentally
sandboxed,
which
means
that
those
webassembly
modules
natively
have
no
access
to
host
resources
and
that's
where
the
security
model
comes
in.
So
what
we've
done
is
we
sort
of
quote
unquote?
A
A
So
in
order
to
be
able
to
to
particular
on
the
socket
side
in
order
to
be
able
to
actually
interact
with
the
outside
world,
you
somehow
need
to
be
able
to
do
that,
and
one
way
to
do
that
is
to,
for
example,
access
http
request
resources
provided
by
the
host
the
node.
The
peer
and
curl
is
one
of
those
resources.
A
So
basically
you
can
do
kodak
with
a
binary
mount
and
to
the
web
assembly
modules
and
then
take
advantage
of
what
the
host
is
providing
and,
as
I
said,
that's
permission
based
and-
and
this
is
how
you
create
so
so,
basically
different
modules.
Web
assembly
modules
can
be
configured
into
different
services.
A
There
is
basically
a
every
every
configuration
of
webassembly
modules
into
a
service
is
reflected
by
a
knee
cache.
It's
called
a
blueprint
id
and
then
you
can
associate
unique
service
ids
to
those
blueprint,
ids
and
the
reason
you
do
this
is
because
actually
in
acquire,
you
can
parallelize
your
workflow
or
parts
of
your
workflow.
So
if
you
wanted
to
run,
for
example,
service
instantiations,
multiple
service
instantiation
on
the
same
node,
you
would
use
the
same
blueprint
and
the
resources,
but
the
instantiation
would
come
through
different
service
ids.
A
You
actually
cannot
because
it's
about
addressability
now,
not
just
the
reuse
of
the
resource,
or
you
could
obviously
do
this
across
different
peers.
So
then,
depending
on
you
know
how
the
hosts
are
configured
in
terms
of
cpu
ram,
blah
blah
blah.
You
can
also
parallelize
across
the
network,
which
is
actually
really
really
powerful.
A
In
addition,
what
the
rust
sdk
provides
you
with
is
some
really
really
good
testing.
Why
is
that
important?
Fundamentally,
if
you
do
unit
integration
tests,
you
do
it
on
your
code
right.
You
write
your
ros
code
or
whatever,
and
and
then
you
run
the
unit
tests
on
the
code
and
that's
nice,
but
our
our
compelled
target
is
actually
wazi
32
wasm,
which
is
a
little
bit
different,
and
in
order
to
do
unit
tests,
you
actually
want
to
run
those
tests.
A
A
A
A
Interfaces
javascript
interfaces
into
aqua,
consumable
interfaces,
so
basically
you
get
the
same
benefit.
Well,
not
the
same
benefit,
but
you
get
the
same
programming
model
and
an
execution
model
with
aqua,
regardless
of
it
being
a
awesome
service
or
actually
a
javascript
type
node.
Actually,
it's
typescript
node,
and
we
do
this
by
making
an
aqua
virtual
machine
available,
and
so
this
runs
in
a
browser
right.
It
could
run
be
an
edge
client,
but
it
runs
in
the
browser.
A
The
part
that's
missing,
is
you
can't
run
those
webassembly
it
modules
in
the
browser
just
yet,
however,
we're
working
on
marine
runtime
called
web
marine.
That's
going
to
be
available,
hopefully
soon.
I
don't
know
two
months.
Maybe,
and
then
you
have
a
full-fledged
javascript,
typescript
environment
that
lets.
A
You
actually
run
rust
type
services,
webassembly
services
in
the
browser
which
I'm
not
bi-engine,
wasn't
but
was
in
mit,
which
is
super
super
cool
because
it
actually
runs
on
on
the
rust
nodes
as
well
and
wherever
you
port,
the
marine
runtime
too-
and
that
actually
is
is
it's
I
don't
know
you
have
to
dig
in
a
little
bit.
You
have
to
use
it.
It's
it's
unbelievable
cool
and
it
gives
you
a
lot
of
options
and
it
really
really
helps
you
in
the
reuse
of
your
resources
and
by
reuse.
A
If
you,
if
you
really
think
about
sort
of
the
different
types
of
of
actors
you
have
in
in
this
ecosystem,
you
could
have
one
actor.
That's
just
focusing
on
operating
nodes,
rust
nodes.
You
know,
peers
pierce,
you
could
have
an
actor
or
actors
that
focus
on
on
creating
services
which
are
then
hosted
by
those
other
type
of
actors,
and
then
you
could
have
actors
that
build
protocols
and
applications
by
reusing
the
already
hosted
services.
A
Aqua
is
a
high
level
language,
and
that
really
is
aqua
is
what
makes
everything
come
together
work,
and
this
is
really
for
the
most
part,
particularly
from
a
protocol
and
application
development
perspective,
the
entry
point
into
the
entire
system,
and
so
it's
a
high-level
language.
It's
a
compiler
that
takes
the
high-level
language
and
turns
it
into
an
immediate
representation,
and
it
has
a
command
line
interfaces
which
actually
gives
you,
as
part
of
the
library,
a
very
small,
thin
client.
A
Oh
now
aqua
been
talking
about
it.
Talking
about
it,
talk
about
it.
It's
time
we
put
the
robert
in
the
road
here
and
go
from
the
academic
to
the
practical
at
the
bottom.
We
have
an
aqua
excerpt
so
assume
we
have
a
web
assembly
service,
a
greeting
service,
that's
out
there
somewhere
on
the
network
and
it's
a
fancy
greeting
service.
It
takes
over
two
parameters:
a
string
and
a
boolean,
and
basically
the
boolean
determines
whether
we
greet
or
say
goodbye
as
that
service,
and
the
string
is
just
basically
the
addressability
of
the
greeting.
A
So
if
the
string
is
bitcoin
and
the
boolean
is
true,
our
our
response
would
be
high
bitcoin
and
if
our
boolean
is
false,
it
would
be
buy
bitcoin
right.
So
it's
just
basically
a
real
fancy,
hello
world.
We
have
the
servers
out
there,
it's
running
on
some
node
on
some
peer
and
it
has
a
service
id
which
we
see
here.
So
this
line
one
and
two
is
your
binding.
A
If
you're
coming
from
from
blockchain,
for
example,
you
can
think
of
it
as
a
api
right-
and
I
mean
you-
don't
have
to
come
for
blockchain,
but
if
you're
a
solidity,
you're
really
really
familiar
with
with
this
kind
of
structure
and
then
lines
four
onward.
This
is
actually
your
aqua
function,
so
you
get
your
function,
signature
on
top
and
it
basically
it's
grading
the
function
name,
and
then
we
have
our
parameters.
So
we
have
the
name
and
the
grid
which
actually
corresponds
to
this.
A
To
that
interface
right
and
now
we
have
the
remaining
two
parameters:
the
node,
which
is
the
peer
id.
It's
a
string
and
the
unique
service
id
which
is
a
string
which
is
our
in
this
particular
case,
our
all
we
need
for
our
addressability
and
then
that
function
returns,
another
string,
hello,
bitcoin
or
a
highgate
kind
of
buy
bitcoin
right
good
coin.
A
A
It
basically
says
on
this
pier
where
we
have
the
address
the
pid.
Here
we
instantiate
our
binding
to
the
provided
service
id
okay.
So
now
we
have
an
instantiated
service
on
whatever
peer
we
specified
here,
that's
it.
This
is
ready
to
go,
and
now
we
execute
for
this
binding.
This
particular
function
called
greeting
and
we
provide
it
with
the
name
and
the
grid
parameters,
and
we
collect
that
into
a
result.
That's
it
so
what
you're
basically
doing
is
you
have
a
client?
A
So
if
you
go
in
the
upper
right,
you
have
this
client
and
it
could
be
a
javascript
client.
It
could
be
your
cli,
it
could
be
whatever
and
you're
flinging
this
particle
now.
The
particle
simply
stating
is
that
compiled
piece
here,
those
those
eight
lines,
plus
your
your
data
parameters
right,
your
name,
the
type
of
boolean,
the
node,
address
the
property
and
the
service
id.
A
So
we
put
all
this
together
and
we
fling
this
out
to
this
relay
node.
Let's
just
say
we
have
a
thin
client,
so
we
need
a
relay
to
actually
get
onto
the
network
and
that's
how
we
initiate
our
request.
This
is
this
is
this
is
our
request
and
then
the
system
takes
care
of
you.
The
discovery
inherent
in
the
peer-to-peer
network
basically
gets
you
to
whatever
node
hosts
that
service
we
talked
about,
which
is
this
node
with
this
service?
I,
but
the
service
has
this
service
id
and
we
call
this
so.
A
The
acqua
vm
now
finds
executes
through
this
compiled
part.
It
knows
we
need
to
go
here.
It
finds
the
service
and
basically
make
sure
that
service
is
executed
on
the
marine
virtual
machine,
and
then
we
get
the
result
back
and
the
result
here
going
back
is
actually
still
on
this
node.
This
part
here
is
on
this
node,
so
we're
over
here
with
the
result.
A
A
So
if
you
were
around
were
to
run
a
node
on
your
home
system.
Let's
just
say
you
have
enough,
or
you
know,
an
edge
device
and
you
have
a
cycling
ip
address,
it's
it's
a
non-issue
without
ever
having
to
go
through
a
central,
dns
or
decentralized
dns
for
that
matter.
It's
it's
part
of
the
the
network
topology
fabric,
how
this
discovery
works,
and
this
actually
is
super
super
powerful.
Let
me
see
what
we
have
here.
A
I
know
I'm
going
fast,
but
I
always
run
out
of
time
so,
okay,
well,
if
you
have
any
put
in
jab,
let's
just
speak
up
so
this
is
this
is
in
a
nutshell.
This
is
aqua
and,
as
you
can
see,
if
this
is,
if,
if
you
ever
wanted
to
write
a
peer-to-peer
application
on
your
own,
what
you
would
have
to
do
is
you
have
to
go,
take
lit
p2p,
which
is
a
huge
improvement
over
what
you
had
a
few
years
ago.
A
A
It
has
all
the
key
management.
All
this
stuff
is
taken
care
of
where
you
already
so
you
really
can't
just
go
and
start
build
protocols
and
applications
and
and
aqua
really
abstracts.
You
don't
have
to
deal
with
any
of
those
low-end
metal
type
programming
chores
which
are
so
far
from
where
you
usually
want
to
be
when
you,
when
you
implement
or
want
to
implement
the
protocol
or
an
application.
A
Okay,
so
far,
so
good,
all
right,
so
in
order
to
make
things
even
easier,
fluence
provides
a
growing
integration
ecosystem
and
one
of
the
big
integrations
or
one
of
the
first
ones,
which
we
really
really
like
is
ipfs.
So
how
do
you?
How
do
you
do
this
in
and
actually
I'll
go
through
the
code
with
you
in
a
little
bit?
So
I'm
going
to
go
a
little
fast,
fluence
ips,
because
we're
going
to
spend
like
probably
20
minutes
on
it,
but
basically
what
we're
doing
is
so
we
have
this
this.
A
This
network
of
this
pure
pin
network
of
fluence
nodes-
and
I
say,
fluence
nodes,
because
right
now
the
reference
implementation
is
the
only
one
and
that's
fluence.
You
can
take
it.
You
can
fork
it.
You
can
make
it
john
or
brian's,
or
cans,
peer-to-peer,
node
and
that's
cool
as
long
as
it
as
long
as
the
the
interfaces
and
the
the
node
itself
still
adheres
to
the
protocol
and
the
specifications.
A
So
as
far
as
you
as
a
as
a
protocol
and
application
developer
are
concerned,
there
is
no
difference
from
a
programming
model
between
compute
and
data,
and
that
actually
is
really
really
cool,
and
I
at
least
I
think
so
and
we'll
get
into
that.
As
I
said
like
at
the
code
level
in
in
a
little
bit,
we
do
the
same
with
ceramic
ceramics
is
a
little
bit
different
because
it
sits
on
top
of
ipfs.
So
you
need
multiple
ways
to
to
access
ceramic.
A
You
can
do
part
of
it
is
through
the
http
api
part
of
its
cli
api.
The
interesting
part
with
the
fluence
integration
is
that
it's
actually
happening
at
the
file
system
level.
So
what
we've
done
is
we've
said.
I
told
you
earlier
that,
with
the
right
permissions
service
modules,
wise
and
modules
actually
can
go
beyond
the
sandbox
and
utilize
permissioned
host
resources,
which
includes
the
file
system.
So
we
created
a
a
file
vault.
If
you
will
well
actually
that's
what
it's
called
the
file.
A
We
have
a
bunch
of
additional
building
blocks,
so
we
have
a
bunch
of
fluent
examples.
So
it's
if
you
go
to
a
github
dot
com
forward,
slash
fluence
labs
forward,
slash
examples:
there's
a
ton
of
examples
for
aqua
for
marine
for
everything.
However,
over
the
past
year
or
so,
we've
had
multiple
hackathons
several
with
bitcoin,
which
I
thought
went
really
well,
and
the
community
has
really
done
some
really
really
cool
things.
So
just
so,
there's
one
that
that
was
working
on
nfts
there
has
contracts
whatever.
A
A
If
you
want
to
do
dynamic,
nfts
with
dynamic
data
or
dynamic,
dynamic
nfts,
with
data
on
say,
for
example,
ceramic
on
a
decentralized
solution,
so
that
basically
governs
what
resources
actually
have
access
to
the
data
representation
of
the
nfv,
so
you
can
update
it
and
just
since
a
few
people
seem
to
be
newer
than
others,
some
of
the
cool
things
of
dynamic
nfts
is,
for
example,
if
you
have
a,
I
don't
know
if
you're
into
sports.
But
if
you
have,
I
don't
know
a
baseball
player
card.
A
If
you
will
as
an
nft,
you
could
keep
updating
that
player's
statistics.
So
if
she
hits,
I
don't
know,
as
as
the
player
evolves,
the
the
metadata
walls
with
the
nft
without
ever
having
to
remind
the
nft-
and
that's
obviously
like
huge.
This
is
like
a
super
super
cool
use
case
to
to
really
make
nfts
super
valuable
beyond
the
art
straight
art,
but
even
living
art
actually
uses
dynamic
nfd.
A
A
A
Signing
services
off
chainsaw
chain
signing
services
in
order
to
guard
your
key
properly
is
your
private
key
properly.
You
need
to
run
your
own
node.
You
don't
want
to
run
your
own
node
for
everything,
but
this
is
where
fluence
gs
node
comes
in.
It
could
be
super
handy
and
and
where
you
really
just
use
it
for
signing
services.
So
if
that
node
goes
offline,
you're,
not
particularly
worried
about
it,
unless,
of
course,
you
want
to
sign
something
not
interactively,
of
course.
A
A
A
A
I
know
a
temporal
virtual
private
network
right
because
your
services
are
addressable
and
the
lifetime.
The
span
of
this
this
this
aqua.
It
sort
of
it,
creates
this
this
this
virtual
coverage
of
the
network,
the
sub
network,
it's
not
really
a
sub
network,
but
for
you,
as
a
as
a
aqua,
programmer
and
and
owner,
it
looks
like
a
sub
network,
so
ordering
messages
doesn't
really
matter.
A
So
unless
you
go
into
parallel
right,
so
everything
is
sequential
until
you
hit
apparel
fork
in
the
parallelization
ordering
isn't
happening
per
se,
whatever
finishes
first,
whatever
sequence
you
get
the
returns.
This
is
how
it
gets
and
then
the
state
gets
updated.
So
the
state,
regardless
of
how
the
messages
come
in
or
the
compute
comes
in,
is
going
it
doesn't
matter.
A
So
it's
up
to
you
to
design
a
workflow
where
this
is
acceptable,
and
this
is
where,
when
we
looked
at
particles,
it's
it's
where
those
conflict-free
replication
data
structures
come
in
because
you
have
this
eventual
consistency
and
the
eventual
consistency
is
not
the
eventually
over
the
run
of
your
aqueous
script.
The
lifetime
of
your
logic,
it's
actually
over
over
your
service
branch
or
your
fork
like
parallelization,
does
that
make
it
clearer.
A
A
So
if
with
rust,
you
literally
write
web
assembly
modules
with
fluence.js,
you
write
javascript,
as
you
would
async,
for
example,
as
you
would
always,
and
then
you
are
able
to
expose
those
javascript
or
typescript
interfaces
as
if
they
were
web
assembly
modules,
but
they're
not
and
from
an
echo
perspective
it
doesn't
really
matter.
The
important
part
is
that
you
have
a.
A
B
B
A
Apologize,
what
matters
is
that
web
assembly
modules
are
easily
portable.
You
can
run
them
just
about
in
any
environment,
whereas
fluence
gs,
it's
it's.
Fundamentally,
it's
a
node
structure.
It's
it's!
It's!
It's
a
much
less
fine-grained
approach
to
to
resource
capabilities
than
what
you
have
with
webassembly.
A
And,
as
I
said
like
as
so
so
in
many
respects,
if
you
use
fluence.js-
and
you
expose-
I
don't
know
five
or
six
interfaces
to
be
used
by
aqua
in
conjunction
with
with
any
other
webassembly
services
or
not
it's
it's
really.
It
doesn't
really
matter.
Aqua
doesn't
act
by
itself,
doesn't
distinguish
as
long
as
there's
an
aquarium
available
and
the
interfaces
are
processable.
A
You,
your
fluence
js
node.
If
you
will
your
client
is
your
sort
of
mega
service
right,
you
can't
you
can't
slice
it
dice
it
and
partially
partially
host
it
somewhere
else,
whereas
webassembly
you
can
so
the
level
of
granularity
is
at
the
webassembly
module
so
when
to
do
one
or
the
other.
If
you
want
to
have
optimal,
reuse
and
granularity,
particularly
fine-grained
function
level,
development
is
important
to
you
think
lambda,
for
example.
A
A
On
the
network
level
and
on
the
transaction
level,
everything
is
encrypted
end-to-end,
but
what's
the
end,
the
end
is
the
peer,
not
the
service
right.
So
as
the
decryption
is
happening,
it's
happening
at
the
peer
level.
So
there's
this
level
of
exposure
between
the
peer
and
and
the
web
assembly
module
that
can
be
problematic.
So
if
you
have
a
huge
security
concerns,
just
like
with
anything
else,
you
don't
send
your
keys
right,
don't
send
you
decryption
keys.
A
A
How
fine-grained
you
can
get
and
if
you
look
at
the
code,
real
quick,
so
this
this
here
this
markup
here
this
macro
is,
is
basically
it's
from
fluence,
it's
the
marine
markup,
that's
the
marine
macro
and
it
does
a
few
things.
It
checks
for
types
and
it
makes
sure
that
whatever
is
marked
up
and
properly
is
actually
exposed
to
the
webassembly
module
interfaces
and
if
you
look
at
it,
so
basically
this
is
in
in
javascript.
This
is
a
structure
in
javascript.
It
would
be
an
interface.
A
This
is
how
you
do
your
files,
so
there's
a
little
bit
of
rust
sugar
in
there
in
terms
of
doing
a
match
statement
instead
of
just
doing
a
if,
if
else,
if
then
else,
but
if
else
then,
but
fundamentally,
if
you've
done
any
javascript
or
some
python
whatever
go,
you
look
at
it.
It's
like
oh
yeah,
yeah.
I
get
it.
I
get
it.
A
I
already
compiled
it
and
when
you
compile
it,
it
basically
creates
this
webassembly
module
and
I
told
we
have
a
repl
and
if
we
look
into
this
replica
and
we
look
at
the
interfaces,
we
get
exactly
the
webassembly
module
public
interfaces.
We
specified
here
right,
our
size
result
our
write
result
and
then
those
are
our
function,
write
the
calculate
the
file
size
and
write
the
file,
and
you
can
interact
with
that.
Well,
we'll
skip
over
that,
but
so
we
have
this
module.
A
So,
let's
just
see
okay,
so
we
built
a
little
interface,
a
demo
interface
for
us
to
look
at
and
basically
what
it
lets
us
do.
Is
it
lets
us
pick
a
fluence,
ipfs,
combo
and
just
any
relay.
I
just
gotta
pick
this
one
and
we're
connecting
this
so
we're
now.
This
browser
now
is
the
client
that
client
is
connected
to
this
particular
peer
in
the
network.
A
A
So
what
we
want
to
do
in
order
to
deploy
that
webassembly
module
as
a
service
to
one
any
one
node
out
there
or
any
node
or
all
the
nodes,
whichever
ones
you
want
to
do,
we
want
to
first
save
it
onto
ipfs
and
the
way
we
do
it
now,
I'm
lazy
I'm
using
the
the
ipfs
desktop
client
for
for
the
mac,
and
we
take
this
ipad
this
this.
This
multi
address
for
the
ipfs
node,
and
here
we
have
it
it's
it's
up
and
running.
A
So
now
I
have
the
clean
slate
ipfs
client
and
what
I
want
to
do
is
of
course
I
want
to
move
or
copy
that
webassembly
module
onto
ipfs,
and
this
is
why
I
said
I'm
lazy.
I
just
drag
it
rather
than
use
the
as
the
ipfs
cli
to
put
it
on
there,
and
so
now
we
have
this
this
this
file
on
there,
and
this
is
the
cid.
This
is
the
content
addressable
id
this
we
use
on
on
ipfs
right
because
that's
how
ipfs
gets
its
it
censorship,
resistance,
failover,
many
other
things.
A
As
it's
not
location,
addressable
either
it's
it's
content
addressable!
So
now
we
go
back
to
our
handy.
Little
react,
client
browser
and
we
update
the
cid,
which
is
for
the
process
file,
and
now
we
deploy
the
service.
So
this
is
all
happening
on
the
back.
So
now,
basically,
let
me
just
go
through
the
whole
thing,
so
we
get
it
so
now
we
have
a
service
out
there
that
can
calculate
file
sizes
right.
A
A
A
From
before
all
we
have
to
somehow
get
the
file
path
to
it,
and
we
do
that
by
deploying
it
to
the
network
so
boom.
Let's
calculate
the
size,
and
here
it
is
431
bytes,
which
is
yes.
It
checks
out
so
where's
all
this
magic.
Here's,
the
magic
I'll
show
you
the
magic,
it's
not
magic.
The
magic
is
actually
aqua.
A
A
We
want
the
cid
of
the
the
file
which
we
did
when
we,
when
we
put
it
on
the
ipvs
node,
we
got
the
the
content
id.
We
need
the
ipv6
multi
address,
which
remember
we
got
it
when
we,
because
we
know
that
it's
a
sidecar
node
to
the
fluence
nodes.
It's
very
simple.
We
provide
that
and
then
this
is
a
callback
function.
We
call
it
an
error,
but
it's
a
callback
function.
A
A
We
want
to
execute
an
ipfs
get
call,
and
if
that
call-
and
for
that
we
all
we
need,
is
the
multi
address
and
the
content
identifier,
and
if
that
process
is
successful,
we
now
calculate
all
these
hashes
to
get
the
blueprint
and
to
get
the
service
id
and
add
blueprint
and
is
up
here-
and
I
told
you
before
that
we
wrote
a
lot
of
those
services
already
and
let
me
go
here
so
you
get
in
the
echo
book
on
the
libraries.
It
shows
you,
the
api.
A
A
So,
basically,
you
know
orchestrating
or
composing
with
aqua
across
two
different
networks,
peer-to-peer
networks,
as
it
happens,
to
be,
and
using
this
very,
very
simple,
but
extremely
powerful
abstraction
on
top
of
the
p2p.
Fundamentally,
because
now
you're
actually
mingling
function,
addressability
with
content,
addressability
and
neither
one
is,
is
location
based.
Neither
one
uses
ip,
which
is
the
real,
which
is
the
key
the
key
to
all
of
to
most
of
the
web
3
benefits.
A
Obviously
I'm
really
into
it,
as
you
can
tell
so
I
get
excited
about
it.
If
our
result
is
a
failure,
we
have
a
co
routine
that
initiates
that
callback
to
the
client
and
basically
it
failed
our
service
id,
it's
basically
an
empty
string
which
we
have
here.
This
is
why
it
was
optional
and
in
the
client
you
obviously
have
to
catch
the
error
and
off
you
go
once
we
have
all
that
in
place.
We
deployed
it.
I
showed
you
how
to.
A
Where
was
it
oh
yeah
how
to
basically
now
we
just
can
put
in
different
file
cids,
and
we
just
keep
calculating
the
result,
and
this
is
what
we're
doing
here
and
basically
this
up
all
this
part
again,
it's
just
a
function.
Signature
just
like
before
you
need
your
cid,
all
the
address
service
id
again.
We
have
some
callbacks
here
and
you
know
the
id,
which
is
the
relay
and
then
again
very
simple
on
this
relay
pick
up
the
content.
A
If
we
get
the
content
successfully,
we
now
call
our
service,
and
this
is
remember
when
I
showed
you
the
first
little
example
about
the
greeting,
where
we
had
the
service
binding.
Well
here
we're
doing
it
right
up
front,
and
this
is
the
binding
we're
binding
we're
binding
the
service,
which
is,
I
think
here
right
here.
A
This
was
the
the
interface
with
those
two
functions,
but
if
you
look
at
the
repl
is
quite
there
and
we
bind
them
to
that
service
id
which
we
got
from
here.
So
this
is
the
instantiation
and
then
we
just
go
through
it
like
before
and
again
it's
literally.
If
you
take
the
all
the
the
markup
the
comments
out,
it's
it's
10
lines
and
you
or
you
you
compose
a
fully
distributed
peer-to-peer
hosted
service
across
two
peer-to-peer
networks,
the
fluence
network
and
ipfs.
A
It
could
not
be
any
simpler
and
obviously
the
more
complex
it
works
still
gets
more
complex.
It
gets,
but
still
the
addressability
issue
that
usually
haunts
peer-to-peer
developers
is
totally
abstracted
for
you
and
taken
care
of
by
by
aqua
and
then
our
last
one
is
actually
how
room
with
service,
because
you
want
to
be
a
good
good
citizen
and
not
over
not
leave
a
bunch
of
garbage
on
those
nodes,
so
you
just
delete
it
and
in
order
to
delete
it,
you
use
another
built-in
service.
A
A
We
want
you
to
if
you
going
for
the
advanced
bounty,
we
want
you
to
go
for
the
beginners
bounty.
We
want
you
to
go
for
the
intermediate
bounty
and
we
want
you
to
keep
building
on
it
and
if
you,
if
your
submissions
are
good
enough,
we
are
happy.
We
are
excited.
We
are
thrilled
to
pay
you
out
for
each
one
of
those
bounties.
There
is
no
exclusivity,
so
just
build
up
and
get
into
it
and
obviously
there's
where
it's
easier.
It's
more.
A
So
if
you
look
at
the
threads
from
beginners
to
intermediate
to
advanced
bounties,
it
basically
gets
you
to
to
build
your
own
wallet
could
custodial
non-custodial.
I
don't
even
care
at
this
point
to
basically
create
mint,
redisplay
and
buy,
sell
nfts
so,
of
course,
on
the
beginner's
bounty
really
just
provide
some
integrations
into
those
custodial
wallets
and
apis
of
those
two
marketplaces.
A
If
you
feel
you
should
use
a
different
one,
let
me
know
I'm
sure
we
can
work
something
out
and
just
basically
find
fetch
and
display
nfts,
because
another
interesting
part
is,
for
example,
in
in
some
of
those
marketplaces.
If
you're
not
long
enlisted,
you
can't
find
your
most
of
your
wallets
can't
find
your
nft
asset
any
longer,
because
it's
no
longer
available
through
the
api
and
a
lot
of
the
wallets
are
actually
all
you
know,
lazy.
A
So
this
is
this
is
so
on
the
beginning,
there's
some
leeway
and
I
I
I
believe
you
you'll
build
some
really
cool
stuff.
The
intermediate
bounty
is
basically
build
a
super
wallet
to
you
know
across
the
marketplaces,
so
this
is
sort
of
a
a
multi-marketplace
approach
and
the
advanced
one
is
to
really
like
blow
it
out
and
build
the
full
wallet.
A
In
addition,
so
this
is
five
times
five
hundred
one
times
a
thousand
one
time,
two
thousand.
In
addition,
we
have
best
use
of
fluence
and
aqua
in
your
dap.
So
if
you
already
have
you
have
something
you
wanna
build
something
or
you
already
done
something,
and
it
has
some
components
that
need
to
be
centralized.
It
could
benefit
from
off
chain
or
you
actually
really
like.
Look
at
aquas
like
okay.
I
can
replace
like
thousands
of
lines
of
code
with
just
a
few,
that's
for
you
and
I
got
a
few
examples
for
there.
A
So
you
know:
decentralized,
nft
creation,
storage
solutions,
for
example,
nft
storage
from
ipfs,
which
is
plain,
ipfs,
create
multi-source,
decentralized,
exchange,
price
oracles,
for
example,
including
for
for
nfts
or
trade
books.
What
order
books,
whatever
you
want
to
do,
enable
off
chain
dials
anything
I
mean
those
are
just
examples.
Whatever
you
have
in
your
mind
for
udap
this
is
and
there's
room
for
fluence
and
aqua
go
for.
It
we'd
be
happy
to
support
you
and
look
forward
to
your
submission
for
additional
resources.
We
have
a
website.
A
A
B
Yeah,
I
don't,
I
don't
have
any
questions
and
I
don't
see
any
in
the
chat
I
wanted
to.
Thank
you
for
your
time.
Bernard
I'm
totally
fine
with
it
going
over.
It's
always
super
informative
and
I
think
a
lot
of
people
got
a
lot
from
it.
So
thank
you
for
that.
I'm
going
to
probably
drop
the
fluence
discord.
I
think,
and
I
might
have
dropped
it
in
our
discorders
as
well,
but
not
I'll
drop
that
in
the
selling
point
hackathon,
underneath
where
we
were
talking
about
this
workshop
too.