►
Description
Fluence Workshop for the EthCC Hackathon July 22 - 24
The workshop provides an overview of the Fluence stack and a code review on how to use Fluence off-chain compute to decentralize blockchain gateways.
Speaker: Bernhard Borges
Participate in the hackathon via devpost https://ethcchack2022.devpost.com/
How to start hacking with Fluence https://www.notion.so/fluencenetwork/Hacking-On-Fluence-Primer-28a87754397048e1bec72e3bfc91fd9b
Fluence Documentation https://doc.fluence.dev/docs/
Aqua Book https://doc.fluence.dev/aqua-book/
Fluence Quickstart https://github.com/fluencelabs/exampl...
Fluence Examples https://github.com/fluencelabs/examples
Discord support https://fluence.chat/
Book A Meeting With The Team https://calendly.com/fluencehack/
A
Hello,
everybody
welcome
to
ecc
hack,
2022,
I'm
bernard
and
I'm
with
fluence
labs
and
we're
super
briggs
be
here
and
to
be
hacking
with
you.
This,
unfortunately,
is
a
pre-recorded
and
no
interactivity
clearly.
So,
if
you
have
any
questions
and
comments,
please
reach
out
to
telegram
discord
and
also
we're
going
to
be
there
for
the
week
in
person.
A
You've
probably
seen
sort
of
the
many
many
different
incarnations
of
this
web,
one
two
and
three
journey,
and
I
think
so-
I'm
not
gonna
get
into
too
much
detail
in
this
workshop.
But
what
the
important
part
is
that
there's,
an
evolutionary
evolution
is
driven
by
by
constraints
with
the
regulatory
market
demands
as
well
as
enabled
by
and
web
3
addresses
a
lot
of
the
the
grievances.
A
If
you
will
we've
encountered
through
web-free
business
models,
we
just
don't
think
are
particularly
fair
and
sustainable,
so
censorship
resistance,
risk
of
minimized
risk
of
de-platforming,
low
exit
barrier
control
over
your
data
control
of
your
identity.
Those
are
all
all
attributes
of
web
3
we're
looking
for
to
counteract
some
of
the
you
know,
specifically
unfair
and
concentrated
power
distribution
that
that's
currently
available
sitting
in
in
metoo
and
a
lot
of
the
web.
A
A
Well,
probably,
I
don't
think
it's
going
to
go
away,
because
if
you
look
at
all
the
efforts
from
central
banks
looking
at
digital
currency,
this
is
the
best
model
in
the
journey
of
e-money
over
the
last
30
years,
or
so
we've
seen.
And,
of
course,
it's
really
the
the
high
probability
elimination
of
double
spend
at
a
relatively
low
cost,
which,
which
is
is
super
critical.
A
However,
we
don't
just
want
to
decentralize
financial
systems.
We
actually
want
to
decentralize
a
whole
many
layers
of
the
internet
storage,
for
example.
Protocol
apps,
ipfs
filecoin
is
a
great
example
of
how
to
decentralize
storage
in
with
peer-to-peer
networks
and
to
bring
innovation
to
the
market
like
content
addressability,
which,
which
totally
changes
the
way
you
deal
with
data,
how
you
create
complex
data
models
using
ipld
and
all
that
good
stuff
and
another
aspect
is
identity.
Right
I
mean
we've
been
dealing
with
ego
of
digital
identity,
blah
blah
blah
for
a
long
time.
A
Nothing
ever
really
stuck
about.
Four
years
ago,
four
or
four
and
a
half
years
ago,
serious
work
started
to
begin
when
decentralized
identities
verify
your
credentials.
And
just
now
you
really
see
a
lot
of
coalescing
going
on.
You
see.
Efforts
like
you
can
cacao
coming
to
air
and
really
really
changing
the
way.
A
Self-Sovereign
sovereignty
is
expressed,
how
we,
how
we
can
retain
control
not
just
of
our
data
through
peer-to-peer
type
storage
like
active
spot
coin,
but
also
for
our
representation
of
our
self
and
any
other
secrets
we
like
to
represent,
but
not
necessarily
share
explicitly
through
through
non-interactive
interactions
and
another
one,
of
course,
is
decentralized.
Networking
networking
it
be
decentralized,
so
many
different
levels,
but
probably
the
most
prominent,
is
social
networks
right.
I
mean
you're
fundamentally
being
held
hostage
by
your
own
data
in
these
walled
gardens,
whether
it's
facebook
or
any
one
of
them.
A
The
people
currently
locked
into
these
small
gardens
need
to
be
able
to
get
that
data
out,
and
this
may
be
a
generational
issue
or
it
might
be
a
regulatory
issue
where
probably,
if
I'm
looking
at
it,
looking
more
towards
you
probably
to
to
force
some
of
those
volume
guard
providers
to
to
let
users
take
the
data
out
and
once
you
take
it
out,
and
you
start
looking
at
your
decentralization
perspective
and
you
build
the
rare
tools
you
actually
can
build
these.
These.
A
These
complex
data
models
very
easily
very
cheaply
on
decentralized
storage
and
now
it's
portable
and
could
be
easily
consumed
by
the
any
of
the
mastodons
or
subsequent
or
concurrent
competitors
in
the
marketplace,
and
your
data
could
be
synced
and
could
be
it's.
It's
actually
not
that
difficult
to
do
even
at
scale,
particularly
if
you
have
these
content
addressabilities
that
that
come
out
of
decentralized,
laptop
storage
and,
of
course
the
the
last
one
is
computing.
I
mean
there's
more
to
it.
A
There
are
more
attributes,
but
the
last
big
one
is
computing
is,
of
course,
where
fluence
comes
in,
so
decentralized
computing
are
different
incarnations.
If
you
will.
Most
of
you
are
probably
very
familiar
with
smart
contracts,
unchained
very
deterministic,
and
then
there
are
decentralized
hardware
marketplaces
with
one
life
period,
so
the
on
chain,
computer.
A
As
I
said,
it's
deterministic,
so
there's
a
lot
of
limitations.
I
mean
blockchains
are
fundamentally
introverts,
so
you
need
offchain
compute
to
to
to
complement
the
the
limitations
of
the
blockchain,
which
of
course,
are
a
lot
of
advantage
because
you
end
up
with
immutability
and
and
and
long
exchange
through
long
extreme
building
and
in
consensus
flowing
stream
building
and
that
that's
a
really
valuable
model,
but
it
doesn't
cover
all
compute
than
in
the
centralized
hardware
marketplace.
A
So
that's
really
what
the
fluent
vision-
and
this
is
where
all
the
tooling
we're
going
to
talk
about,
and
the
code
we'll
see
a
little
bit
comes
in
so
fluence
decentralized
period
of
peer
compute
time
to
get
a
little
bit
come
a
little
bit
down
in
the
level
of
abstraction.
So
on
the
right
here
you
see
a
peer-to-peer
network.
A
You
have
two
to
client
peers.
If
you
build
those,
are
the
upper
green
and
lower
left
green
and
could
be
a
browser,
it
could
be
a
node
app,
doesn't
really
matter,
it's
those
are
peer-to-peer
clients
and
then
in
the
blue.
Are
our
peers
in
the
network
relay
obviously
is
a
a
peer?
That's
publicly
accessible
could
be
sitting
in
front
of
peers
behind
gnats,
et
cetera,
et
cetera,
et
cetera
these
peers.
A
In
in
what
connect
together
to
form
the
fluence
network,
are
enabled
to
host
webassembly
based
services
and
it's
web
assembly.
It
not
jump
by
engine.
Well,
you
can
get
a
little
bit
and
that
allows
you
to
to
really
have
the
building
blocks
for
a
generalized
compute
network,
peer-to-peer,
compute
network,
and
these
services
could
be
encapsulated
any
kind
of
business
logic.
A
You
can
possibly
express
in
webassembly
modules-
and
that
includes
actually
adapters
adapters,
to
pre-existing
capability
and
resources
like
api
microservices,
but
also
to
other
peer-to-peer
networks
like
ipfs,
and
we
have
a
full
integration
with
ios,
where
you
can
basically
use
the
tooling
from
flint
to
seamlessly
go
back
and
forth
between
the
compute
network
fluence
and
the
ipfs
data
network
by
extension.
Filecoin.
A
So
so
we
get
a
peer
peer
network
which
actually
is
represented,
representing
the
connectivity
among
a
bunch,
a
whole
bunch
of
peers
which
are
reference
nodes
that
connect
to
each
other
in,
according
to
certain
rules,
a
part
of
the
protocol
and
and
each
one
of
those
nodes
is
or
peers,
is
capable
to
host
webassembly
modules,
which
are
services
which
are
then
addressable
and
callable
and
executable
on
these
particular
nodes.
And
when
you
compose
across
those
different
services,
you
get
protocols
and
applications.
A
A
Green
client,
uplift
and
love
our
browsers
and
if
our
tactican
is
to
send
a
message
from
the
upper
left
to
the
lower
right
by
a
improving
upon
the
text,
that
was
input
in
the
upper
left
by
basically
scanning
the
text
to
convert
relevant
characters
into
emojis
and
then
to
do
a
spell
check.
Okay.
So,
basically,
if
we,
if
our
text
is,
is
golden
plus
one
e
z-
and
we
then
basically
say
hey,
throw
this
out
on
network
and
before
you
deliver
it
to
the
lower
left.
A
Green
client
check
the
text
for
emoji
injections,
so
we
have
an
emoji
injection
service
which
would
be
right
here.
So
we
connect
from
the
browser
to
the
relay.
The
relay
then
starts
figuring
out
for
peer
discovery
and
content.
Routing
to
this
particular
service
may
not
be
a
straight
shot
right.
It
could
go
through
a
whole
bunch
of
other
nodes.
Rest
assured,
there's
end
to
end.
Encryption
play,
doesn't
really
matter
if
it
goes
for
another
node
until
it
gets
to
the
final
node,
it's
all
fully
encrypted,
and
then
in
here
we
have
this.
A
This
service,
which
is
now
executed
and
then
scan
the
text
in
this
particular
case,
it
says.
Oh,
we
found
a
colon
plus
one
which
means
thumbs
up
and
we
replace
it
with
a
link
to
a
png.
For
example,
I'm
done
with
that
apply
our
state
change
to
the
text.
We
now
somehow
find
the
next
service,
which
is
a
spell
checker.
We
get
there
again
effect
in
this
particular
case.
A
We
also
have
another
service
here
that
says
hey
in
parallel
to
delivering
this
to
this
client,
actually
save
this,
this
very,
very
important
text
to
ipfs
you
get
a
cid
back
and
do
with
it
whatever
you
want,
okay,
so
it
was
a
very
simple
three
step,
three
service
example,
and
so
basically
what
we
said:
hey
there's
a
workflow,
so
I
alluded.
There's
a
workflow,
and
one
of
the
things
I
said
before,
is
that
all
these
services
are
function
addressable,
so
they
are
addressed
over
the
peer-to-peer
network,
not
json
rpc
rs.
A
A
You
invested
services
very
particular
over
peer-to-peer,
and-
and
this
is
sorry-
and
this
is
one
of
the
key
parts
of
the
the
fluence
protocol-
and
this
is
enabled
by
a
program.
Language
called
aqua
aqua
was,
is
a
fluent
invention
and
basically
allows
you
to
compose
distributed
services
in
networks
to
in
into
protocols
and
locations.
A
And
let's
just
have
a
look
real,
quick
in
how
aqua
works,
and
then
we
look
at
a
couple.
Other
technical
details
to
hopefully
explain
this
a
little
bit
further,
because
what
you
saw
here.
It's
not
a
typical
client
client
server
request
response
model,
it's
literally
a
data
push
model
and
that's
actually
really
important,
because
it
has
an
impact
on
enabling
very
thin
clients
and
a
few
other
ones
that
we
consider
vastly
superior
to
traditional
client
server
interactions
so
aqua.
A
Let's
just
like,
have
a
look
at
right
here
so
out
there
there's
a
service.
Basically,
it's
an
ipfs
service.
We
wrote
in
rust
and
compiled
webassembly
that
basically
extracts
parameters
from
an
ipfs
document.
We'll
actually
look
at
this
various
service
in
a
little
bit
later
in
detail,
so
believe
me,
it's
out
there
and
we
wrote
this.
A
We
compiled
it
to
webassembly
and
deployed
it
to
one
or
more
nodes
appears
if
you
will
out
there,
and
by
doing
this
we
end
up
with
function:
addressable
tuple,
which
is
the
peer
id
and
the
service
id,
so
that
service
is
out
there.
So
what
we
now
do
is
we
basically
create
an
interface
which
corresponds
to
that
webassembly
service
out
there,
and
this
is
the
namespace.
It
takes
a
service
id
which
we
get
it
shouldn't
be.
A
Is
it
should
be
id
sorry,
and
that
has
this
particular
function
and
this
particular
function
basically
takes
the
multi-address
of
the
ipfs
node,
which
is
in
every
fluence?
Node
comes
with
an
ipfs
sidecar
and
the
cid
of
the
safe
documents,
basically
a
bunch
of
parameters
that
were
uploaded
to
ipfs,
which
we
now
use
as
as
function
arguments.
A
So,
instead
of
using
actual
arguments,
we're
using
a
cid
which,
essentially
again
I'll
show
in
late
example,
actually
really
cool,
because
you
can
very
succinctly
process
very
complex,
linked
data
models
and
then
we
basically
just
have
a
a
function.
This
is
a
macro
function,
we
call
it
check
utility
addresses
and
it
takes
the
cid
which
corresponds
to
here
the
multi-average
which
corresponds
to
here
and
the
the
the
fluence
pier
I
didn't
name
this
particularly
below,
but
the
fluence
pier
that
has
the
ipfs
sidecar.
A
So
now
this
is
so
so
you're
on
the
screen,
you're
in
green
right
now
right,
so
you
you
have
to
support
where
you
have
it
in
some
client,
it
could
be
deployed
on
the
node.
But,
let's
just
say
you
have
a
client,
the
bigger
client
with
your
client
and
you
sort
of
throw
this
out.
It
doesn't
work
and
you're
on
some
relay
and
the
relay
doesn't
have
to
be
where
you're
on
doesn't
have
to
be
that
particular
node,
where
we
want
to
access
the
ipfs
tech
car.
A
So
what
we're
now
saying
in
aqua
is
basically
on
this
node
we
might
be
on
a
different
peer
right,
but
which
is
saying
on
the
period
on
this
potentially
different
peer,
create
a
binding
of
this
interface
to
this
particular
service
id
and
then
execute
in
that
namespace
in
the
service
namespace.
This
function
with
those
parameters
right
just
like
we
specified
up
there.
That
returns
us
in
this
particular
case,
a
a
function:
addressability
tuple,
which
happens
to
be
the
peer
id
service
id
and
now
return.
A
This
result
back
to,
in
this
particular
case,
the
source,
the
origin
or
originating
peer-to-peer
client.
So
it
could
be
from
this
node
oops
from
this
node.
We
go
back
to
the
relay
back
to
the
client
right.
So
if
we
were
just
like
in
that
examples,
if
the
service
was
here,
we
pushed
the
result
back
to
here
and
then
back
to
here.
If
that's
what
we
wanted,
which
will
be
this
particular
example.
A
So
if
you
look
at
it,
it
allows
you
to
compose
these
services
very
very
easily
into
into
much
more
complex
workflows,
and
it
actually
allows
you
to
program
aspects
of
the
fluence
network
and
but
also
seamlessly
interact
with
ipfs
different
particular
case
based
on
some
integration
of
work.
That's
already
been
done
and
is
ready
for
you
to
use.
A
So
how
does
that
work?
How
does
aqua
work?
How?
How
does
this
all
work?
How
do
we
get
this
data
push
model
we
talked
about?
How
do
we
actually
find
these
services
and
how
we
call
them,
and
how
do
we
execute
them?
So
there
are
two
aspects
to
it:
one
is
called
aqua
wireless
marine,
so
aqua
is
a
language.
A
It's
a
compiler
that
takes
the
language,
compiles
it
into
an
intermediate
representation,
and
it's
also
a
virtual
machine
which
actually
executes
this
intermediate
representation
and
then
there's
marine
marine
is
general
purpose
runtime
for
our
red
assembly
modules,
which
is
based
on
welshman
right
now,
we're
looking
into
extending
it
to
azel
time
as
well,
and
both
marine
and
aqua
are
available
in
every
fluence
reference
node,
which
is
the
rust
node
right
now.
It's
also
available
in
the
browser
now
aqua
is,
is
fully
unconditionally
available
for
the
browser
for
node
apps,
a
variety
of
clients.
A
Basically
what
it
means
you
can
literally
deploy
web
assembly
modules
for
execution
into
your
browser
or
your
node's
client,
or
your
long
running,
node
app
just
like,
as
you
would,
with
the
rusto,
and
so
those
both
virtual
machines
are
available
and
agra
really
is
about
composition.
And
it's
all
about
execution
and.
A
So
how
do
we
actually
pop
pop
through
those
different
peers
and
and
what
happens
when
we
do-
and
this
is
where
we
have
to
get
a
little
bit
into
the
foundations
of
the
protocol
and
the
application
of
the
protocol?
We
there
are
smart
package,
smart
package
or
smart
packages,
we
call
it
the
particle
and
the
particle.
The
smart
package
basically
combines
data,
the
compiled
aqua
script
and
then
some
data
forget
about
the
metadata
for
right
now,
but
basically
your
original
data.
A
So
if
you
go
back
to
our
original
example,
where
we
had
this
text
text,
colon
plus
one
ecc
right
and
that's
our
original
data,
our
genesis
data
and
then
we
have
the
execution
sequence
where
we
acquire
we
set
on
node
so
and
so
execute
the
the
emoji
injector
service
and
then
find
on
another
node,
execute
the
spell
checker
and
then
on
another
node,
which
actually
will
be
the
same.
Node
execute
the
a
in
parallel.
For
example,
you
deliver
write
to
ipfs
and
at
the
same
time,
given
the
way
to
that
client.
A
So
so
what
what
you
have
you
have
these
topological
hubs
across
the
network
and
execution
of
these
services
on
the
particular
node
you
reference
and
basically
every
time
you
so
so.
So,
basically,
you
hit
an
aquarium.
It
looks
at
the
script
of
the
intermediate
representation
of
the
composite
script
and
it
checks
what's
been
executed.
What
needs
to
be
executed
from
there?
It
determines
where
or
where
to
send
the
particle
either
if
it's
on
the
same
peer
or
to
another
peer
once
we're
at
the
right
period,
where
we
have
the
service
we're
not
looking
for.
A
We
now
execute
that
service.
On
marine,
we
update
our
data
in
the
particles.
We
get
a
device
particle
with
new
data,
and
a
new
list
appears
to
go
to
a
new
workflow,
basically
or
a
new
up
step
through
workflow
remainder,
if
you
will
to
that
needs
to
be
executed
until
you
finally
reach
the
end
of
the
script.
A
A
A
So
if
you
host
your
service
on
a
particular
node
and
you
don't
like
the
service
you're
getting
from
this
node,
you
literally
just
have
to
redeploy
your
web
assembly
modules
to
to
another
node
that
wants
to
host
you
and
off
you
go
there
are
it's
it's
it's
it's
extremely,
affordable
and,
and
the
impact
on
your
on
your
workflow
is
is
fundamentally
zero
right.
As
long
as
you,
you
have
somewhere
a
reference
to
the
updated
service
location,
you're
good
to
go.
A
Okay,
so
just
a
little
bit
more
about
tooling.
Before
you
get
to
the
code,
I
know
y'all
itching
to
get
to
the
code
we'll
get
there,
and
so
we
have
a
rust,
sdk,
rust,
node.
The
rust
node
is
a
reference
implementation
and
it's
readily
available
for
you
to
use.
If
you
want
to
know,
it's
influenced
brian's
double
bunch,
so
for
the
purposes
of
the
microphone
you
don't
have
to,
but
you're
more
than
welcome
to
do
so,
and
we
have
rust
sdk
that
allows
you
to
create
website
launches
from
rust
and
from
those
modules.
A
I
can
build
services,
so
services
have
unique
service
ids,
and
that
gets
you
to
these
function.
Addressing
tuples
we
talked
before
about
prp
and
service
id,
and
the
sdk
also
brings
some
additional
capabilities,
taking
a
very
cool
way
on
how
to
a
unit
integration
test,
the
actual
output
of
your
rascal,
not
just
the
code
itself,
but
once
you
compile
the
code
which
ends
which
results
in
representing
modules,
you
can
now
run
the
unit
integration
test
on
the
very
web
assembly
modules
before
you
deploy
it,
which
is
actually
super
super
helpful.
A
A
It
also
gives
you
capabilities
from
the
aqua
compiler
to
create
type
and
javascript
wrap
intermediate
representations,
which
then,
in
conjunction
with
allows
you
to
to
expose
javascript
interfaces
or
types
of
interfaces,
to
archive
to
be
used
as
if
they
were
web
assembly
services
and
they're
just
full-fledged
services
just
and
this
advantages.
But
it
also
requires
you
to
run
a
particular
node
and
if
you
want
a
scalar
node,
if
you
want
to
paralyze
this
node
blah
blah
blah
through
aqua,
you
would
have
to
run
multiple
modes.
A
So
the
trailer
is,
if
you
just
want
to.
If
you
want
to
be
light
as
possible
serverless,
if
you
will
you
don't
necessarily
want
to
run
a
node,
then
you
can
just
host
the
services
and
for
a
variety
of
reasons,
including
some
security
considerations
like
signing,
for
example,
you
might
want
to
run
the
build
or
keep
the
client
ready
available.
A
A
A
So
for
a
lot
of
dap
developers,
it
does
make
sense
to
run
downloads
and
instead
they
rely
on
the
gateway,
blockchain
gateways
like
infuria,
and
there's
nothing
wrong
with
that.
If
it
does
very
job,
but
it
does
introduce
a
centralized
choke
point
into
your
dap,
so
the
d
in
the
dap
is,
you
know,
starting
to
look
a
little
wiggly
there,
and
so
another
question
is:
how
do
you
deal
with
this?
A
So
we
can
do
this
with
ancestor
off
chain
solution.
So
basically,
what
we're
trying
to
do
now
is
we
say:
hey,
there's
like
multiple
blocking
gateways
right
and
for
the
same
function.
Call
for
james
jason,
rpc
call
to
the
institute
case,
ethereum
l1
nodes.
We
would
all
expect
at
the
same
time
to
get
the
same
answer.
So
if
we
actually
do
the
ethernet
score
block
capital
number
call,
which
is
an
rpc
call
here,
it
says,
express
and
skip
block
number
to
each
one
of
those
gateways.
A
We
want
to
have
certain
degree
of
failover
and
we
want
to
have
certain
so
basically
what
we're
doing
in
this
particular
example
we're
deploying
services
to
different
nodes
and
then
run
those
in
parallel
to
get
our
results.
Our
request
respond
our
response
to
the
request
from
this
different
gateway.
So
with
three
services
and
the
three
gateways
and
three
nodes,
we
expect
nine
nine
responses
which
hopefully
are
nine
same
block
number
at
this
particular
given
time
and
then
once
we
have
each
one
of
those
each
month
nodes
have
those
three
calls.
A
We
return
those
responses
and
then
we
apply
the
statistics.
We
use
some
frequency
calculations,
both
basically
and
say,
hey
how
many?
What's
the
most
frequent
response
out
of
the
responses
we
got
out
of
nine?
Hopefully
you
know
and
what's
what's
the
end
associated
with
it,
and
then
we
can
provide
a
quorum
threshold
to
our
application.
A
A
So
so,
basically,
verification
by
replication
is
one
way
you
can
very
easily
very
quickly
or
relatively
quickly
decentralized
blockchain
gateways
and
proudly
retain
the
d
and
the
adapt,
and
this
is
what
we're
gonna
go
through.
I'm
probably
gonna
go
through
everything
in
detail,
but
I'll
give
you
enough.
There's
a
it's
in.
We
have
a
repo
and
it's
listed
down
here
and
there's
a
big
old
readme
and
feel
free
to
work
through
it,
the
suggestions
on
what
to
do
and
how
to
get
involved.
A
What
are
implementation
requirements?
How
do
you
look
at
get
this
actually
done
so
we
just
mentioned.
We
need
webassembly
services
right,
so
we
need
to
create
those
gateway
providers
and
we
have
to
do
those
quorum
calculations.
I
mean
that's
the
minimum
high
level
stuff
and
then
we
need
to.
We
have
these
at
least
two
services,
and
now
we
need
to
compose
the
services
with
the
appropriate
control
structures
in
aqua.
A
So
how
do
we
call
those
gateway
providers
and
how
do
we
get
our
code
executed
as
quickly
as
possible?
Because,
if
we're
too
slow,
if
everything's
sequential,
we
might
very
easily
end
up
being
on
two
different
sides
of
the
end
of
the
block
time
and
actually
legitimately
get
two
different
black
side
block
heights
unacceptable.
So
we
need
to
paralyze.
So
we
have
web
assembly
single
threaded,
but
we
need
parallelization
and
webassembly
no
sockets
and
we
need
to
call
those
kp
providers
like
if
you're
a
command
link
to
to
get
our
our
data.
A
How
are
we
going
to
do
this?
Well
as
part
of
marine?
We
we
created
a
punch
through
capability
from
the
wazi
sandbox
into
the
host
to
the
host,
and
that
comes
with
permissioning.
So
if
the
whole,
the
host
agrees
to
permission
a
particular
binary,
for
example,
to
the
webassembly
module,
then
that
web
assembly
module
can't
utilize
that
binary-
and
this
binary
in
this
particular
case
is
curl,
so
we
can
actually
create
our
gateway
primers
with
chrome.
We
don't
want
wss,
for
example.
We
don't
want
to
have
these
long
running
connections.
A
We
want
to
develop
this
quick,
so
otherwise,
the
first
block
for
everywhere
that
blocks
the
marine
block
very
quickly.
If
you
want
to
you,
bring
the
whole
network
to
grinding
halt
and
that's
obviously
what
we
don't
want
for
you
who
happens
resistance,
timers
are
your
friends
right,
so,
but
even
one
shot,
the
calls
are
are
better
than
have
to
enforce
taiwans
and
everything
which
may
not
always
work
okay,
so
by
in
by
so
implicitly
I
just
mentioned.
A
Otherwise,
you
get
a
mix
of
parallelization
or
sequential,
sequential
execution
which
may
not
bring
you
the
the
the
time
advantages
you're
looking
for
okay,
so
we
had
the
implementation
requirements.
What
are
our
steps?
There
are
obviously
different
ways
to
go
into
it,
but
you
know:
write
our
assembly
modules
interact
with
the
gateways,
configure
and
deploy
those
services
and
and
then
implement
the
aqua
service
composition
control.
A
Now,
a
lot
of
these
services
provide
very,
very
cool
higher
level
apis,
which
are
super
cool,
but
they're,
usually
semi-proprietary.
So
the
one
what's
working
in
pure
doesn't
work
in
alchemy:
does
market
link?
Doesn't
work,
can
be
rare,
blah
blah
blah,
so
the
common
lingua
francois,
if
you
will
of
evms,
is
just
rbc.
So
this
is
how
we're
implementing
it,
and
if
you
just
in
case
you're,
not
too
familiar,
you
should
be
coming
from
ethereum,
but
just
in
case
I'm
going
to
blow
through
it
is.
A
This
is
what
your
your
request
method
would
look
like
in
json
rpc,
you
get
a
method,
you
get
parameters
with
triemt
for
block
number,
of
course,
and
id's
your
knobs,
and
if
you
can
literally
call
it
with
curl,
which
is
what
we're
actually
going
to
be
doing
later
on
as
well,
and
then
we
get.
This
is
fault.
If,
if
you,
if
you,
you
should
compare
the
non-smash
and
the
result,
this
particular
thing
called
these.
A
A
Let's
look
in
the
left
here
and
our
overview
and
let's
just
have
a
look
at
different
directories,
we're
using
in
order
to
get
our
stuff
done.
We
have
a
directory
called
aqua.
This
is
where
we
have
our
aquascripts.
We
have
a
directory
called
artifacts.
This
is
where
we
collect
our
webassembly
modules
from
basically
the
compiled
directories
of
each
one
of
the
rest
projects
that
end
up
creating
these
webassembly
modules
we'll
go
into
this
a
little
bit
later.
A
We
got
some
parameter
files,
we'll
I'll
go
in
this
in
a
little
bit,
but
basically
I'll
go
in
this
a
little
bit.
Some
of
them
are
to
be
used
directly
in
in
akron
function,
calls
and
others.
Our
parameters
be
actually
uploaded
to
ipfs
and
then
use
in
aqua
through
the
cid
and
the
multi-address
of
this
particular
idea,
sidecar
and
we'll
get
into.
Why
we're
doing
this?
In
a
little
bit?
A
A
A
They
also
have
the
api
key
as
part
of
the
url,
except
for
link
which
doesn't
have
an
api
key
doesn't
require
an
api
key,
and
so
we
don't
have
to
do
some
fancy
header
processing
for
for
tokens
or
whatever
other
alternatives
there
are
to
to
authenticate
against
those
services.
So
if
you,
if
you
want
to
use
different
services,
you
may
have
to
slightly
change
the
code
in
order
to
try
ahead
of
parsing,
to
get
your
authentication
capabilities
and
pass
them
on
to
curl,
so,
okay.
So
what
we're
doing
this
is
our
method.
A
So
all
this
stuff,
we're
doing
here
is
we're
basically
creating
the
reusably
the
setup
of
the
json
document,
which
we
turn
into
a
string
for
the
jsonpc
request,
and
then
we
actually
just
call
it
girl.
So
where
does
curl
come
from?
We
have
this
web
assembly,
and
I
told
you
this
is
punching
capability
for
the
wazi
sandbox
into
the
whole
system.
How
and
where?
A
Okay,
if
you
look
at
the
bottom
here,
we're
basically
if
you're
familiar
with
rust
or
or
cc,
plus
plus
you
realize
this
is
my
favorite
ffi
style
import
of
a
link
of
something
and
this
something
is
actually
curl
adapter.
So
where
does
the
curl
adapter
come
from
by
the
way
the
mounted
binary?
This
is
this
is
where
the
punch
loop
comes,
and
this
is
where
we
collect
the
results
from
the
binary
and
bring
it
back
as
a
result
from
this
current
request
call
so
back
to
where
does
curl
cancel
so
we
have
a
curl.
A
A
That's
it,
and
then
we
wrap
that
if
I
imported
the
ff
imported
binary
call,
if
you
will
and
call
it
curl
now,
we
call
it
curl
unscore
request.
Again
we
take
this
array
of
strings,
we
return
exactly
the
same
I'll,
do
it
by
the
result-
and
we
call
curls
just
like
with
here,
so
we
compile
this
adapter
code
and
we
deploy
it
to
the
network
with
this
module
and
I'll
show
you
this
in
a
little
bit,
but
let's
just
like,
look
a
little
bit
more.
A
What
we
have
to
do
in
order
to
get
our
request
a
service
from
each
one
of
those
providers,
so
we
have
the
ur.
So
in
here
private
just
reply,
we
we
get
the
name
and
url.
We
start
calling
curl
with
all
these
rpc
commands.
We
get
it
back.
We
make
sure
that
we
don't
have
any
errors
in
the
return,
because
obviously
this
is
a
fundamental
deterministic
call.
A
We
could
time
out
the
the
the
provider
could
may
not
be
up
etcetera,
etcetera,
etcetera
and
then,
if
we
actually
do
get
what
we
want,
which
is
the
block
height,
we
change
it
from
from
the
hex
to
a
u64
and
we
actually
create
a
json
string
with
the
key
block
height
and
then,
of
course,
the
u64
being
the
block
height.
That's
what
we'll
return
so.
A
A
A
We
see
the
in
our
webassembly
modules
directory.
This
is
where
all
our
our
ras
projects
are,
which
compile
into
these,
which
result
in
the
compilation
into
these
web
assembly
modules,
and
the
key
here
is
basically
this,
which
basically
is
this,
which
marine,
which
is
the
marine
sdk.
I
mentioned
before
the
rust
sdk
it's
marine
and
basically
we
specify
to
build
that
project
and
make
sure
you
specify
release.
Otherwise,
you
end
up
with
like
multi
gigabyte
size
by
assembly
modules,
which
you
do
not
want
to
upload
to
the
network.
A
A
A
A
Okay,
so
we're
this
is
probably
not
very
visible
for
you.
Let's
make
it
a
little
bigger
so
now
we're
in
in
the
rebel
in
the
marine
rebel,
and
let's
see
that
lists
everything
that
we've
exposed
in
our
code-
and
I
forgot
to
mention
how
we
expose
it
I'll
go
back
and
explain
this
in
a
minute-
and
so
here
here
are
a
bunch
of
exported
functions,
all
the
data
structures
of
course
and
functions.
So
this
is
the
chrome
request
we
were
talking
about,
and
this
is
the
multi-provider
query
we
were
looking
at.
A
So,
let's
see
I
used
it
before
okay.
So
let's
call
this
multi-provider
get
block
number
right:
that's
the
web!
That's
the
russ
code!
We
just
looked
at
and
compiled
into
this
particular
representative
module
which
utilizes
the
curl
adapter
and
we're
doing
this
with
the
link
gateway
provider,
which
luckily
doesn't
use
an
api
key.
So
I
don't
have
to
rotate
anything.
We
are
really
dead
and
all
right
moment
of
truth.
Oh
look!
A
A
A
You
can
think
of
it
as
decorator,
and
this
is
what
actually
helps
turn
dress
code
and
enforce
the
webassembly
rules,
because
we're
using
webassembly
inference
types
which
has
limitations
in
the
interface
types
and
also
make
sure
that
everything
that
is
in
that
marine
block
gets
actually
exposed
to
as
a
public
function
or
or
method
for
a
data
structure.
So
what
you
saw
in
the
rebel
everything
was
prefixed
with
this
macro
and
just
on
the
type
side
everything
website
is
passed
by
value,
so
in
rust
there
are
no
within
those
marine
blocks.
A
A
We
need
to
deploy
this
service
to
the
network
and
I'm
gonna
save
ourselves
a
little
bit
of
time
here
we
do
this
with
the
aqua
cll,
so
first
of
all,
fluence
provides
a
whole
bunch
of
nodes.
That
are,
I
mean
there
are
other
notes
as
well
about
fluency
a
bunch,
and
I
encourage
you
if
you
want
to
use
those
nodes,
and
you
can
actually
do
this
with
the
command
aquaculture
default.
Peers,
they're,
different
networks-
if
you
just
do
not
use
stage,
you
end
up
with
a
krasnodar
network
for
this
particular
case.
A
It
was
a
stage
and
this
this
basically
are
the
pure
addresses
right.
This
is
the
pure
multi-addresses
and
back
here
those
are
the
actual
peer
ids,
and
if
you
want
to
deploy
a
service,
you
need
secret
key.
That
secret
key
has
multiple
functions,
including
if
you
want
to
delete
the
service,
you
need
to
provide
a
secret
key
and
you
actually
can
use
authentication
within
the
web
assembly
modules
to
restrict
access
to
one
function
or
many
functions
and
again
this
requires
the
secret
key,
so
create
yourself
one
or
more
key
pairs.
A
A
There
are
some
trade-offs
to
be
had,
and
then
we
use
aqua
to
deploy
the
service
and
the
service
we
just
deployed
was
called
multi-provided.
Query
remember:
this
is
what
we
called
our
this
was
the
web
assembly
module.
This
is
what
we
called
it
right,
and
this
is
speaker
key.
You
gotta
bring
it
in
there's
a
thing
in
the
log
level
to
keep
it
nice
and
clean,
and
the
response
you
should
be
back
is
that
we're
uploading
a
module,
we're
applying
another
module,
two
modules.
Why
remember?
A
We
needed
the
the
curl
adapter
to
empower
that
to
provide
a
query,
webassembly
module
to
actually
make
the
calls,
and
then
we
end
up
with
a
blueprint.
Blueplane
is
basically
a
the
hashing,
a
particular
way
of
hashing,
all
the
modules
you
uploaded
and
then
you
get
server
side,
so
the
blueprint
id
if
the
blueprint
is
static.
A
If
you,
as
long
as
you,
don't
change
your
web
assembly
code
or
your
single
modules,
you
end
up
in
the
upload
in
the
same
configuration
the
end
up,
always
with
the
same
blueprint
across
any
any
period
you
deploy
in
this
particular
service
over
and
over
again.
It's
always
same,
however,
in
order
to
actually
instantiate
those
services
and
run
them,
you
need
a
service
id
and
that's
a
unique
basic
ui
uuid
and
which
is
unique
and
associated
with
those
blueprints
ids.
A
A
Configuration
deployment
so
this
is
this
is
a
deployment
config
file
and
it
has
multiple
modules.
What
modules
it
is,
so
we
can
each
one
of
the
sections
can
be
deployed
independently
of
the
other
ones
by
just
simply
specifying
the
name
in
the
service
we
want
to
deploy,
and
this
was
the
one
we
want
to
deploy
and
it
comes
it's
comprised
of
two
web
assembly
modules.
We
have
basically
packaging
and
product
with
linking
once
they
are
deployed
onto
the
host,
which
is
the
curl
adapter,
which
is
then
used
by
the
multi
provider.
A
A
If
you
go,
if
you,
if
you
shell
into
the
node,
you
know
around
which
binary
which
curl
that's
where
it's
using
curl
great
and
it's
available
in
all
fluids,
notes
for
sure
and
that's
the
command
we're
using
and
the
rest
of
my
memory
allocate
where
the
path
is
in
artifacts.
So
now
you
see
why
we
moved
everything
to
artifacts,
because
it's
just
a
lot
easier
to
deal
with
and
then
of
course
this
is
the
multiple
project
query
we
were
using
again.
A
We
set
the
memory
and
of
course
we
don't
need
any
mounted
binaries,
because
there
there
is
no
access
directly
from
this
multi-product
query
web
essentials
to
the
host
it's
done
through
the
web,
the
curl
adapter
okay,
so
we
got
the
service,
we
deployed
the
services
and
now
we
actually
would
like
to
check
if
the
services
are
working.
Yes,
we
actually
now
get
into
writing
some
aqua
code
and
in
this
particular
case,
our
very
simple
one
to
basically,
we
just
want
to
get
block
heights
right.
A
So
we
have
a
bunch
of
provider
info
and
and
and
function
addresses.
So
we
had
three
providers
right
and
the
providers
was
the
name
and
the
url
remember,
and
we
had
three
nodes.
So
we
have
three
nodes:
peer,
ids
and
service
ids
and
we're
gonna
get
back
to
the
edm
result,
which
is
what
we're
looking
here.
Basically,
just
tells
you
the
provider
and
and
that's
just
a
standard
standard
error
and
it's
an
array
they're
off.
A
So
in
our
particular
case,
when
we
run
it
three
provide
us
to
be
nodes,
we
should
get
nine
and
the
rate
of
length
nine,
and
basically,
we
create
here
right.
What
we're
saying
here
is
for,
for
each
of
the
addresses
function,
addresses
services
deployed
on
that
peer.
That
hosts
this
particular
service,
create
this
binding
of
the
multi-provider
query,
which
we
specified
here,
which
remember
get
block
number.
We
looked
at
this
at
the
very
beginning
and
now
we're
back
to
here,
which
corresponds,
of
course
to
the.
A
We
do
by
specifying
par
here
and
so
basically
for
each
for
each
provider
for
each
service
available,
we
run
in
parallel
on
each
different
node.
The
the
provider
info
basically
run
the
request,
and
then
we
get
some
results
back.
We
don't
really
need
that
and
we
return
it
so
blah
blah
blah.
What
does
it
look
like.
A
Okay,
first
of
all,
this
is
very,
very
ugly,
but
it's
very
illustrative,
so
we
say
acro
run
and
then
we
just
select
appear
on
the
network.
We
on
the
namespace
of
the
network,
we're
looking
at
we
use
stage
in
this
particular
case
and
we
basically
say:
hey,
compile
this
aqua
and
then
we
say:
hey
call
this
function
with
those
two
arguments
and
then
we
specify
those
arguments
because
they
are
json
specified
json.
We
we
break
them
out
separately
and
it's
of
course
not
particularly
nice.
But
here
we
say:
do
this
with
your
api
key.
A
We're
not
gonna
get
anything,
so,
let's
see
what
we're
getting
when
we're
calling
this,
because,
obviously
we're
not
going
to
be
authenticated
too,
so
you
got
to
put
in
your
own
api
keys,
so
link,
I
said,
didn't
require
api
key,
so
we
said.
Okay,
ms,
is
expected
here.
Message:
error,
error,
block,
height,
error,
error,
block,
guide,
error,
blockhead,
so
this
is
all
consistent.
All
the
blockets
are
the
same.
So
even
though
we
didn't
provide,
we
didn't
get
it
at
least
link
across
the
three
different
nodes
gives
us.
A
The
same
gives
us
the
same
block
height,
which
is
somewhat
encouraging.
If
you
actually
again,
if
you
update
this
with
your
api
key,
you
actually
get
nine
results
and
I'll
show
this
a
little
bit
because
I'm
going
to
abstract
the
way
over
the
over
the
api
keys.
So
again,
I
don't
want
to
have
to
redo
my
ips
all
the
time
for
those
providers.
A
A
So
here
we
got
sort
of
a
full-fledged
everything
aqua
function
which
takes
both
actual
arguments,
so
the
provider
info-
we
we
type
in
as
arguments
just
like
we
did
before,
and
the
reason
for
this
ipf
is
public.
So
I
don't
want
to
put
my
api
keys
onto
ivfs
necessarily,
so
I
just
rather
use
that,
but
then
all
the
other
parameters
we
saw
before
we
actually
upload
to
ipfs
we
get
cids
back.
A
We
get
the
function
address
right
here
and
then
basically,
we
move
in
and
again
just
like
before.
We
now
get
our
our
our
nine
responses
back.
Hopefully
so
we
do
it
again
in
parallel
and
now
here
we
actually
start
calculating
the
quorum,
and
I
didn't
show
you
the
service,
but
you
can
figure
this
out
on
your
own
and
basically,
what
we're
saying
here
is
calculate
the
quorum.
If
we
do
have
a
quorum,
then
everything
is
fine.
A
Then
we
also
are
interested
in
so
so,
if
we
just
run
this
at
up
at
this
point,
you
basically
would
get
what
you
know.
I
don't
know
nine
or
nine
the
same
or
six
out
of
nine
the
same,
but
you
have.
No,
it
just
tells
you
what
the
frequency
distribution
is
basically
of
the
quote-unquote
winning
response
and
that's
okay,
but
if
we
want
to
start
building
trust
profiles
over
different
providers
and
different
nodes,
for
example,
we
actually
want
a
little
bit
information
and
get
this
information
by
adding
this
particular
sub
portion
here.
A
So
basically,
what
we're
saying
is
like
hey.
We
have
this
where
the
utility
service
comes
in,
convert
this
json
string
into
a
just
give
me
the
block,
height
integer,
and
if
that
integer
is
not
equal
to
the
mode,
then
we
have
a
deviant
and
if
we
have
a
deviant
we
want
to,
we
want
to
print
that
out.
That's
what
we're
doing
here.
Of
course
the
printout
is
just
a
placeholder
process.
You
could
save
it
to
to
ipfs.
A
You
could
save
it
to
ceramic
for
further
processing,
update
a
running
tally
of
accuracy
or
inaccuracy
of
a
particular
service
or
node,
and
we
do
this
as
in
this
particular
case
as
a
co-routine,
and
we
do
this
at
close
routine,
because
in
order
to
print
you
can
fundamentally
only
print
on
the
pier
you're
calling
from
not
the
peer.
You
actually
spitting
on
this
list,
and
so
basically
we're
doing
is
here.
A
We
we
go
from
the
pier
we're,
quite
quite
on
recall
from,
and
then
we
make
a
topological
switch
to
this
pier
up
here
for
each
one
of
those
addresses,
and
then
we
basically
switch
back
to
our
original
appear
and
as
a
co-routine.
So
we
don't
incur
any
any
major
type
penalties
and
then
we
just
print
out
the
quorum,
basically
the
highest
frequency
of
the
blockade
that
we've
encountered
and
whether
or
not
we
accept
this
quorum.
So
let's
execute
this
real,
quick
and
this
time.
A
This
is
our
mix
parameter
file
now
with
which
we
data
path,
and
this
is
what
it
looks
like.
So,
instead
of
the
node
and
peer
ids,
we
have
cids
and
multi
addresses
and,
for
example,
the
the
core
mattresses,
which
were
here
now,
of
course,
look
like
look
like
this
all
right.
So
those
are
our
provider
arguments
remember.
A
We
said
we're
going
to
keep
them
raw
because
it
includes
our
api
keys
and
ipfs
doesn't
inherently
provide
privacy,
so
we
said
we'll
keep
it
cid,
cid
cid,
three
different
services,
and
then
we
have
the
arguments,
raw
agreements
of
our
active
service
and
the
threshold.
The
thresh
probably
is
actually
a
candidate
for
ipfs,
because
the
immutability
around
the
threshold,
if
you,
if
you
wanted
to
have
some,
you
know,
provability,
that
you
didn't
change
your
parameters.
So
that's
for
a
particular
outcome.
That
would
be
actually
kind
of
helpful.
A
A
Yes,
so
we
remember,
we
had
nine
calls
in
total.
Our
frequency
is
nine.
This
is
our
block,
so
everything's,
fine,
our
form
is
satisfied
and
we're
in
good
shape.
If
that
hadn't
been
the
case,
then
just
before
we
would
have
had
different,
you
know
threshold
settings
and
different
quorum
acceptance,
and
if
we
have
different
frequencies,
then
relative
to
threshold
blah
blah
blah
just
as
anyway,
it's
the
same
thing
just
we're
now
using
ipfs
arguments.
That's
really
cid
arguments,
that's
really
the
only
thing
and
we're
resolving
the
ipfs
reference
content.
A
A
So
if
you
want
to
share
your
parameters
or
reuse
them
later,
you
have
reference
to
them,
but
you
actually
can
start
building
ipld
type
data
models,
so
we
actually
could
could
build
a
link,
parameter
settings
and
obviously
make
create
much
more
complex
data
models
which
we
then
could
very
succinctly
and
immutably
because
of
cid's
feed
into
these
functions
all
right.
So
this
was
it
for
the
code,
thanks
for
bearing
with
me
and
everything
actually
went
up
without
a
hitch.
So
that's
pretty
cool.
A
So
in
we,
we
have
a
few
available
integrations
available,
including
ipfs,
which
we
just
discussed
ceramic.
We
have
near
integration
which
easily
extends
to
evms
in
general
and
with
three
libraries
we
have
additional
building
blocks
around
adapters,
integrations
nfts
and
a
lot
of
it
coming.
Also
we
see
and
did's
coming
from
the
community
so
have
a
look
and
now
the
bounties.
A
Any
end
users
here
is
obviously
go
for
it,
pursue
it.
Amaze
us
dazzle
us
and
have
a
lot
of
fun
doing
it.
If
you're
a
little
light
on
the
idea
side,
things
like
moving
complex
computations
for
a
default
nfc
product
to
off
to
influence
network.
That's
obviously
something
keep
that
d
in
the
dap
just
keep
it
alive.
A
It's
important
the
data
processing
engines
for
ipfs
and
flatcoin,
either
from
the
blockchain
to
or
from
the
data
back
to
on
chain,
whether
it's
oracle
or
or
some
other
triggers
it's
up
to
you,
I'm
I'm
pretty
enamored
with
with
cid's
and
in
functions
as
you
can
tell.
You
may
not
think
it's
a
big
deal.
I
think
it's
really
cool
because
of
the
benefits
I
pointed
out
earlier
to
build
more
complex
data
models.
A
You
may
actually
want
an
indexing,
because
every
time
you
change
something
you
need
to
be
next
ipld
and
for
that
it
can
actually
influence.
So
it's
it's
it's.
It
comes
full
circle,
so
this
would
be
also
something
I
think
we'd
be
looking
very
interesting.
It's
a
very
interesting
project,
particularly
if
you
can
start
using,
because
if
you
have
these
complex
data
models,
they're
not
just
succinctly
represented
in
as
a
function
argument
also
in
smart
contracts
right.
A
So
so
you
can
very
easily
very
cheaply
anchor
very
complex
data
models
and
really
push
on
the
probability
aspects
of
it
and
finally,
another
one
of
our
favorites
is
eli's
dao
proposals
to
trigger
off-chain
compute
events
with
points.
So
the
idea
here
is,
I
see
you,
you
have
some
off-chain
compute
requirement
as
a
result
of
a
proposal
being
accepted
or
possibly
rejected,
and
and
that
compute
should
be
triggered
by
the
outcome
of
the
voting
process.
A
So
one
one
way
you
can
do
this
to
to
really
keep
the
automation
and
working
is
you
you
attach,
or
you
embed,
the
the
acquired
compiled
aquascript
in
your
proposal
and
upon
execution
or
upon
vote
outcome.
The
script
now
gets
executed
and
there's
different
ways
of
doing
this.
Reach
out.
If
you
want
to
but
keep
in
mind,
the
script
itself
could
be
uploaded
to
ipfs.
A
You
have
a
cid
and
the
addressability
to
the
script,
regardless
of
where
you're
calling
from
right
and
then
all
the
compute
models
you're
actually
using
all
the
service
models
themselves
actually
can
be
also
on
on
ipfs
or
filecoin.
So
you
also
have
content
adjustability
and
you
have
the
immutability
of
the
actual
services,
so
you
could
have
the
the
script
that
actually
loads
and
eventually
unloads
those
services
required
in
order
to
the
execution,
and
it's
I'm
I'm
pretty
excited
about
it.
A
I
think
it's
a
really
really
cool
use
case
and
if
that's
something
you're
interested
in
reach
out,
we
can
go
through
it
and
certainly
look
forward
to
building
it
and
before
we
close
out,
we
have
a
website.
We
have
github,
we
have
discord,
we
have
delegate
and
of
course
we
have
twitter
and
we
also
have
a
job
opening.
A
So
if
you're
interested
in
particular
round
rust,
if
you're
interested
in
building
nodes,
if
you're
interested
in
compilers,
if
you're
interested
in
language
development
acquired
selfish
development
scala,
for
example,
any
of
that,
if
you're
interested
in
peer-to-peer
protocols
if
you're
interested
in
developer
relations
management,
so
there
are
some
some
core
engineering
and
some
related
and
some
non-engineering,
including
marketing
product
reach
out
and
get
in
touch,
and
that's
it.
So.
Thank
you
very
much
thanks
for
having
me
have
fun
good
luck
and
looking
forward
to
some
great
submissions,
cheers.