►
From YouTube: Hands-on p2p network choreography. Workshop
Description
00:00:00 Intro
00:02:46 Requirements to follow the workshop
00:03:47 Hackathon bounties review
00:07:10 Example of the chat app built with Fluence
00:14:46 What is Fluence
00:46:41 Building a simple service in Rust: Curl adapter
01:20:48 Making a multi-module project and writing to disk from service
01:44:23 Authorization
----
Workshop content:
- what is Fluence?
- clone repositories so you can repeat after me
- simple effectful service in rust: curl adapter
- configure it, deploy
- connect it with frontend
- CLI: inspect, run scripts
- writing to disk from service
- linking 2 modules together: url downloader
- advanced: authorization, tetraplets
----
Speaker: Alexey Pyshnenko
Engineer at Fluence Labs
----
Source https://youtu.be/om038Mnzj_w
Workshop flow https://www.notion.so/fluencenetwork/Fluence-Workshop-hands-on-2-network-choreography-83beddecd2194a4789039406a85224df
Hack the System hackathon challenges https://medium.com/encode-club/hack-the-system-announcing-fluence-87fa8dae59
Get started with Fluence https://fluence.dev/docs
Protocol Paper https://github.com/fluencelabs/rfcs/blob/main/0-overview.md
Developer Hub https://dash.fluence.dev/
Github https://github.com/fluencelabs
Fluence Home https://fluence.network/
A
So
hi
everyone
welcome
to
today's
workshop
with
fluence,
and
this
is
the
first
workshop
in
the
hackles
system
hackathon
that
we're
running
over
the
next
sort
of
ten
weeks
and
yep.
This.
This
hackathon
is
gonna,
be
led
by
the
the
fluence
team,
which
consists
of
anna,
the
community,
lead
and
then
alexei,
dimitri
and
bernhard,
so
they'll
all
be
here
to
to
walk
you
through
it
fluence
today
the
technology
and
answer
any
questions
you
might
have
in
in
relation
to
that
fun.
So,
just
a
bit
more
in
general
about
the
hackathon.
We
have.
A
We
start
off
with
the
five-week
learning
period
where
you
are
allowed
to
hack,
but
we
host
workshops
with
the
sponsors.
We
have
general
introduction
to
blockchain
coding
workshops
just
for
everyone
to
get
to
grips
with
with
blockchain,
if
you
maybe
haven't
developed
on
it
before
and
a
chance
to
learn
a
bit
more
about
our
sponsors
technology
like
we
have
today
in
terms
of
support
throughout
the
hackathon.
We
do
offer
one-to-one
kind
of
advice
sessions.
A
So
it's
a
really
good
session
to
set
up
if
you,
if
you
would
like
to
in
general,
the
hacking
should
start
by
around
the
end
of
march
and
the
submissions
are
in
early
may
and
then
the
judging
and
the
final
event
will
be
in
mid-may
and
obviously
we
have
the
upcoming
events
wise.
We
have
the
stella
workshop
this
friday
and
we
have
a
general
introduction
to
blockchain
event
next
tuesday
and
next
wednesday,
the
10th.
B
B
So
first,
let's
start
with
the
requirements.
If
you
are
to
follow
me,
you
need
to
go
to
the
requirements
title
here
and
install
everything
that
sets
here
no
anyway,
so
you
will
need
npm
or
yarn
to
install
jsdk
or
serena
just
decay
and
foggy
that's
the
utility
we
use
to
manage
flumes
from
command
line
and
all
this
stuff,
you
will
need
to
develop
services
in
rust,
okay,
it
will
take
some
time
to
install
so
especially
the
rust
and
compile
all
of
this.
So
please
do
that
as
early
as
possible.
B
If
you
are
to
follow
and
then
sorry
for
scrolling
over
all
around
and
then
let's
take
a
look
at
our
boundaries,
we
have
three
boundaries.
One
first
one
is
to
use
accommodating
with
existing
services.
They
can
be
not
really
clear
right
now
or
well.
You
don't
know
much
about
fluence,
but
they
will
be
clear
after
after
the
workshop.
B
So
let
me
disable
those
notifications
we
have.
I
have
a
link
here
to
the
medium
that
describes
the
bounties
in
detail,
so
the
let's
just
review
it
a
little.
So
the
first
bounty
is
called
easy
challenge.
You
have
to
use
custom
air
scripts
to
clear
one
of
the
existing
services.
That
should
be
really
really
easy
and
you
will
have
100
dollars
per
functional
submission.
It
says
that
you
need
to
decorate
your
submission.
That's
not
entirely
true.
It's
optional!
You
can
submit
a
working
repository
on
github.
B
B
So
that's
the
main
requirement
for
for
your
submission
to
be
considered
functional
that
what
the
rights
is
meant
to
to
mean.
So
the
second
bound
is
medium
challenge.
It's
for
250
and
you
have
to
implement,
deploy
custom
service.
It
can
be
a
service
that
queries,
ethereum
or
maybe
some
other
service.
It
got
to
be
a
custom
service,
not
the
one
from
workshop
and
yeah
custom,
air
2.
B
You
have
to
submit
custom
service,
custom
scripts
and
custom
front-end,
and
you
will
compete
with
others
for
the
first
place
of
two
thousand
dollars
and
the
second
place
of
one
thousand
dollars
same
here.
It
says
dockerized,
but
it
means
really
that
you,
it's
gotta,
be
working
and
it's
gotta
be
really
really
clear
how
to
run
it.
So
if
it's
not
clear
how
to
run
your
submission,
it
won't
be,
it
will
be
hard
for
us
to
judge.
So
please,
please
make
it
clear
how
to
run
okay.
B
B
B
I
chose
go
here
because
it's
nice,
it's
a
nice
service
and
it
gives
you
an
api
to
really
implement
this
functionality.
So
if
we
are
to
build
such
a
chat,
we
will
have
will
have
to
start
with
some
back
end
and
its
api
right.
It
can
be
like
an
http
endpoint
like
end
users
with
this
instead
of
a
structure
or
instead
of
json
just
fastest
get
parameters,
it
doesn't
really
matter
here
it.
B
So
it's
just
an
idea.
The
principle
will
always
be
the
same.
You
will
have
some
end
point
that
that
is
called
something
like
edge
user
and
you
will
pass
their
name
and
id
of
the
user
to
add
that
user.
There.
You
will
have
a
query
and
point
to
get
list
of
users.
You
will
have
a
message
endpoint
to
add
message
with
some
this
thing
it
will
be
more
clear
later,
but
it's
an
authorization
token.
B
I
mean
it's
a
simple
boolean,
so
it's
true
false
and
it
works
influence
that
way
and
it's
really
interesting
how
it
works.
But
anyway,
you
will
have
instead
of
boolean
some
more
complex
logic.
Talking
or
something
still,
you
will
have
add
messaging
point.
Then
you
will
have
get
message,
some
point
and
finally
clear
url
and
point
to
implement.
B
So
that's
what
I
would
start
with
when
building
a
simple
chat,
not
influence,
but
a
general
traditional
client
server
application
with
backend
with
api
like
this
and
with
front-end
with
basic
functionality.
Like
add
user,
send
message
list
users
in
list
area
some
scrolling
thing
and
in
the
input
you
would
have
be
able
to
type
that
comment.
So
it
will
go
to
query
to
query.
B
B
Whenever
I
want
to
prototype
on
an
application
like
this,
I
usually
have
to
start
from
more
or
less
from
the
scratch.
I
have
to
have
some
server
listing
on
some
port,
some
routing
logic,
something
to
store
data,
something
to
query
data.
I
have
to
think
about
how
to
do
this
thing
and
then
that
thing
and
implement
all
this
in
my
front-end
application
and
that's
always
pretty
much
the
same
right.
It's
always
pretty
much
the
same
logic
everywhere
and
a
lot
of
people
who
start
prototyping
apps
like
this.
B
They
just
repeat
what
what's
already
been
done
by
others,
but
why
why
why?
Why
waste
human
time,
if
you're
you're,
surely
not
the
first
human
to
store
a
list
of
users
and
messages
in
a
database
right?
And
there
are
already
someone
who
built-
maybe
libraries
for
that-
maybe
repositories
that
you
can
start
with.
But
what?
If
someone
already
has
running
such
components
somewhere?
B
B
If
you
know
someone
who's
running
such
api,
you
could
contact
him
directly
and
ask
for
access
to
it,
but
that's
really
not
a
systematic
solution.
I
would
like
to
be
able
to
use
someone's
api
if
he's
okay
with
that,
and
I
would
like
to
have
some
discovery
around
that
kind
of
interaction
right,
so
it
would
be
nice
to
reuse
code
and
that's
already
running
and
maybe
even
reuse
this
state.
C
B
B
From
telegram
and
send
messages
to
them
on
twitter
and
all
that
without
redeploying
the
services
without
searching
for
open,
end
points,
because
if
telegram
telegram
surely
has
some
apis
inside
their
cloud
but
they're
no
not
exposed
to
the
public,
because
it's
really
hard
it's
behind
the
security
perimeter
and
it's
not
a
traditional
way
to
go
and
expose
your
apis
to
anyone
to
use-
and
that's
kind
of
I
understand.
Why
is
that?
But
that's
kind
of
sad,
but
even
if
you
gather
access
to
those
apis,
there
was
wastely
vastly
different.
B
You
have
api
from
one
vendor,
it
uses
xml
other
render
uses
json
and
you
have
to
convert,
and
where
do
you
convert?
How
do
you
compose
those
different
apis?
Do
you
write
logic
on
front-end
and
get
your
front-end
bloated,
and
if
I
want
to
reuse
that
logic
in
another
app,
I
have
to
write
it
from
scratch
or
copy
paste.
B
B
B
B
Every
application
is
a
web
assembly
service,
so
the
runtime
we
use
for
application
is
webassembly
and
applications.
They
can
be
hosted
on
a
set
of
peers,
not
just
on
a
single
one.
You
can
scatter
the
services
of
your
application
on
several
years
and
compose
them
through
script,
language
that
I
will
show
you
and
we'll
talk
about
later.
B
B
B
You
can
see
smaller
red
dots.
Those
are
the
services
on
the
nodes,
so
I
can
say
that
this
node
here
runs
two
services
and
those
browser
icons.
This
is
the
clients
and
clients
want
to
interact
with
each
other,
for
example,
they
want
to
use
chat.
They
want
to
send
message
to
chat
members
and
to
store
it
to
somewhere
durable,
so
messages
can
be
retrieved
later
how
it
works
so
first,
since
the
browser
isn't
really
have
ability
to
receive
incoming
connections
on
its
own.
B
Imagine
you're,
sitting
at
mcdonald's
behind
in
that
net
that
defend
all
the
wi-fi
limitations
and
firewalls.
You
can't
receive
entire
connections
so
to
interact
with
the
network.
Then
such
clients
they
use
nodes
called
relay.
Currently
any
relay
can
be
used
as
a
node
in
the
future.
You
will
have
to
agree
with
with
a
node
if
it
wants
to
be
your
reload.
B
Currently,
you
can
just
use
any
node
as
a
reload.
So
this
the
fox,
the
red
fox.
It
wants
to
send
a
message
to
the
chat.
How
does
it
it
sends
a
script
that
says:
go
to
user
list
service
load,
the
list
of
users,
the
ids
peer
ids
of
those
clients
and
for
each
user
go
and
call
a
function,
display
message
on
each
of
them.
B
So
if
a
client
is
participating
in
chat,
it
defines
through
gssdk
it's
very
simple:
it
defines
the
api
function.
That's
are
callable
on
that
client.
So
in
this
case
they
are
participating
in
the
chat.
So
they
define
display
message
function.
Display
is
a
service
message
is
a
function.
It's
really
easy,
so
it's
basically
a
callback,
so
this
client
what
it
does
it
loads.
B
It
asks
the
network
to
load
list
of
users
in
the
chat
and
then
call
on
each
of
them
a
callback,
a
function
that
will
display
a
new
message
on
their
screens
and
after
and
in
parallel
to
that,
all
that
happens
in
parallel
and
in
parallel
to
that
also
happens.
The
persistence
of
the
message
so
here
after
in
parallel
with
sending
with
colon
display
message,
functions
on
client,
we
also
store
a
message
on
history
service.
B
So,
what's
under
the
hood
under
the
hood
every
peer,
including
browser
clients
and
nodes
and
others
they
have
webassembly
runtimes,
you
can
see
that
all
nodes
have
at
least
one
webassembly
runtime.
This
runtime
is
used
to
interpret
the
scripts
the
by
calculus
based
scripts
that
define
the
orchestration
of
the
network.
B
B
So
you
can
take
this
interpreter
of
the
script
language
and
put
it
anywhere
where
you
can
run
a
web
assembly
on
time
and
it
will
be
able
to
interpret
the
scripts
and
basically
will
be
able
to
participate
in
the
network
and,
as
I
said,
some
nodes,
they
can
also
host
services,
and
the
services
are
also
run
in
webassembly
runtime
in
a
different
one.
It's
the
same
runtime,
but
but
with
different
webassembly
module
loaded
into
so
freeze
network.
Is
this
it's
really
simple?
B
B
B
B
B
It's
different
because
it's
a
p2p
network,
not
a
client,
server
architecture
and
p2p
architecture,
is
it's
more
general
than
client
server.
It
can
implement
client
server
and
more
instead
of
having
backends
as
different
beasts
compiled
from
different
language
languages
to
native
code,
you
have
services
compiled
to
webassemb
instead
of
http
you're
using
fluence
protocol,
it's
based
on
rust
liquidity
by
the
way,
which
is
a
really
nice
library.
If
you're
building
liquid
to
be
networks,
I
mean
p2p
networks,
you
should
check
it
out.
B
And
what
makes
really
what
makes
fluence
really
outstanding?
Is
that
requests
sorry
requests?
They
are
programmable.
You
can
program
routing
through
scripts.
You
can
say
to
the
network.
Take
this
request.
Put
it
here,
call
some
function.
Take
a
result
of
that
function.
Send
the
data
to
another
place.
Then
there
then
here
and
you
can
call
a
lot
of
services.
You
can
call
any
number
of
services.
You
can
compose
their
results,
you
can
transform
the
results
and
you
can
send
data
from
one
service
to
another.
Save
it
to
database.
B
C
B
If
they're,
if
they
can
have
a
direct
connection,
they
can
avoid
having
servers
or
they
can
use
servers
as
a
blind
relays.
Just
proxies
that
just
forwards.
The
data
from
between
the
clients
servers
of
different
vendor
can
communicate
if
twitter
or
telegram
or
other
vendor
is
to
expose
their
apis
to
the
fluence
network.
B
B
Then
you
can
contact
him
and
you
can
discuss
and
you
can
give
him
access
to
your
service
in
a
secure
way
and
it
can.
He
can
reuse
it
without
without
writing
their
own
from
scratch,
and
they
don't
need
to
host
it.
You
can
cost
it.
You
can
share
already
running
services
between
companies.
You
can
do
that
in
private
setups.
You
can
do
that
in
your
home
local
network
anywhere.
B
B
And
what
we
have
also
is
a
built-in
peer
and
service
discovery.
If
you
want
to
reach
some
node
in
the
network,
some
client
in
the
network-
all
you
have
to
know,
is
it's
p
rating
and
the
peer
id
of
the
relay
it
connected
to,
and
that's
all
you
don't
know
you
need
to
know
ip
address,
it
will
be
automatically
discovered
through
the
adam.
The
network
for
the
cadet.
C
B
And
same
with
services,
if
you
or
your
friend
or
someone
else
deployed
service
to
the
network,
all
we
need
is
peer
id
of
the
node
that
this
service
is
hosting
and
the
service
id.
So
you
need
priority
and
unit
of
the
service,
and
you
can
call
that
service.
You
can
inspect
its
api.
You
can
compose
it
with
other
services.
B
B
C
B
Our
own
implementation
of
interface
types,
which
is
still
in
the
proposal
phase
webassembly,
gives
you
security
sandbox.
It's
a
really
simple
binary
format,
so
it's
it's
easily
inspectable
and
instrumental,
and
by
design
it
doesn't
have
excess
unlimited
access
to
the
operating
system
that
works
on
like
native
apps
native
apps.
They
usually
can
call
in
cisco,
but
here
in
wasp
you
have
you
to
limit
that
you
can
configure
which
these
calls
are.
B
B
If
you
have
different
apis,
you
have
to
write
this
integration
code
inside
your
front-end
up
or
inside
your
back-end
service,
and
it's
hard
to
make
it
reusable
really
because
you
you
can
implement
it
as
a
library
and
give
nice
interfaces
to
others.
But
it's
really
it's
really
a
hard
task.
It's
a
basically
making
a
library,
an
internal
product,
and
you
have
to
support
it
and
all
that
with
echo
marine
you
can
compose
services
without
depending
on
the
actual
implementation
of
the
services.
So
it's
a
different
language.
It's
a
different
execution
environment.
B
You
have
this
script,
then
I
will
show
you
already
in
a
moment
that
controls
different
services
and
you
have
the
services
that
that
are
written,
for
example,
in
rust
and
compiled
to
webassembly
in
some
service
it
may
use
sqlite
today,
but
tomorrow
it
can
be
redeployed
and
use
redis
to
store
its
data
and
accommodating
it
doesn't
care.
Really.
B
B
Now
you
can
express
many
algorithms,
you
can
express
academia
and
we're
already
working
on
porting
cadently
to
that
script.
Scripting
language.
Apparently
we
enjoy
the
academia
baked
into
our
nose,
use
it
and
we
took
it
from
rust
liquidity
and
it's
a
great
implementation.
But
we
thought
why
do
we
need
to
break
ademya
into
our
notes?
Couldn't
they
just
start
and
wait
for
comments,
and
if
those
comments
tell
it
how
to
organize
in
a
sore
topology
an
academic
apology?
B
Well,
they
will
do
that.
All
you
have
to
do
is
to
allow
scripts
to
manage
connection
of
the
nodes
like
say
to
connect
to
this
node,
send
message
to
this
node
and
that's
based,
and
you
have
to
be
able
to
execute
functions
on
different
nodes
on
different
peers
in
the
network
and
having
those
primitives.
B
You
can
import
the
complex
cadenza
algorithm
to
the
scripting
language
that
is,
and
it
will
be
pluggable
on
each
node.
So
you,
if
you
need
to
have
different
academia
network
for
your
own
project
that
will
work
only
on
10
of
your
nodes
or
or
50
nodes.
That
you
know
was
really
any
different
topology
you
can
have
it.
You
can
take
the
scripts
of
our
academic
implementation.
You
can
copy
them
to
you
and
deploy
same
services
or
modified
services,
and
you
can
compose
them
and
have
your
own
cadempa.
B
So
currently,
friends
network
has
just
one
kadamla
network
and
after
reported
to
payer
scripts,
you
can
have
tens
or
hundreds
of
that.
Those
networks
are
thousands
and
they
can
be
totally
independent
with
different
projects.
If
you
want
to
euro
to
prototype
and
try
your
own
custom
cpu
attack
defense,
you
can
do
that
you're,
a
simple
changing
script.
You
don't
need
to
have
all
the
code
compiled
to
some
node
and
then
go
to
that
node
and
learn
how
it
works
to
the
ground.
I
mean
100
percent.
B
B
B
You
can
have
microservices
composed
in
aquamarine.
You
can
have
them
in
public
and
private
deployments
on
your
local
home
network
on
your
work
anywhere.
You
can
have
different
communication
patterns
expressed
in
accommodate
scripts.
You
can
push
notification
to
browser
clients.
You
can
pull
data
from
browser
clients
periodically.
B
You
can
send
message
from
one
browser
to
another
browser
to
some
node
and
express
any
topology,
and
you
don't
need
to
receive
responses,
because
when
you,
if
as
if
we
remember
the
chat,
chat
api,
I
showed
in
the
beginning,
how
do
you
compose
data
from
get
from
get
users
endpoint
via
messages?
You
have
to
send
a
get
request
or
some
rpc
request
to
one
of
the
endpoints
say
that
will
give
you
a
list
of
users
back.
You
will
have
it
on
your
front-end
application
and
then
on
your
front-end
application.
B
B
B
And
if
someone
updated
or
viewed
your
self-updated
version
of
the
service
and
made
the
api
changed,
you
just
change
a
little
name
of
the
function
or
some
format
of
the
arguments
in
the
script,
and
that's
it.
You
don't
need
to
deploy
anything
because
the
script
is
just
a
text
file.
You
can
just
run
it
anytime.
B
B
And
then
you,
you
say
for
that
list
of
peers
execute
a
function
on
each
of
that
of
the
peer
in
the
list,
and
then
you
switch
list
topology
to
cadence
topology
or
to
rough
topology,
and
then
you
say:
execute
go
through
the
raft
find
out
and
topology
will
define
that
you
have
to
go
through
the
raft
discovery.
All
other
rough
members
check
that
they
are
alive
and
only
then
call
a
function
on
them,
and
thus
they
will
be
reusable
they.
You
can
switch
one
topology
to
now,
but
that's
work
in
progress.
B
It's
going
to
be
nuts
really
it's
really
hard
to
put
to
put
it
in
words,
and
once
we
have
it
done,
we
will
have
it
in
the
code
and
it
will
be
amazing.
So
what
we
have
now
we
have
marine
scripting
language,
that's
written
for
use.
You
can
compose
services
yeah
accommodating
scripts.
They
are
currently
written
in
air
language,
marine
intermediate
representation,
that's
a
low
language,
a
low
level
language
for
gluten.
B
B
B
We
have
already
a
lot
of
examples
done
on
friends
that
showcase
ptp
communication
that
showcase
how
to
broadcast
messages,
how
to
broadcast
function,
calls
how
to
do
authorization,
how
to
talk
with
ethereum
servers
and
how
to
basically
implement
oracle,
taking
data
from
ethereum
service
and
processing
it
in
a
specific
way
and
put
it
to
other
service
services.
You
can
periodically
take,
for
example,
prices
from
ethereum
nodes
or
from
some
api
that
give
you
prices
and
then
put
up
a
service
that
that
implements
some
prediction
algorithms
and
gives
you
a
service
that
predicts
prices.
B
B
This
script,
this
script
tells
the
network
to
go
to
some
node
called
relay
call
some
service
called
user
list
and
check
if
the
current
user
that
sends
the
script
is
authenticated
if
it's
authenticate
and
the
result
of
that
authentication
is
put
into
variable
status.
So
this
call
here
is
really
a
function.
Call
you
call
function
is
authenticated
on
service
user
list,
which
is
hosted
on
the
node
relay
and
you
put
result
in
the
variable,
with
name
state
status.
B
So
then,
now
you
go
to
the
history
service.
For
example.
It's
a
chat.
History
service,
for
example,
could
be
any
other
history
service.
But
here
it's
a
chat
system
and
you
call
add
function,
meaning
that
you
want
to
persist
the
message
into
the
history
service,
so
others
can
read
it
later.
So
it's
a
persistency
layer
of
your
chat
application
and
you
specify
two
two
arguments
to
the
function
to
function
at
first.
One
is
message
that
contains
some
hello
or
image
or
whatever,
and
the
second
one
is
this.
B
Construction
that
takes
field
is
authenticated
from
this
status
so
status.
It's
a
structure
that
has
that
field
is
authenticated
and
it's
a
boolean,
simple
boolean,
but
under
the
hood
we
have
this
security
implemented
for
all
arguments.
I
will
talk
about
that
in
the
at
the
end
of
our
workshop
and
it
checks
that
this
boolean,
true
or
false.
It
comes
from
correct
service
and
from
correct
field.
B
B
So
once
we
added
a
message
to
the
database
and
proceeded
it,
we
then
go
to
user
list
service
and
ask
for
all
users
of
the
chat,
and
then
we
fold
through
we
iterate
this
default
fold
instruction
here.
It
means
iterate
through
the
array
of
users
and
for
each
user,
put
it
into
variable
named
view
and
then
call
a
chat
display
function
on
each
of
that
here.
B
B
We
have
a
documentation
on
this
documentation
on
the
language
documentation
on
instructions,
documentation
on
services,
so
beer
with
me
will
go
there.
You
will
have
links
to
to
study
yourself
if
you
want.
Oh,
I
have
this
some
problem
here
with
indentation:
let's
switch
to
the
to
the
text.
It's
a
better
identity,
so
what's
happening
here
if
something
goes
wrong,
rejoin
yourself,
the
error,
but
how
here
on
the
top
level,
we
have
this
instruction.
B
B
This
is
a
try
block
and
this
is
a
cage
block,
and
here
we
say
that
if
some
error
happens
then
return
that
error
to
the
initial
appeal
to
the.
If
I
send
this
script,
then
to
me
return
that
error,
the
last
error
to
initial
peer
id,
which
is
a
client.
If
the
client
sent
this
request,
then
you
need
peer.
B
Id
will
be
declined
and
this
line
here
it
says
that
you
can
access
the
client
through
the
relay,
because
the
client
could
be
somewhere
behind
the
nut
and
behind
the
firewall,
and
it
has
a
direct
connection
with
that
relay
so
to
access
the
client.
You
have
to
go
through.
It's
really
important
and
not
forget
to
specify
your
viewer.
B
B
B
B
Here
great,
so
then
we
will
configure
that
service
we
will
deploy.
We
will
connect
it
with
a
front-end
application.
We
will
use
cli
to
the
flgs
here
to
inspect
the
server
that
service
and
run
scripts
from
cli.
You
can
run
scripts
from
front
end.
You
can
run
scripts
from
cli
or
you
can
use
your
own
environment
that
you
like.
B
Then
we
will
extend
that
service
to
be
able
to
write
data
to
disk,
and
I
will
also
explain
how
to
link
several
modules
together
and
finally,
we
will
go
to
advanced
part
that
we
have
time
hopefully,
and
we
will
talk
about
authorization-
that's
done
through
chatroclax.
We
have
this
term
I'll
talk
about.
B
So
what
I
want
to
have
is
a
separate
service,
so
others
can
reuse
it,
and
I
want
to
be
able
to
call
network
to
call
duckduckgo
from
that
service,
but
there's
a
problem
with
wasm
advisor.
They
do
not
provide
network
socket
api
yet,
but
how
to
work
around
that?
We
can
review
the
existence
of
I
like
reusing
stuff,
and
here
we
will
use
curl,
not
as
a
library
but
as
a
binary.
That's
already
that's
running
that
that
exists
on
the
node.
B
B
B
And
the
whole
implementation
of
that
request
and
the
point
now
that
request
function
is
here
in
a
single
line.
It
calls
external
binary
curl,
like
a
simple
raster
like
an
ordinary
rust
function.
It
passes
a
single
argument,
that's
an
array
of
a
single
argument
of
a
single
element
to
as
an
argument
to
the
curl.
So
it
basically
does
this.
B
B
B
B
We
have
a
script
airscript
to
call
those
backends
and
we
have
this
configuration
file
that
allows
you
to
try
the
service
lock.
I
will
talk
about
so.
Let's
first
review,
let's
first
review
the
backhand
right,
as
I
said,
it's
a
simple
rust
project
that
has
a
single
dependency
experience.
That's
fluence
trust
sdk,.
B
And
here,
and
when
you
compile
that
project
you
in
result
will
have
a
webassembly
file,
so
you
will
have
something
like
curl
template
dot
wasn't
somewhere
in
the
target
directory.
We
will
do
that.
We
will
see
so
here.
What's
in
the
what
are
the
sources
of
the
project?
They
are
pretty
simple,
as
was
imagined
presented
on
the
pictures
here
I
passed
two
arguments,
the
url
and
the
options
to
make
it
less
verbose.
B
So,
anytime,
you
want
to
call
some
mounted
binary,
some
external
binary.
You
will
have
to
do
it
that
way.
You
will
have
to
have
external
c
around
it.
So
it's
so
rust
knows
it's
an
ffi
frame
function.
Interface.
You
will
have
to
have
this
link.
That
points
was
member
module
to
host.
So
runtime
knows
that
you
mean
running
those
functions
on
the
host
and
you
will
need
to
have
this
macro
fce
that
converts
all
this
and
converts
underlying
types.
So
you
can't
have
just
string
and
webassembly.
You
can
have
just
result
in
web
assembly.
B
You
need
to
manage
pointers
and
draw
memory
to
for
this
to
work
so
that
what
that
small,
free
electric
micro
does
inside
a
lot
of
complex
logic
that
you
don't
have
to
worry
about.
You
just
have
to
have
this
marker
here
and
to
describe
your
public
api.
You
define
function
and
mark
it
with
fc
macro
too,
so
it
converts
it
makes
public.
It
makes
it
available
for
scripts
to
call
and
it
converts
complex
structures
to
webassembly
format.
B
Okay,
so
how
is
it
deployed?
What
how
to
deploy
a
service
to
the
influence?
It's
pretty
simple.
The
first
thing
is
this,
and
the
second
thing
is
this:
all
everything
else
is
just
a
fancy
scripting
stuff
that
we
don't
really
care
about.
So
you
to
compile
the
webassembly
file,
you
have
to
go
to
the
backend
folder
and
run
fc
view
minus
minus
release.
That's
why
you
need
fce
installed,
so
I'm
in
coral
template
I
go
to
backhand,
I
put
a
simple
release
and
I
have
my
web
assembly.
I
guess
it's
too
small.
B
B
So
we
deployed
service,
let's
try
to
call
it
and
here
yeah
and
sure
where
the
wasm
file
is
in
the
target
folder.
So
we
can
check
it.
It's
there,
it's
there
and
then
discrete
the
dwsh
script.
It
uses
flgs2
to
create
a
service.
So
you
basically
specify
a
list
of
modules
as
a
players
of
awesome
semicolon
configuration
file
in
here
configuration
file.
We
already
seen
here
on
the
image.
It's
it.
You
have
a
link
here
to
follow
if
you
want
so
that
already
happened,
let's
try
to
call
our
service,
but
before
that,
let's
review.
B
Let's
call
that
service,
but
first,
let's
review
the
script
so
to
call
the
service
you
use
for
this
run
air
command
and
you
specify
a
path
to
air
script
and
you
specify
variables
really
for
variables
that
I
use
inside
that
script,
what
it
means
variables
inside
script.
So
let's
take
a
look
at
the
request.
Air
file
here
we
have
a
simple
script
that
goes
to
a
service
goes
to
a
node
which
id
is
resolved
through
variable
named
service.
That's
why
we
have
here.
B
I
will
switch
tab,
that's
why
we
have
here
this
variable
that
holds
a
service
id
so
yeah.
It
holds
a
service
id
here,
so
it's
so
we
can
use
it.
We
go
to
the
node
relay
here.
It's
also
variable,
but
run
air
already
gives
you
that
to
use.
So
we
don't
have
to
specify
it
all
the
time.
If
we
switch
to
another
relay,
it
will
automatically
change.
B
B
What
hamataki
means
it's
magic,
mathematical
object
and
stuff
we
will
see
and
we
have
the
result
of
the
curl
execution
of
the
call
of
the
curl
binary
put
into
well
variable
named
result.
And,
finally,
we
go
to
the
init
peer
id,
which
is
our
the
client's
address,
and
we
run
this
thing.
This
is
a
specific
to
run
air
command.
So
when
we
we
do,
author
just
run
air,
we
have
two
variables
available
for
us.
First,
one
is
a
relay
and
second
one
is
return
service.
B
That
way,
you
can
always
return
a
result
to
the
client.
By
calling
this
this
service
return
service
and
function
run,
it
will
be
just
displayed
on
the
in
the
console.
Let's
see
how
it
works
in
action,
so
here
you
can
see
that
it
it's
a
different
service
id
than
from
what
I
created,
because
it
was.
Let
me
make
it
a
little
smaller.
It's
too
big.
I
think
I
hope.
B
B
B
Okay,
so
it
works
this
second
argument,
so
you
have
here
two
things
display.
First,
one
is
the
result
of
the
curl.
Second,
one
is
the
tetraplate
that
says
where
this
result
came
from.
That's
how
security
works.
I
will
talk
about
it.
I
will
elaborate
on
it
later,
but
in
short,
you
have
this
thing.
That's
called
tetraplax.
Why?
Tetraplex,
because
there
are
four
meaningful
fields.
There
are
four
fields
from
what
node.
B
C
B
B
B
Okay,
service
id
is
this
and
we
will
have
a
json
json
structure
that
describes
that
this
service
has
the
following
functions.
It's
a
single
function
called
request
with
a
single
argument:
url
of
type
string,
it
outputs
string,
result,
structure
and
the
that
structure
string.
Result
it's
defined
here
in
record
types.
So
we
know
that
it
has
those
fields,
red
code,
error,
std
out
and
ecdr,
all
of
them
strings,
except
the
return
code,
which
is
an
interview,
and
it
will
also
show
us
who
is
the
owner
or
who
created
that
service.
B
That's
the
peer
id
that
was
after
automatically
generated
here.
Let
me
show
it
yeah
this
yeah
was
it
yeah
client
ready,
that's
the
one
that
was
used
to
create
the
service
and
it's
and
it's
the
same.
So
every
service
knows
who
created
it
and
it
can
be
checked
in
the
service
function.
That's
another
primitive!
You
can
use
for
authorization.
B
Right
yeah,
it's
recorded,
but
I
will
elaborate
anyway.
I
will
hope
to
make
it
clear
that
backend
is
awesome.
It's
not
like
what
we
can
do
is
connected
to
us.
We
have
has
this
code
here.
It
says
this
is
our
backend.
This
is
the
backend
code
right,
and
this
is
the
api
of
the
back
this
code.
It
was
compiled
to
webassembly
module
and
deployed
to
melody.
B
So
it
was
a
really
simple
deployment
process
and
you
can
have
it
programmed
in
different
complex
way.
You
can
deploy
different
services
to
different
nodes,
different
backends,
to
different
nodes
in
a
dynamic
way.
However,
you
choose
to
do,
but
here
it
was
simple
that
we
have
this
code.
This
is
whole
code
wire
back
no
more.
B
So
I
was
a
little
ahead.
Let
me
explain
so
here
we
have
a
simple
tamil
conflict
that
describes
describes
for
fc
repo,
how
to
run
that
service
locker.
Here
we
have
a
specification
for
a
module.
It's
almost
the
same
as
you
have
seen
in
json
right.
It's
almost
almost
the
same
as
a
configuration
for
this
module.
B
Just
this
is
in
json,
and
this
is
in
town.
It
specifies
where
to
look
for
the
module.
It
specifies
the
name
of
the
module
yeah,
so
we
we
had
the
we
had
our
module
and
that
this
folder
right
under
this
name
dot
rasm,
that's
exactly
what
it
says
what
it
says,
and
here
we
specify
the
same
amount
of
binaries.
B
So
we
tell
that
we
should.
The
fc
rebel
should
look
for
the
curl
on
my
system
now
now
it
is
running
locally
under
this
path.
So,
let's
run
it
to
run
to
run
vfc
repo,
you
have
to
specify
path
to
the
configuration
file
you
run
it
up.
Service
is
creates,
is
created
immediately
and
you
can
call
it.
Let's
see,
how
can
we
how
we
can
call
it?
B
B
B
B
B
I
don't
have
much
of
it
too
bad
anyway,
let's
review
package.json
for
now,
while
it
installs
so
package.json.
I
hope
you
know
that
it
well.
It
allows
you
to
specify
dependencies
for
your
project
here.
There
are
two
main
dependencies
for
using
fluent.
First
one
is
fluence
jcdk.
Second,
one
is
a
library
that
allows
you
to
switch
between
different
environments
of
the
frames
network.
B
B
So
here
we
have
a
really
simple
web
application
that
has,
as
that
has
the
field
to
enter
the
url
and
the
button
to
issue
a
request
to
issue
a
call
function
to
the
service.
We
will
go
through
the
source
of
the
front-end
application
in
a
moment
here.
You
can
see
that
we
send
a
request
to
go
and
receive
the
same
response.
So
if
I
put
here
another
string,
we
will
have
apple
apple,
disambigation
definition
text
apple
daily.
Well,
it's
not
that
good.
B
B
It
has
three
main
files
that
you
I
care
about
for
right
now.
The
first
one
is
package.json
that
specifies
the
dependencies
on
florence.js
sdk,
but
that
we
already
looked
through
the
second
one
is
fluence
dot
ts,
it's
a
typescript
file,
yeah,
all
it
does.
It
gives
you
a
single
function
to
call
it's
called
request.
B
B
It's
really
easy,
almost
the
same
as
we
used
if
we
run
air,
but
since
we
don't
have
relay
variable
provided
here
by
default,
we
have
to
provide
it
our
own,
so
it
does
the
almost
the
same.
We
go
to
the
relay.
We
go
to
the
node.host
service,
it's
the
same
thing
in
our
case,
but
still
you
can
have
it
different.
You
can
have
work
with
different
nodes
through
same
relay
and
we
call
service.
B
We
call
the
function
request
there
we
put
url,
we
get
result
and
we
finally
send
a
result
back
to
ourselves
right
here.
We
could
use
init
peer
id
in
person,
science,
but
we
decided
not
to
for
no
apparent
reason.
It's
just
a
matter
of
taste.
However,
you
like
it,
you
can
write,
and
here
you
can
see
that
result
is
returned
to
the
client
through
relay,
so
it's
expressed
in
this
way.
It
says
that
sequentially
go
to
relay,
do
nothing
there
or
identity,
just
nothing
that
does.
B
And
after
relay,
go
to
client
and
call
callback
function,
callback
service
with
callback
function
and
callback
is
defined.
Here,
it's
done
to
disambiguate
with,
so
you
can
see
that
callback
id
is
generated
on
each
request.
That
way,
you
can
differentiate
the
between
different
responses
to
different
requests.
B
So
what
we
have
in
result
is
a
curl
function
that
returns
some
result
here
by
sending
the
script
with
that
data
to
the
network,
script
and
data,
they
are
wrapped
in
a
structure
called
particle
particle
is
a
network
packet
that
contains
well
script
and
data
and
the
timeout
and
once
and
network
will
start
executing
the
script
line
by
line,
and
once
it
goes
to
that
line,
the
particle
will
be
sent
will
be
sent
from
the
relay
to
the
local
client
and
will
be
executed
in
local
webassembly
runtime.
So
this
front-end
application
this
one
internally.
B
B
B
B
You
should
use
testnet
environment
always,
but
this
index
you
can
switch.
You
can
use
several
nodes,
you
can
use
all
of
them.
I
think
there
are
like
10
of
them
right
now.
You
can
use
any
other
or
you
can
stick
with
this
one.
It's
the
most
used
node
we
have.
I
will
show
you
that
also
so
we
have
really
know
we
connect
there
through
korean
create
client
function
that
we
take
from
flint's,
js,
sdk
and
well.
B
We
basically
set
the
client
to
use
it
later,
so
it's
really
obvious
and
then
we
get
the
we
execute
curl
request
once
this
request
function
is
executed
on
on
the
button.
So
we
have
this
button
and
on
click,
it
just
executes
request
function
that,
in
its
turn,
executes
curl
request
that
which,
in
its
turn,
sends
script
to
the
node
and
it
returns
promise.
So
we
wait
for
it.
And
finally,
we
set
the
data
to
be
displayed
here.
B
You
can
see
that
we
access
std
out
field,
so
the
data
this
structure
returned
from
the
rust
right.
So
we
had
this,
we
have
we
had
anyway,
we
had
a
structure
returned
from
rust.
It
had
some
fields
and
those
fields,
they
are
deserialized
to
javascript
objects
to
json
objects,
and
you
can
access
their
fields
in
a
simple
way
later.
It
will
all
be
smoothed
out.
B
B
B
We
just
had
our
first
back
end
implemented
and
we
made
a
front
end
up
for
it
and
it
can
implement
these
slash,
go
comment
of
our
chat
and
you
can
start
from
right
from
there.
You
can
start
developing
your
app
right
from
there
and
give
a
few
customizations.
You
can
already
hit
those
bounties.
The
first
two
just
don't
just
be
sure
to
customize
your
apps
to
do
something
different,
not
copy
paste.
The
existing
code.
C
B
B
B
B
B
That
so
now
we
have,
we
will
have
an
application.
That's
called
url
downloader
that
uses
curl
to
download
something
from
internet
some
file,
and
we
will
use
local
storage
to
write
that
file
to
the
disk
all
right,
and
that
makes
two
web
assembly
modules,
and
we
will
have
the
second
webassembly
modules
to
provide
the
public
api
to
glue
those
two
modules
together.
B
B
B
It
sets,
creates
a
path
and
it
will
always
write
all
files
to
the
same
directory.
This
is
for
simplicity
purposes,
and
then
we
just
write
file
content
to
the
file
system
and
that's
it
and
we,
if
we
have
an
error,
we
return
it
as
a
string.
You
can
obviously
define
your
own
structure
with
different
fields
to
return
error
as
a
separate
field,
as
you
would
do
in
rust.
But
here
we
return.
It
is
a
simple
string
and
if
everything
is
okay,
then
we
return.
Okay,.
B
B
It's
not
the
best
way
to
approach
error
handling,
but
it's
for
simplicity
for
for
simplicity
purposes.
It's
really!
Okay!
We
will
see
the
error
we
will
so
it's
gonna
be
working
for
now,
but
you
can
approach
that
differently.
You
can
use
your
you,
your
favorite
rust
patterns
here,
except
you
can't
use
enough
right
now,
but
the
fc
macro
doesn't
support
them,
but
everything
is
still
expressible
in
terms
of
structures.
B
So
our
up
here
it
won't
be
much
distributed.
It
will
be
a
single
app,
but
we
will
later
see
how
to
make
it
a
distributed
application
and
compose
different
modules
as
different
services
in
the
single
application
through
airscript.
But
first,
let's
start
with
a
simple
approach
where
we
have
all
these
modules
linked
together.
B
B
B
The
thing
that
I
didn't
tell
you
yet
about
fluence
applications
is
that
you
can
have
only
a
single
module
to
be
publicly
available.
That's
for
security
reasons,
and
for
you
know
for
designing
reasons.
When
you
design
some
service,
you
want
to
provide
nice
api
to
your
users.
You
don't
want
to
show
all
api
uncontrollably
right.
You
want
to
have
some
control
over
it
and
the
facade
module
it
gives
a
control
of
it.
So
only
single
module
has
its
api
publicly
available.
B
So
we
have
two
api
functions.
First,
one
is
named,
fancily
get
and
save,
and
it
basically
returns.
Okay,
if
ever,
if
the,
if
the
file
was
saved
so
first
it
accepts
url
and
file
name,
so
it
downloads
contents
of
the
file
or
site
or
whatever
through
the
curl
returns
result
and
the
result
is
saved
to
a
file.
There's
a
file.
B
So
here
you
can
see
that
we're
using
the
same
as
the
out
field.
That
was
before
that's
because
we
are
using
external
binder
and
if
it's
not
successful,
if
download
is
not
successful,
we
return
error
and
we
will
log
error.
This
log
message
will
be
seen
through
fc
repo.
If
you
develop
your
services
on
fc
repo,
you
will
see
this
work
message.
B
B
B
B
The
difference
is
that
it
returns
a
result
as
bytes,
not
as
string
so
okay
and
here,
and
we
link
the
curl
adapter
to
the
facade
module
in
almost
the
same
way
as
we
did
with
mounted
binaries,
but
with
this
crucial
difference
that
instead
of
specifying
host
here,
we
specify
the
webassembly
module
name
here
and
the
same
with
local
storage.
We
specify
local
storage
module
name
and
we
say
that
we
want
to
use
get
function
with
the
name
file
get
we
want
to
use,
put
function
with
the
name
file
put
and
that's
it.
B
B
B
The
only
difference
is
that,
instead
of
previously,
we
had
this
function
request
and
it
was
stringifying
the
results.
So
it
was
trying
to
convert
std
out
or
is
to
the
error
from
byte
array
to
string
the
download
function.
It
doesn't
do
that
for
performance
reasons.
Obviously
you
don't
want
to
to
convert
bytes
to
strings
with
no
reason
it's
handy
for
returning
to
the
front-end
strings,
but
between
modules,
it's
more
makes
more
sense
to
to
return
bytes.
C
B
Is
the
same
module
as
before
it
has
the
curl
mounted
binary
with
it?
So
it
has
to
have
configuration
file
for
that
module,
and
we
can
see
that
we
have
this
configuration
file
for
curl
here
and
it's
the
same
as
before.
It
specifies
mounted
binaries
and
let's
take
a
look
at
the
configuration
file
for
a
module
local
storage,
it's
different
for
some
funny
reason:
it
has
mounted
binaries
here,
it's
it
makes
no
sense,
they
don't
break,
it,
doesn't
break
anything
and
it
just
it.
B
B
B
B
B
B
B
B
Okay,
that's
good!
That's
that's
a
good
conversation.
We
have
there.
So
we
what
just
happened.
We
have
built
the
project
in
the
free
wasn't
files.
If
I
were
to
write
here,
I
will
see
what's
impossible,
it's
more
than
free
because
they
build
sh.
It
builds
files
like
here
and
then
copies
them
to
artifacts,
folder
or
well,
it's
more
handy-dandy.
B
B
B
Thanks
well
so
we
can
also
deploy
the
service.
I
will
spare
myself
from
doing
that
to
save
time,
but
it's
anyway,
we
can
call
it
from
cli
the
same
way
as
we
were
calling
the
previous
service.
Let's
review
the
script
for
the,
so
I
just
executed
download.air
script
here
with
service
id
specified
to
some
previous
build
service.
B
I
can
deploy
again
and
use
this
new
service
id
and
it
will
work
so
what's
inside
doing
what
it's
this,
it
says
that
go
to
relay
call
this
service
call
the
function,
get
and
save
pass
there
url
to
logo.
Here
I
short
shorted
it
just
for
gravity,
save
it
as
logo.
Dot
svg
then
go
to
the
service
and
call
call
function,
load
file
and
read
file
from
log
svg,
put
it
to
variable
name
bytes
as
a
base,
64
string
and
return
to
the
client.
B
If
it
would
be
in
like
a
jpeg,
you
can
compress
it
and
return
compressed
files
all
in
the
network,
all
without
returning
responses
to
the
client
until
the
very
end,
if
you
need
you
can
avoid
returning
bytes
to
the
client
whatsoever,
you
can
just
take
bytes
from
the
file,
compress
it
and
upload
to
s3.
If
you
are
to
write
s3
adapter
confirms,
please
do
no
one
has
done
that
yet.
So
that's
a
good
idea
to
have
a
storage,
s3
storage
engine
available
to
code
from
fluence.
B
Okay,
everything
of
this-
I
already
showed
you
in
the
code,
so
the
interesting,
the
most
interesting
part
as
we
are
approaching
through
two
hours
already,
and
I
still
haven't-
came
to
authorization
so
composition.
Imagine
that
we!
So
what
we
did.
We
have
linked.
Three
was
modules
together
to
make
a
single
service.
Was
it
required?
No,
you
could
easily
for
your
friend,
develop
a
local
storage
service
and
deploy
it
and
you
deploy
qr
adapter
service,
develop
and
deploy,
and
then
you
can
compose
this
to
services
here.
B
I
have
an
example
script
of
how
to
how
to
deploy
this
as
separate
services.
So
here
we
build
was
web
assembly
files.
We
don't
use
facade
anymore
because
we
deploy
first
local
storage
and
the
local
storage.
That
was,
it
will
be
the
first
8
module.
It
will
be
the
module
that
faces
the
public
api,
that's
available
to
call
from
script
and
we
deploy
curl
adapter
in
the
same
version.
So
this
is
the
single
module
in
the
service
before
it
was
a
service
of
three
webassembly
modules.
B
B
It
didn't
change
much
the
discrete
it's
almost
the
same,
but
before
you
were
using
this
api
and
then
load
file
now
you're
using
the
api
of
specific
modules,
you
call
you
call
curl
download
to
get
contents
as
bytes
and
you
pass
those
bytes
to
storage,
put
the
same
thing
that,
let's
take
a
look
at,
let's
take
a
look
at
the
facade
module,
but
it's
here.
No,
no!
B
B
Look
here
we
have
this
get
and
save
function
right.
What
it
does
it
calls
download
on
curl
module.
Then
it
calls
foot
on
the
local
storage
module
we're
here.
We
here
doing
same
thing,
download
and
put
and
then
get
the
same
as
we
were
doing
through
load
file
before,
but
now
anyone
can
reduce
the
curl
service
and
storage
service
for
their
purposes
right
and
it
didn't.
They
changed
much.
We
split
our
kind
of
monolithic
service
in
term
more
in
the
smaller
parts
and
provided
them
as
a
separate
apis.
B
Isn't
it
awesome?
You
could
do
the
same
if
you're
working
at
the
company
and
you
have
developed
some
api
over
s3
or
over
media
or
whatever,
and
you
can
give
other
people
access
to
it
through
the
webassembly
adapter
that
will
simply
call
it
through
curl
or
through
locally
mounted
binaries.
If
it's
whatever
you
can,
you
can
give
other
people
access
to
your
api
on
the
same
product.
B
So,
if
a
lot
of
imagine
if
a
lot
of
people
develops
a
lot
of
services
and
you
can
compose
all
of
them,
imagine
if
spotify
gives
you
access
to
your
listing
history,
and
you
have
a
service
that
some
ai
service
that
can
consume
that
history
and
give
you
back
some
analysis
of
it.
You
don't
need
to
have
api
integrated
into
the
service.
You
just
have
to
know
the
format
that
ai
service
understands
and
how
to
convert
spotify
format
to
there.
B
You
could
express
that
conversion
of
formats,
for
example,
from
json
to
xml
or
something
as
a
webassembly
service,
and
you
can
deploy
it
and
others
can
use
it,
and
you,
you
have
deployed
a
small
web
assembly
service
that
all
it
does
is
converts
data
from
spotify
to
some
analysis,
preference,
music
analysis,
service
format,
and
now
not
only
you
can
enjoy
the
analysis
of
your
musical
preferences.
Anyone
can
isn't
it
just
amazing.
B
B
Yeah,
so,
okay-
maybe
my
previous
words
about
anyone
having
access
to
any
ap
frightening,
because
you
know
if
anyone
can
call
the
storage
put
api
on
my
computer.
I
wouldn't
be
really
happy
about
it
because
one
morning
I
get
up
and
I
see
a
terabyte
file
put
into
my
macbook
and
it
has
not
so
much
gigabytes
left
there
and
I
have
no
free
disk
space
and
it's
one
way,
and
it
could
be
worse
worse
than
that,
so
we
have
to
protect
our
apis.
We
have
to
manage
the
authorization.
B
B
Chat
but
okay,
I'm
I'm
gonna,
do
it
too
far.
So
the
first
thing
every
service
internally
has
an
access
to
this
function.
You
can
always
call
get
call
parameters
from
any
service
in
any
function
and
you
will
get
security
metadata
that
will
contain
information
about
whoa
whoa.
Why?
Where
something
happened
and
everything
scrolled,
you
will
have
information
about
who
sent
the
request.
That's
in
your
parade,
you
need
period.
As
we
see
in
person,
science,
you
will
be
able
to
know
who
has
created
the
service,
who's,
the
service
creator
or
owner
and
for
example.
B
B
The
id
of
the
service
creator,
so
you
can
know
who
created
the
service
the
id
of
the
current
peer
that
hosts
this
service.
So
it's
basically
the
idea
of
the
node
that
you
have
deployed
the
service
to
current
particle
id
for
duplication
of
requests
for
to
be
able
to
implement
exactly
once
semantics,
for
example,
to
be
able
to
make
idempotent
queries
and
stuff
and
the
most
crucial
most
interesting
part
is
tetraploids.
B
B
To
other
function,
would
you
believe
it
like?
If
someone
gives
me,
I
am
an
o,
I
am
the
owner,
equals
true
and
there's
the
authorization,
no,
because
that
data
could
be
easily
hijacked
right.
Anyone
can
emit
a
true
result
into
script.
I
can
put
true
in
the
data
and
just
feed
here,
a
true
value
without
going
to
his
own
revolt
code
without
calling
his
owner
function
here,.
C
B
B
Okay,
I
have
20
minutes
left.
I
will
do
in
20
minutes
so
here
where
tetraploids
come
into
play.
So
for
each
argument,
that's
pass
that
is
passed
to
the
as
an
argument
or
function.
For
example,
we
want
to
extend
storage,
put
with
check
of
authority
to
check
that
the
only
owner
can
write
files
to
the
file
system,
for
example.
B
Then,
when
we
do
this,
when
we
call
put
function
with
just
three
values
for
these
three
arguments,
the
following
happens
with
each
of
the
argument:
we
have
a
corresponding
security
catalog.
So
for
each
of
these
values
we
will
have
a
single
checker
plan.
That
say
says
where
this
value
comes
from
from
what
node
from
what
service
from
what
function,
and
was
it
modified
in
any
way
by
jsonpath?
B
B
So
inside
is
authenticated.
We
get
the
security
net
information,
we
get
the
first
tetraploid
for
we
know.
The
first
argument
to
the
function
is
owner
is
ordinary
and
we
check
that
this
tetraplate
is
correct,
but
it's
a
correct
service
id.
It
has
correct
function,
name
and
it
has
no
json
path
applied
to
it.
B
So
it
uses
the
the
following
logic:
almost
the
same
logic,
to
authenticate
users,
so
only
owner
of
the
service
can
add
users
to
that
editor
right.
It
makes
sense.
If
I
don't
want
anyone
to
do
anything
with
my
text
that
I
myself
deployed,
and
I
edit
it
with
my
friend-
I
don't
want
anyone
to
interfere
with
that.
A
B
Five
minutes
great,
so
I
will
do
that
in
five
minutes.
Okay,
so
go
to
flintpad
services
with
me:
follow
it
and
deploy
services
on
your
own
and
see
how
it
works.
You
will
see
that
in
order
to
use
the
fluentpad
app,
you
have
to
first
set
chatter
plan.
So
as
an
owner
of
the
frame
part
as
one
who
deployed
you
have
to
say
to
it,
in
which
data
to
trust
which
json
path
to
trust
which
function
is
correct,
which
service
is
okay
and
so
on?
B
B
So
if
you
are
to
use
a
wrong
json
path,
for
example,
you
will
have
the
following
error:
that
jsonpath
was
expected
to
be
like
that,
and
jsonpath
actually
was
like
that.
So
if
data
is
forced
from
some
in
some
way
or
it
comes
from
a
different
source
that
you
didn't
allow,
it
will
fail,
you
can
check
against
it.
You
can
change
check
the
authenticity
of
the
data.
It's
original,
it's
kind
of
like
across
a
region,
request
policy,
that's
what
we
were
inspired
by.
So
it's
kind,
it's
kind
of
like
that.
B
That
shows
all
the
services
running
on
the
nodes.
Well,
on
the
testnet,
we
have
documentation
here
that
overuse
the
language.
It
overviews,
how
to
develop
services,
how
to
launch
your
unknown
the
structure
of
the
language.
What
built-in
services
you
able
to
use
there
are
plenty
of
them
yeah.
It
talks
about
the
authorization
in
detail
and
explains
different
things.
It
has
extra
resources
with
youtube
talks
and
stuff.
B
It
has
links
to
our
telegram
to
our
discord,
to
the
dashboard
and
to
discussions
on
github.
Please
use
it.
It's
a
really
nice
way
to
to
discuss
and
to
share
your
knowledge
to
reduce
knowledge.
Your
usage
is,
there
is
a
point
of
difference.
So
here
is
the
dashboard.
Dashboard
connect
contains
a
few
of
the
future
blueprints
which
shows
nodes
that
are
in
the
test
net.
You
can
see
that
I
was
saying
that
the
third
node
is
the
most
used
one.
You
can
see
that
it
has
almost
400
services
deployed
into
it.
B
A
Awesome,
thank
you
very
much
alexi
and
for
the
rest
of
the
fluence
team
for
helping
out
with
the
the
questions
in
chat
as
well
yeah.
This
video
will
be
going
live
on
the
youtube,
so
hello
to
everyone
still
watching
on
youtube,
and
that
should
be
up
tomorrow.
I
guess
just
to
round
off.
We
have
obviously
the
stellar
event
on
friday
evening,
starting
at
the
same
time
as
this
one
did
and
then
a
couple
more
events
next
week,
including
a
general
introduction
to
blockchain
the
skynet
workshop
and
the
vega
workshop.