►
Description
00:00 Intro by Connor O’Day, GitCoin
00:12 Intro by Bernhard Borges, Fluence Labs
00:40 What is Fluence
02:02 How does the Fluence network operate
03:22 How to program services with Aqua
06:51 Aqua code in a nutshell
09:59 Particle — the core of the Fluence model
14:31 Use cases of storing and deploying Fluence services with Aqua and IPFS
16:29 Creating and deploying a service
28:37 Creating blueprint using Aqua
35:24 Q&A: is Aqua a different language? Aqua language overview
38:59 Q&A: is Fluence something like Kubernetes?
42:41 Q&A: how does Fluence solve gas halting problem?
47:10 Bounties presentation for GR11 hackathon
Open bounties https://gitcoin.co/hackathon/gr11?org=fluencelabs
Fluence documentation https://doc.fluence.dev/docs/
Aqua book https://doc.fluence.dev/aqua-book/
Fluence Devcontainer https://github.com/fluencelabs/devcontainer
Fluence IPFS Adapter https://github.com/fluencelabs/aqua-ipfs
Discord Support https://fluence.chat/
Book A Meeting With The Team https://calendly.com/fluencehack/
Original video: https://youtu.be/3TpchfzEtyE
Speaker: Bernhard Borges, Fluence Labs
A
All
right
cool
and
I
think
we're
live
so
what's
up,
everybody
welcome
to
the
first
sponsor
workshop
that
we're
doing
for
the
grants
round.
11
hackathon,
I'm
here
with
bernard
from
fluence,
we're
going
to
be
talking
a
bit
about
their
bounties,
their
their
tech
and
ipfs
and
aqua
and
some
other
fun
stuff.
So
just
let
me
send
out
a
quick
alert
for
people
to
join
the
session
here
and
yeah.
I
guess
bernard
I'll
watch.
You
know
if
you
guys
have
questions
out
there.
I
I
can.
A
B
A
B
What's
going
to
be,
obviously
a
super
amazing
hackathon,
so
a
little
bit
about
fluent
fluency
is
is
a
permissionless
and
secure
peer-to-peer
protocol
and
the
protocol
really
focuses
on
compute
and
as
part
of
the
fluent
solution,
we
have
a
network
with
a
stack.
We
have
a
network
and
a
bunch
of
open
source
tooling,
and
that
bunch
of
open
source
tooling,
is
something
we
really
need
to
talk
about
during
the
workshop.
B
The
way
the
addressability
of
those
module
works
is
actually
you
link
them
and
you
link
them
into
logical
constructs.
We
call
services
and
those
services
despite
being
highly
sandboxed,
as
web
assembly
modules,
actually
can
execute
external
effects,
so
you
can
download,
uplight
modified
replicate
and
you
actually
can
use
http.
B
B
With
those
services
you
actually
can
create
connections
or
adapters
to
services
already
available
outside
the
fluence
peer-to-peer
network.
So,
for
example,
ipfs
comes
to
mind
any
microservice
you
can
think
of
and
any
api
that's
out
there.
You
can
basically
wrap
and
bring
into
the
peer-to-peer
network
flow.
B
The
way
you
program,
services
in
influence
is
with
a
purpose-built
language
called
aqua.
Now
before
we
go
any
further
there.
Let
me
okay,
see
if
you
look
at
the
right.
This
is
a
teeny
weeny
little
pdp
network
and
it's
got
the
two
clients,
the
green
ones,
which
could
be,
and
then
a
bunch
of
peer-to-peer
nodes
and
those
nodes
host
services,
one
or
more
could
be
any
one
or
more
a
relay
by
the
way.
It's
just
a
node,
that's
publicly
accessible.
B
B
Services,
yes,
so
we
have
the
services
one
more
really
notice
is
something
that's
publicly
accessible,
because
not
all
nodes
actually
are
publicly
accessible.
It
could
be
behind
that,
so
it
could
be
a
browser.
Browser
itself
is
not
directly
accessible
as
a
peer
has
to
go
through
a
relay,
and
if
we
look
on
the
on
that
continue
with
there,
one
of
the
services
is
a
representative
of
an
adapter
service
that
links
you
to
all
those
other
services
available.
A
B
B
B
So
you
can't
really-
or
you
don't
really
want
to
use
json
rpc
for
that
you
don't
want
to
use
your
traditional
rest,
endpoint
approaches
to
it,
because
it's
peer-to-peer
it's
highly
distributed
and
in
peer-to-peer
networks,
as
you
probably
know,
notes,
disappearing
or
going
away
for
brief
or
even
longer
periods
of
time
is,
is
more
the
rule
than
the
exception.
So
it
is
expected.
Actually,
so
you
need
a
lot
of
flexibility
in
how
to
resolve
routes
throughout
the
network
and
it
needs
to
be
dynamic,
and
this
is
where
aqua
comes
in.
B
Aqua
is
a
purpose-built
language
for
distributed
systems,
in
particular
peer-to-peer
systems,
and
it
allows
you
to
basically
capture
those
services
on
the
right
through
a
very
high
level,
language
that
really
unburdens
the
developer
from
a
lot
of
the
treasury
of
peer-to-peer
programming
and
allows
you
to
propose
the
services
into
applications.
And
if
you
do
it
right
as
a
developer,
actually
decentralized
applications,
it's
all
open
source
and
we
believe
it
really
is
going
to
commoditize
peer-to-peer
programming.
B
B
However,
it's
a
fancy
one.
It
not
only
takes
a
name;
it
actually
takes
a
boolean
as
well,
and
we
see
this
in
the
greeting
function,
so,
basically
the
output,
the
expected
output
of
this
greeting
function
is
where
the
string
is
for
the
name
and
the
boolean
is
for
what
we
call
the
greek
variable.
If
the
boolean
is
true,
it's
as
high,
if
the
bullying
is
false,
it
says
spy
and
the
string
is
whatever
the
name.
So
we
get
high
conor
by
conor,
something
like
that
and
in
those
first
two
lines.
B
Those
are
the
service
bindings,
it's
basically,
if
you're
coming
from
blockchain,
if
you've
done
any
work
in
solidity,
you
can
think
of
it
in
an
analogously
as
a
api,
and
basically
it
allows
you
to
bind
that
interface
to
the
remote
interface
and
then
start
executing
the
associated
functions.
So
right
now
there's
only
one
greeting,
but
there
could
be
10
that
could
be
20.
There
could
be
5,
it
doesn't
really
matter.
B
Then
the
next
function
lines.
Fourth
rate.
This
is
actually
the
aqua
function
that
composes
that
service
into
something
useful,
and
here
we
start
bringing
in
the
topology
of
the
service.
So
if
you
look
to
the
last
two
arguments
in
the
function,
signature
node
and
greeting
service
node
is
basically
the
peer
id
of
the
host
for
the
service,
which
is
identified
by
a
unique
greeting
service
id.
B
So
basically,
what
we're
saying
here
is
on
that
node
on
this
particular
peer
specified
up
there
in
that
function.
Signature
we
bind
our
greeting
service
to
that
already
available
service
through
its
service
id,
and
then
we
execute
through
that
binding
the
actual
function
with
our
name
and
greet
arguments,
and
then
we
get
a
result
and
then
we
push
this
result
back
to
the
client.
Now,
if
you
look
in
the
upper
right,
you
see
a
sequence
diagram.
Basically
what
so
the
client
could
be
a
browser
right.
It
could
be
very,
very
thin,
iot
device.
B
It
could
be
just
about
anything
and
it
connects
to
the
a
relay
node
and
then
on
that
relay
node.
We
determine
how
we
need
to
call
that
service.
What
needs
to
be
done
so
the
execution
initially
of
this
script.
If
you
go
back
to
lines
four
through
eight,
it's
not
on
the
actual
network
node,
it
actually
happened
on
the
relay
node
and
then
it
pushes
it
forward
and
then
on
whatever
node
we
have
that
service
hosted,
we
start
executing
it,
and
then
we
get
results
back
while
really
back
to
our
client.
B
So
the
question
you're,
probably
gonna-
all
ask
yourself
now-
is
how
the
hell
is
that
gonna
work.
How
does
this
happen?
How
do
you
make
this
work
and
there
is
a
part,
a
foundation
part
that
probably
helps
to
understand
if
you
want
to
work
with
fluence,
which
we
all
hope
you
will-
and
this
is
called
a
particle.
B
A
particle
is
fundamentally
a
data
structure,
a
conflict,
replication
data
structure
that
combines
data
and
execution
sequence
and
some
metadata
which
we
can
ignore
for
right
now
the
execution
sequence
is
really
important
and
this
is
basically
the
compiled
aquascript.
So
if
you
think
you
program
you,
this
is
your
aqua
here
and
now
we
compile
that
into
what
we
call
air.
It's
the
aqua
intermediary
representation,
but
you
can
think
of
it.
B
It's
not
my
code,
it's
actually
a
very
lisp-like
code,
but
you
can
think
of
it
as
by
code
if
you
want
to-
and
that
basically
is
part
of
this
particle
and
what
happens
is
that
on
every
node?
Aside
from
the
marine
runtime
that
executes
webassembly
modules
through
the
linking
into
a
service,
we
also
execute
the
particle
solution.
B
In
a
traditional
model,
client
server
model,
you
have
a
request
response
model,
it's
sort
of
end
to
end
right,
there's
an
api,
you
get
result
back,
you
do
something
with
it
or
not,
and
you
just
push
it
on
to
the
next
service
and
do
some
of
our
api
and
do
something
with
that
blah
blah.
So
if
you
want
to
put
this
in
more
context,
let's
just
say
you
have
a
customer
and
let
me
just
go
back
real
quick.
B
Let's
say
you
have
a
customer
for
which
you
have
to
do
a
credit
check
and
what
you
then
want
to
do.
Is
you
want
to
notify
the
customer
with
an
sms
message
message
of
the
credit
check
so
in
the
traditional
client
server
environment?
What
you
would
do
you
would
use
your
rest
point
endpoints
and
you'd
probably
go
to
stripe,
check
or
whatever,
and
then
you
get
the
result
back
to
your
client
and
now
you
push
that
result
into.
B
I
don't
know
tool
io,
for
example,
and
then
that
the
sms
message
gets
in
and
you
close
the
loop
with
the
client
in
peer-to-peer
in
particular
fluence
peer-to-peer
programming.
This
is
not
really
how
you
want
to
do
it
and
back
on
the
right
side.
The
way
the
direction
of
those
are,
what
you
want.
What
you
would
want
to
do
is
you
would
have
a
service.
Let's
just
say
that
first
service
here
is
our
stripe,
call
which
could
be
one
of
those
apis.
B
Your
load
on
the
client
is
very
becomes
very,
very
small.
You
really
enable
very
thin
clients
and
I'm
not
necessarily
on
a
browser
or
a
mobile
phone.
These
days
is
a
thin
client,
but
a
lot
of
edge
edge
devices
are,
and
you
can
really
enable
a
lot
through
small
devices,
thin
clients
with
this
kind
of
request
response
model,
and
this
is
why
peer-to-peer
to
a
certain
extent
is
really
sort
of
growing
a
lot
interesting,
because
it
allows
exactly
that.
B
Onto
the
network,
all
right,
let's
go
back
forward.
All
this,
of
course,
is
the
particle
particle
is
so
you
have
for
chaining
data
movement
model.
If
you
will
combines
the
data
updates
and
the
and
the
execution
steps
you
basically
and
at
the
end
up
at
the
end
of
the
script,
so
from
the
to
the
little
bit
more
applied.
B
B
B
All
right,
so
the
first
thing
I
said
we
want
to
do:
we
wanted
to
create
a
a
service.
So
let's
just
have
a
look
at
servers,
so
services
are
comprised
of
web
assembly
modules
and
only
in
this
case,
right
now
is
created
in
rust
and
basically
it's
your
basic
rust.
There
is
nothing
super
fancy
you
don't
have
to
use
lifetimes.
B
So,
basically,
what
we're
having
here,
we're
creating
a
module,
and
this
module
basically
calculates
the
size
of
a
file
where
the
file
comes
from
a
file
path.
Great,
nothing,
no,
no
big
deal
right.
So
the
only
interesting
part
here,
not
the
only
but
the
most
interesting
part
here
is
that
macro.
It's
called
marine
and
basically
what
it
does.
It
allows
you
to
turn
that
dress
code
into
webassembly
code
and
it's
wazi32.
B
B
So
we
have
a
build
script
for
this
and
I'm
just
going
to
quickly
go
through
it.
So
basically,
what
we're
doing
is
we.
This
is
the
most
important
part
here
we
use
marine,
which
is
a
fluence
tool
that
extends
the
rust,
compiler
and
rust,
and
cargo
to
allow
the
web
assembly
compilation
for
our
compiled
target,
and
then
we
do
some
stuff
in
terms
of
moving
things
around.
So
it's
a
little
bit
more
accessible.
B
B
B
File
and
and
compile
target
so
okay,
so
now
we
have
in
in
the
in
that
directory
artifacts,
we
have
actually
our
file.
This
is
what
we're
looking
at.
This
is
what
we
wanted,
and
this
is
what
we
want
to
do
something
with
now.
I
told
you
we're
going
to
take
this
this
file
and
what
we
want
to
do
is
we
want
to
put
this
on
ipfs
and
then
we
want
to
use
aqua
to
you
access
ipfs
and
do
something
with
this
file,
which
basically
means
we're
gonna
calculate
file
sizes.
B
B
B
Okay,
this
is
the
file
we
we
created.
This
is
our
web
assembly
file.
This
is
the
one
we
want
to
use
we
wanted
to.
We
want
to
put
that
on
on
ipfs-
and
I
already
done
this
before,
but
I'm
gonna
do
this
again.
So
you
know
there
is
no
cheating
going
on
it's
all
like
real
and
live,
and
a
total
high
wire
act
and
no
net
and.
A
A
A
B
B
B
We
have
have
the
service
deployed
and
this
is
our
service
id
and
it's
it's
on
that
particular
peer,
which
also
happens
to
be
the
relay
and
what
we
want
to
do
now.
The
web
assembly
module,
if
you
remember
correctly,
was
we
were
actually
calculating
your
file
size
right.
So
what
we
can
do
now
is
we
can
actually
okay.
B
We
get
our
cid
right
for
that
file,
so
now
we
can
go
back
to
this
little
thing
and
say
we
want
to
get
the
file
size
and
now
we
have
to
put
in
the
new
cid
and
now
the
very
service
we
originally
used
put
on
ipfs
and
then
uploaded
is
now
calculating
the
file
size,
and
I
hope
you
see
the
result,
and
we
can
double
check
that
from
the
here.
It
was
116,
bytes
and
guess
what
it
calculated
160
bytes.
B
So
what
we
just
it
is
we.
Basically
we
have
a
fluence
node.
We
sidecar
that
fluence
node
with
an
idfs
node.
We
use
the
local
ipfs
desktop
to
to
store
webassembly
module
that
we
created
in
rust.
We
deployed
that
to
that
peer
up
here,
and
then
we
used
that
service
right
after
deployment
to
calculate
the
file
size
of
an
arbitrary
ipfs
content.
Addressable
file,
that's
what
we
just
did
and
we
got
the
result
right
here
now.
This
is
all
nice,
but
the
what
matters
is
how
it's
done.
B
B
So
when
you
write
code
in
aqua,
you
have
the
option
of
actually
of
compiling
the
file
either
into
the
raw
air
file
or
actually
have
it
wrapped
for
you
ready
to
go
as
a
typescript
file.
So
it's
super
easy
to
use,
and
this
is
our
aqua
file.
So
we
have
a
bunch
of
aliases.
Basically,
purity
is
a
string
content.
B
Now
I
told
you
before
that.
Basically,
services
are
logical
constructs
and
the
way
this
happens
is
that
the
web
assembly
modules,
where
wasmit
is
nothing,
is
shared
between
it's
a
no
share
environment
but
they're
linked.
They
can
be
linked
through
configuration
files
and
those
those
linkages
and
those
dependencies
are
defined
in
what
we
call
a
blueprint,
and
this
is
the
way
to
create
a
blueprint
using
aqua.
Again,
it's
like
four
lines
and
basically
what
that
allows
you
to
do.
B
This
is
what
we're
gonna
get
we
get
it
from
up
here
and
then
we
use
it,
and
now
we
use
some
built-in
pro
built-in
services
that
are
already
deployed
on
network
to
access
our
our
process
files.
This
is
the
very
very
here.
Let
me
just
go
back
to
to
show
it
to
you
in
the
code
here.
This
is
this:
is
the
process
aqua,
and
this
was
the
file
size,
and
this
is
what
we
called
right
here
where.
B
We
created
the
service
and
and
calculate
the
file
size,
and
then
it's
just
basically.
If
the
file
says
it's
successful,
we
do
something
here.
It's
called
code
log
size
code
means
routine
and
log
size
basically
is
a
callback.
It's
in
aqua.
We
call
it
an
error
function,
but
it's
literally
a
callback
that
allows
us
to
update
actually
the
browser
with
that
result,
as
we
were,
as
we
keep
continuing
with
some
other
execution
processes
and
then
at
the
end
you
actually
can
remove
the
servers.
B
A
B
B
B
And
that
allows
you
to
inspect
and
even
interact
with
your
with
your
wasm
services
locally
before
you
deploy
them
and
all
I
wanted
to
show
you
is.
Basically,
this
is
directly
from
the
webassembly
module
on
my
local
machine,
and
these
are
the
data
structures
and
the
functions
we
that
are
exposed
in
the
webassembly
module
for
consumption
and
since
copy
and
paste
is
just
so
sad
right.
We
actually
have
the
ability
to
export.
B
B
A
B
A
B
B
Is
that
visible
okay,
so
we
got
an
entire
book
on
aqua
and
basically,
what
it
basically
is,
is
it's
a
very
it's.
It's
super
effective
in
doing
one
thing,
basically
unburdening
developers
from
having
to
deal
with
routes
and
general
topology
issues
in
order
to
resolve
services
as
you're
programming,
these
systems,
and
it
should
be
look
fairly
familiar.
This
I
mean
this
is
this
is
how
you
define
a
struct,
or
you
know,
a
data
structure.
B
What
I'm
highlighting
in
okay,
this
is
intermediate
representation,
and
this
is
what
gets
executed
on
the
aqua
virtual
machine.
So
a
very
long
answer
to
a
probably
not
that
deeply
meant
question.
Yes,
it's
a
different
language.
It's
a
new
link,
it's
a
fairly
new
language.
I
think
we
released
it
march,
maybe
april
we've
had
air
before,
but
aqua
air
is,
as
you
can
see,
anybody
who's
ever
done
anything
else.
B
With
this
black
language
and
even
with
code
completion
wrangling,
those
brackets
and
semi
brackets
is
such
a
utter
pita
that
aqua
really
abstracts
over
this
and
makes
it
like
really
really
nice
to
get
a
lot
of
things
done
up
until
aqua.
You
had
to
write
in
in
air
and
even
though
it's
actually
kind
of
neat,
it's
it's
it's
just
it's
wasted
time
compared
to
aqua.
A
B
The
point-
and
I
probably
should
have
brought
this
up
earlier-
the
whole
point
of
fluence
is
that
it
is
highly
decentralized.
There
is
no
no
brokers
out
there,
no
common
brokers
in
there
and
the
and
basically
you
can
look
at
it
as
an
alternative
to
a
variety
of
solutions,
including
some
of
the
big
cloud
providers
who
provide
open
source
solutions
which
we
feel
benefits.
Those
providers
a
lot,
but
the
open
source
contribution
community
not
at
all-
and
this
is
sort
of
sort
of
philosophically.
B
So
you
add
a
node.
You
actually
have
capabilities
that
you're,
not
replicating
you're,
not
replica
you're,
not
strengthening
the
consensus,
you're,
strengthening
the
execution
capability
of
the
network
that
that's
really
where
it
is
so,
and
so
I
I
mean
I
have.
I
have
said
something
like
it's
infinitely
scalable.
It's
obviously
not
infinitely
scalable,
but
it's
highly
scalable
and
without
a
lot
of
sharding
and
one
thing
we
don't
have
right
now,
but
that's
coming
soon
is
subnetworks
and
that
really
gives
you
sort
of
a
shorting
like
capability
to
carve
out
entire
network
sections
and.
B
And
in
that
sense
it's
totally
different
from
kubernetes.
However,
the
way
you
manage
resources
there's
a
certain
analogy.
I
think
that
you
can
look
at
it
to
to
sort
of
capture
your
knowledge
or
transfer
your
knowledge
into
into
a
new
domain
and
and
understand
what's
going
on,
but
it's
it's
it's
it's
not
like
humans,
but
there
are
aspects
of
it
did
that
answer
the
question.
A
A
B
B
A
big,
a
big,
highly
capable
node
that
allocates
a
lot
of
resources,
obviously
probably
going
to
expect
different
payment
than
a
smaller
one,
but
that's
up
to
the
interaction
between
the
node
operator
and
the
service
provider
and
possibly
the
application
developer.
So
you
have
you,
have
this
intersection
and
in
many
respects
it's
not
different.
B
Our
cloud
operator
works
because
you,
basically
you
pay
for
the
resources
you
consume
and
that's
it
and
different
cloud
operators
have
different
models
to
do
it.
So
it's
it's.
As
I
said,
it's
not
a
blockchain
and
and
so
why
I
love
the
evm,
use
gas
metric.
It's
one
of
my
favorite
things.
It's
not
as
applicable
in
the
sense
that
you
have
a
finite
set
of
up
codes.
You
can
spec
out
and
then
correlate
to
some
payment
metric.
A
A
B
B
Come
on
read
me
all
right,
so
we
got
a
variety
of
prizes.
We
have
an
early
explorer
or
beginner
bounty,
which
is
super
in
my
opinion,
super
easy
to
do
and
rewards
you
literally.
If
we're
just
going
through
the
quick
start,
we
have
and
basically
what
you
want
to
do
there
is
we
want
you
to
do.
We
want
you
to
add
another
additional
service
to
the
already
existing
quick
start
services.
B
You
actually
have
to
read
that
and
look
at
it,
and
this
is
a
very
small
bounty,
but
we
have
10
of
them
for
first
10
people
to
to
do
that,
and
I
hope
you're
gonna
have
a
heck
of
a
lot
of
fun
with
it
and
anybody
even
looking
at
doing
intermediate
or
advanced
bounties.
I
think,
if
you
looking
at
that,
you
really
should
look
at
the
beginner
or
early
explorer
bounty,
because
it's
totally
worth
it
because
you're
already
reading
it,
so
you
might
as
well
get
you.
A
B
B
Those
services
for
the
most
part
are
already
built
into
the
node.
So
literally,
you
have
to
just
look
at
the
documentation
and
use
aqua
to
compose
it,
and
you
know
build
your
interface
around
it,
your
ui,
and
so
that's
that
that's
something
that's!
I
really
would
like
to
see
some
innovation
and
from
participants.
A
B
I
got
a
few
examples
for
you
guys
to
look
at
and
I
also
believe
it's
not
a
super
hard.
I
mean
it's
an
intermediate
challenge,
but
there
is
a
lot
of
room
to
really
do
something
great
and
particularly,
if
you
look
at
it
from
off
chain
extension
to
launching
capabilities.
Off-Chain
signing
is
a
big
deal.
Eip
712,
for
example.
So
there's
a
lot
that
somebody
could
do
to
distinguish
themselves
and
sack
that
price,
no
problem,
the
third
one
we're
looking
at
is.
B
We've
we've
done
some
work
with
ceramics,
it's
built.
If
you
don't
know
it,
it's
a
super
cool
abstraction
on
top
of
ipfs
and
that
basically
builds
you
an
append
log
of
immutable
changes
that
lets.
You
do
really
interesting.
Things
like
actually
create
immutable,
ntf,
nft
metadata
and
what
we're
looking
at
is
there's
multiple
ways
to
access
and
interact
with
ceramics,
and
two
of
them
are
cli
and
http,
and
those
who
we
think
are
prime
candidates
for
services
similar
to
the
ipfs
one.
B
We
have
an
advanced
bounty
and
this
is
basically
a
playground
if
your
interest
is
five
thousand
dollars.
If
you're
interested
in
this
contact
us
there's,
I
mean
I
have
a
lot
of
resources
there.
You
can
look
at
it,
but
if
I
just
this
explaining
this
would
take
more
than
the
five
minutes
we
have
left.
But
basically
we
would
like
to
see
how
aqua
can
be
created,
checked
and
and
executed
in
the
browser
like
a
traditional
playground,
and
we
have
we
already
started.
B
We
have
some
sandbox
models
for
it
you
can
use
and
as
that,
if
that's
something
you
want
to
work
on,
please
contact
us
and
we'll
work
with
you
and
make
sure
you
really
honed
in
on
the
task,
and
the
last
last
is
a
general,
more
general
use
of
any
kind
of
the
best
used
literally
of
fluent
in
your
dab
2500,
and
we
have
some
examples.
Those
are
just
examples.
You
know,
like
decentralized,
ft
creation
indexing,
you
know
I
mean
there's
increasingly
there's
the
evm
and
then
there's
compatible
evms.
B
How
do
you,
how
do
you
route
your
contract,
to
which,
if
you
have
one
contract
deployed
on
multiple
evms?
When
do
you
use
which
contract?
How
do
you
index
the
results
and
those
are
areas
we'd
be
really
interested
in
seeing
people
doing
some
experimentation
and
getting
their
feet
wet,
and
that
was
it
for
our
bounties.
I'm
super
excited
about
them
and
I
hope
you
are
too
and
that's
literally
it
from
from
my
end.
So
if
you
have
any
more
questions,
I'd
be
happy
to
answer
them.
A
A
Great
yeah,
I
see
just
dropped
that
link.
I
also
dropped
the
link
on
git
coin
to
see
all
the
the
fluence
bounties
yes
yeah.
It
looks
like
I
mean
we
just
got
started
yesterday.
It
looks
like
there's
a
few
people
doing
the
the
quick
start
one,
but
the
other
ones
are
wide
open
for
the
taking
so
definitely
go
check
them
out
and
click
start
work.
If
you
are
interested.
B
And
on
our
resources,
we,
you
can
also
book
a
calendly
and
I
do
believe
we
have
the
capability
of
providing
a
second
workshop.
So
if
somebody,
if
there
is
enough
interest
on
a
particular
topic,
whatever
just
let
us
know
or
let
the
good
folks
at
gitcoin,
know
and
we'll
try
and
figure
something
out
and
do
something
sooner
rather
than
later.
I
know
it's
a
hackathon,
so
the
badge
of
honor
is
to
do
90
of
your
work
on
the
last
three
days.
Maybe
the
last
two.
B
I
understand
that
I've
done
this
before
myself,
but
if
you,
if
you
haven't
done
anything
in
this
space,
particularly
around
fluence
and
aqua,
maybe
maybe
try
to
get
in
a
little
bit
earlier.
I
I
truly
believe
it's
gonna
be
rewarding
because
you
actually,
you
actually
are
programming
distributed
systems
you're,
not
using
other
people's
work
to
use
distributed
system,
your
program
them-
and
I
I
do
believe-
that's
a
the
next
generation
in
web3
and
anyway.
A
Yeah
absolutely
awesome.
No,
I
really
appreciate
the
presentation.
I
was
super
helpful
and,
and
you
know
in-depth
as
well-
I
don't
think
don't
see
any
other
questions
last
chance
that
there
are
but
deepak
just
said.
Thank
you,
bernard
nice
introduction
to
the
project
new
to
fluence
and
aqua,
but
he
started
on
the
quickstarter.
So
he
said
this
is
very
helpful.
All
right
cool.
B
No,
that's
that's
fine.
We
can
take
it
for
there
and,
of
course,
the
I
I
know
everybody's
doing
it,
but
maybe
there's
this
one
or
two
people
out
there
we're
hiring
if
we're
hiring
core
developers
we're
hiring
in
some
of
business
and
marketing
areas.
So
if
you
like
the
project
and
thank
you
so
much,
please
check
us
out.