►
From YouTube: Protocol Labs - Compute Over Data on the FEVM - Zak Ayesh - FVM Dataverse Hackathon 2023
Description
Protocol Labs - Compute Over Data on the FEVM presented by Zak Ayesh - FVM Dataverse at the Hackathon 2023.
A
So,
yes,
he
did
a
a
workshop
on
dated
owls
and
now
talking
about
compute
over
data
on
the
fvm,
and
this
is
a
new
workshop
that
I've
not
seen
yours
so
yeah
I'm
looking
forward
to
this
so
yeah.
If
you
want
to
start
like
I,
said
I'm
just
going
to
quickly
grab
a
coffee,
you
start
and
I
will
be
I'll,
be
right.
Back
here
again
sounds.
B
B
You
know:
I've
worked
in
web3
for
almost
three
years
now
and
I'm,
a
really
big
fan
of
decentralized
infrastructure,
which
is
why
I'm
here
so
today,
I
want
to
talk
a
little
bit
about
compute,
overstate
versus
compute
over
data.
These
are
actually
two
different
subjects:
I'm
gonna
introduce
you
to
the
project
bakulao,
which
is
a
cute
over
data
project
and
we're
going
to
go
over
some
remix
code
and
then
some
code
in
this
new
hard.
A
B
It's
a
quick
overview
review.
If
you
don't
already
know
the
fvm
brings
on-chain
programmability
to
follow
coin
Network,
and
so
you
may
be
asking
yourself
what
does
that
have
to
do
with
compute
over
data?
Isn't
this
already
compute
over
data
right
like
it's
a
it's,
a
virtual
machine,
it's
running,
computations,
there's
data
in
it.
What
do
I
mean
by
compute
over
data.
B
Right
so,
first
of
all,
you
know
the
architecture
of
the
fvm
is
based
on
webassembly.
It's
built
to
support
multiple
runtimes
and
the
primary
runtime
it
supports.
Right
now
is
the
ethereum
virtual
machine,
all
right,
the
F
evm.
We
call
it
follow.
Coin
ethereum
virtual
machine
right,
so
all
code
that
can
compile
down
to
ethereum
byte
code,
whether
that's
solidity
or
Viper,
can
be
run
within
this
virtual
machine
and
in
the
future,
perhaps
it'll
be
other
virtual
machines
right
and
so
what
is
compute
over
State
compute
overstate
is
essentially
you
know.
B
Filecoin
is
a
blockchain
that
was
tailor-made
for
storing
the
internet's
data
right.
It's
a
blockchain
based
around
decentralized,
archival
storage
and
then
we've
added
in
this.
You
know
evm
to
it.
So
now
we
can
have
programmable
storage
Primitives.
But
you
know
the
virtual
machine
itself
is
actually
just
Computing.
The
state
of
the
data
stored
off
chain
with
your
storage
providers
right
so
on.
B
Filecoin
storage
providers
store
data
and
they
provide
proofs
to
the
blockchain
that
that
data
is
actually
being
stored,
right
and
so
compute
over
state,
which
is
what
the
fevm
can
do,
is
computation
on
the
metadata
of
the
data
stored
on
file
on
with
the
file
coin.
Storage
providers.
Basically
compute
overstate.
If
you
hear
that
it
just
means
the
storage
Shields
compute
and
the
fevm.
Around
storage
deals
right.
B
B
Right
so
here's
a
deal
on
the
Falcon
blockchain,
specifically
the
hyperspace
testnet,
which
we'll
be
deprecating
soon
for
calibration
net,
just
an
FYI,
probably
by
the
end
of
this
month,
we'll
have
calibration
at
up
and
running,
but
hyperspace
testing
it.
Here
we
have
a
deal
1652
right
and
all
of
this
right
here.
B
This
is
that
state
that
we're
talking
about
the
deal
ID,
the
time
that
the
deal
was
created,
the
block
the
deal
was
created,
the
PC
ID
of
the
data
that's
being
stored
with
the
storage
providers
right.
This
is
important,
we'll
talk
about
it
in
a
second
whether
this
deal
is
verified
and
you
know
who
the
client
is
storing
the
deal
and
who
the
provider
is
storing
the
deal.
Is
you
can
write
a
lot
of
interesting
logic
around
this
right?
You
can
have
a
dow
create
deals.
B
I
did
a
talk
on
that
earlier
in
this
hackathon.
You
could
create
Perpetual
storage
contracts
around
this
data,
but
none
of
this
data
is
actually
touching
the
data
off
chain
right.
Why
isn't
it
touching
the
data
off
chain?
Well,
a
lot
of
data.
Storing
data
on
chain
is
extremely
expensive
right
and
the
data
we
want
to
store
off
chain
is
large.
Data
sets,
maybe
it's
a
whole
video.
Maybe
it's
multiple
videos.
B
So
we
store
it
off
chain
and
have
proofs
to
prove
that
they're
still
being
stored
right
so
earlier,
I
showed
you
that
pcid
that's
part
of
a
deal
now
you
can
think
of
that
as
sort
of
a
root
hash
that
represents
the
data.
We're
going
to
be
using
these
a
little
bit
later
on.
So
I
want
to
review
this.
If
you
don't
already
know
it,
but
you
can
think
of
it
as
a
hash,
it's
more
complex
than
a
hash.
So
essentially
you
take
a
file,
a
new
piece
of
data.
B
B
Right,
so
all
of
that's
based
around
compute
over
estate,
right
and
I,
talked
about
the
client
contract
a
little
bit
more
detail.
My
last
talk,
so
please
reference
that
if
you
want
to
learn
a
little
bit
more
and
that's
kind
of
what
we've
been
focused
on
here
for
a
while
is
compute
overstate,
but
many
blockchains
could
do
compute
overstate
what
is
compute
over
data
right,
so
this
is
actually
can
computations
over
that
heavy
data
that
we
have
stored
with
storage
providers.
B
This
may
be
too
expensive
to
run
on
chain
could
cost.
You
know
100
million
dollars
of
gas
if
you
ever
run
these
computations
right.
So
when
we
say
compute
over
data,
we
mean
compute
over
the
actual
data,
that's
being
stored
with
the
storage
providers
and
when
we
say
compute
overstate,
we
mean
computation
in
smart
contracts
over
any
kind
of
state
that
the
virtual
machine
knows
about.
B
Right
so
here's
kind
of
a
visualization
of
what
I'm
talking
about
you
know
we
have
the
layer
one.
We
have
the
actual
file
coin
blockchain
right
here
with
the
fevm,
our
fem
on
it,
and
that's
where
we
can
run
comp
over
state
right
and
then
we
have
Layer
Two,
which
is
the
storage
providers
which
are
providing
zero
knowledge
proofs
onto
the
chain
and
that's
where
we
want
to
run
computation
over
data
right.
We
want
to
run
it
off
chain.
Alongside
these
storage
providers,
right.
B
With
storage
providers
they're
there
to
store
the
data,
they're
not
actually
running
any
programs
to
run
into
computations.
So
how
can
we
run
heavy
compute
off
chain?
This
is
where
the
backyard
project
comes
in,
so
bakilau
is
I,
believe
Portuguese
right,
it's
a
famous
dish
in
Portugal
salted
cod.
Funnily
enough,
so
we
had
a
a
big
file:
cooling,
Summit
and
Lisbon
back
last
October
and
I
tried
baculao
very
delicious,
but
this
speculau
is
a
framework
for
off-chain
computation
right.
B
There's
a
platform
for
fast
cost
efficient
and
secure
computation
about
running
jobs
with
the
data
is
generated
in
store.
So
you
know
right
there
by
the
storage
providers
and
if
we
look
through
their
docks
here,
you'll
see
a
bunch
of
instructions
on
like
why
bacula
was
important.
Getting
you
running
with
baculao,
really
quick.
A
B
Architecture
here
so
you
see,
Bakula
was
itself
a
decentralized
network.
It's
just
not
a
blockchain
right,
so
Baki
allow
itself
is
a
network
of
nodes
that
communicate
with
each
other,
for
instance
using
lib
P2P,
which
is
what
filecoin
and
ipfs
use
to
communicate
in
their
peer-to-peer
Networks,
and
they
run
jobs
on
this
other
decentralized
network
and
post.
The
results
on
chain
kind
of
similar
to
how
storage
providers
store
data
off
chain
and
post
proofs
on
chain
right.
B
So
one
cool
thing
you
can
do
with
bakilau
and
one
thing
I
want
to
run
through
in
a
bit
is
project
Lily,
Pad
right.
So
with
project
Lily
Pad,
you
can
actually
invoke
pakilau
from
Smart
contracts
by
emitting
an
event
so
very
similar
to
the
client
contract
we
have
which
emits
an
event
and
gets
data
stored
with
storage
providers.
Now
you
can
emit
an
event
and
have
computation
run
right
and
we'll
we'll
shoot,
we'll
see
how
we
can
Define
this
computation
in
the
second
right.
B
B
This
contract
defines
the
interp
interface
that
any
contract
that
you
make
needs
to
inherit
if
it
wants
to
run
a
job
on
bakilau
from
a
smart
contract
right
and
it's
pretty
minimum.
You
just
need
to
have
this
enum
and
two
functions
that
you
can
Define
called
Lily
Pad
fulfilled
and
Lily
Pad
canceled
right
you'll,
see
in
a
bit,
but
like
Lily
fad
fulfilled
we're
gonna,
we're
gonna
call
a
function
in
this
contract.
B
We
also
have
lilypad
events
which
you're
also
going
to
want
to
inherit.
It
defines
a
lot
more.
It's
an
upgradable
contract
using
open,
Zeppelin,
Universal,
upgradable,
proxy
structures,
and
this
gives
us
a
little
bit
more
of
that
more
of
the
like
structure
that
we're
going
to
need
in
order
to
run
these
jobs
on
chain.
B
One
of
them
is
called
stable,
diffusion
collar,
V2
right,
and
this
will
actually
call
stable
diffusion
in
vacuole
and
run
it
based
on
a
prompt
that
you
give
it
on
chain
and
return
the
CID
of
the
image
it
generates,
and
you
can
look
it
up
on
ipfs,
which
is
really
cool,
it'll
automatically
post
it
onto
ipfs,
for
you.
So.
B
Yeah
no
problem
yeah,
so
this
will
call
Lily,
Pad
or
bakilau
generate
an
image
from
a
prompt
store
that
image
on
ipfs
and
post
the
CID
of
that
image
back
on
chain,
which
is
really
cool.
So
you
can
get
you
know.
Nfts
have
a
NFC
collection
with
AI
generated
imagery
and
you
know
interact
with
this
all
on
chain.
B
B
Essentially,
this
is,
as
it
says,
ethical
generative,
AI
art
this.
You
know
one
problem
with
current
AI
art
generators
is
that
you
know
they
are.
Our
generator
goes
around
and
samples
all
of
these
artists,
styles
on
the
internet
and
then
kind
of
conglomerates
them
and
generates
art
based
on
that,
without
giving
credit
back
to
the
original
artist
and
water
lily.
Credit
is
given
to
the
specific
artist
that
the
AAA
AI
may
be
imitating
right.
B
So
it's
a
little
bit
better
for
the
artists
all
around
to
pay
them
for
the
work
that
they've
done
to
generate
these
Styles.
So
you
can
give
it
a
prompt.
It
defaults
to
a
rainbow
unicorn
in
space,
and
you
can
pick
a
specific
artist
style
that
you'd
like
you,
need
to
have
a
metamask
wallet
with
magnet
fill
in
it.
So
I'm
not
going
to
use
it
now,
but
you
can
see
some
of
the
feature
artists
in
their
art
here,
but
I
just
think
it's
a
really
cool
project.
B
B
Evm
based
chains
right-
and
so
here
we
have
the
stable
diffusion,
caller
V2
a
contract.
We
have
a
couple
of
State
variables.
The
bridge
address
now
I
didn't
talk
about
the
bridge.
The
bridge
is
an
important
contract,
make
sure
this
is
zoomed
in
too
the
bridge
is
an
important
contract,
as
it
is
really
the
contract
that
acts
as
the
the
middle
person
between
the
contract
that
we
have
here.
The
stable
diffusion
contract
caller
and
the
baculao
network
right.
B
B
We
have
this
truck
here,
for
you
know
the
image
that
it
Returns,
the
prompt
and
the
ipfs
results,
and
we
have
our
Constructor
and
the
Constructor
actually
requires
that
bridge
address
right
right,
it's
not
going
to
deploy
without
it.
We
have
to
tell
it
where
to
point-
and
this
allows
you
know
if
the
bridge
changes-
or
you
know
someone
you
know-
runs
their
own
baculao
cluster
and
creates
a
bridge
taken
post
that
address
here
instead
and
point
to
that
cluster.
B
B
B
So
if
we
go
to
well
we'll
copy
that
we'll
keep
it
for
later,
if
we
continue
scrolling
down
and
the
Lily
Pad
stable,
diffusion
collar,
we'll
see
here
that
we
have
the
spec
for
the
job,
so
Becky
Lyle
runs
all
of
his
jobs
in
Docker
or
Wazoo,
so
you
can
specify
either
one
the
job
has
to
be
added
to
to
the
backy
loud
network.
You
can
refer
to
the
baculao
docs
and
how
to
do
that,
but
we
already
have
this
table
diffusion
job
running
on
vacilau.
B
B
And
here
we
have
the
the
function
stable
diffusion.
This
is
the
magic
function
where
we'll
pass
in
a
string
and
it
will
emit
an
event,
and
actually
you
know,
take
all
that
data
and
call
lilypad
bridge
and
have
bacula
run
the
job
you'll
see
here.
It
has
a
require
statement
requiring
that
a
base
amount
of
fill
is
provided
in.
The
transaction
has
to
be
greater
than
equal
to
the
lily
pad
fee,
which
again
right
now
is
set
to
0.03
fill,
and
if
not,
the
transaction
will
revert.
B
B
A
couple
other
functions
here,
but
the
last
two
big
important
ones
are
Lily
Pad
fulfilled
so
again.
This
is
where
bakilau
will
call
this
function
if
it
has
a
successful
job,
run
and
post
the
results
in
it,
and
we
have
lilypad
canceled
where,
if
it
has
an
unsuccessful
job,
one
we'll
call
it
and
you
can
see
that
we've
inherited
and
provided
our
own
Logic
for
these
events.
Here.
B
B
So
we're
going
to
come
here
and
make
sure
that
everything
compiles
I'll
have
Auto
compile
turned
on.
So
it's
a
green
check
mark
you
can
just
the
button.
You
know.
If
you
end
up
getting
some
errors,
you
can
always
try
changing
the
compiler
version.
Two
I
see
I
get
some
error.
Sometimes,
with
that
I
find
8.17
is
a
great
compiler
version
to
set
to.
B
Now
we'll
go
one
more
to
the
deploy
and
run
transactions
tab.
This
is
the
tab
where
we
can
actually
deploy
our
contract
on
chain
and
you'll,
see
here
on
the
deploy
button
right
beside
it.
It
requires
an
address.
The
bridge
contract
address,
so
I'll
actually
Post
in
that
address
that
I
copied
earlier
for
the
bridge
contract,
0x489
4C,
we'll
double
check
to
make
sure
yep.
That
is
the
right
address.
A
B
And
you
can
click
deploy
and
I
made
a
rookie
mistake.
I
still
make
this
mistake.
Sometimes,
even
though
I've
done
this
a
million
times
right,
so
we
need
to
switch
from
remix
VM
to
injected
provider.
Metamask
and
remix.
Vm
is
essentially
a
virtual
machine
that
sits
within
the
browser
doesn't
know
anything
about
any
external
blockchains.
It's
just
for
testing,
but
we're
gonna
actually
go
through
metamask
and
my
metamask
is
pointed
to
the
hyperspace
test.
Net
right
and
so
I
already
have
some
test
fill
there's
some
tutorials
in
the
filecoin
docs.
B
B
And
you
know
now
it's
going
to
take
some
time
for
that
contractor
to
be
deployed
on
chain.
I
actually
have
another
contract.
That's
pre-deployed
that
we're
going
to
use,
but
you
know
with
file
a
coin.
It
takes
about
30
seconds
for
the
transaction
to
be
included
in
the
block,
and
final
coin
runs
with
something
called
deferred
execution.
So
after
the
transaction
is
included
in
the
Block,
it's
actually
not
executed,
for
until
the
next
block
is
added
to
the
chain.
B
B
So
here
is
all
of
the
functions
we
can
call
from
this
contract.
We
can
click.
All
images
and
you'll
see
that
there's
already
a
bunch
of
images
that
have
been
stored
from
previous
abacular
runs
a
bunch
of
this
rainbow
unicorn.
It
looks
like
a
a
corgi
having
two
with
a
king.
That
sounds
like
a
fun
image
alongside
their
ipfs
cids,
so
we
can
look
back
at
it
right
and
you'll
see
that
disable
diffusion
function
is
in
red,
which
means
it's
payable.
B
So
let's
go
find
that
right
here
yep
because
of
this
require
statement.
If
I
click
on
it
again,
you'll
see
error
not
enough
to
run
lily
pad
job,
which
is
the
error
we
got
right
here,
because
our
message
dot
value-
was
it
greater
than
or
equal
to
the
lily
pad
fee.
So
how
do
we
get
our
message.value
greater
than
that?
B
B
You
can
just
post
that
in
here,
and
so
again
this
is
going
to
be
.03
fill.
If
you
ever
wanted
to
do
like
whole
number
increments
of
fill,
you
could
switch
to
Ether
So
You
Know
Remix
is
based
around
ethereum,
but
Phil
will
be
the
unit
of
accountances
we're
connecting
to
file
coin,
and
this
would
be
like
three
billion
fill,
which
we
don't
want
to
send.
You'd
want
to
put
like
one
or
two,
but
we're
gonna
denominate
it
in
a
way
to
put
this.
So
this
is
going
to
be
0.03
fill.
B
B
Baculao
has
to
listen
for
the
job
and
it
pulls
it
periodically.
I
think
right.
Now,
it's
every
five
to
ten
minutes.
It
pulls
the
Lily
bad
Bridge
runs
the
job.
That'll
take
some
time,
then
post
the
results
back
on
chain
and
that
transaction
has
to
be
included
on
chain.
So
it
will
take
some
time
for
this
to
run
we're
not
going
to
rate
for
this
specific
job
to
run.
B
But
what
we
can
do
is
we
can
look
up
these
already
included
jobs
in
this
contract
and
see
what
images
are
generated
right.
So
these
are
all
stored
in
ipfs,
so
they're
open.
Let's
look
up
rainbow
unicorn
right,
so
I'm
going
to
copy
the
CID
for
that,
and
here
I
may
have
to
actually
share
my
whole
screen
to
really
get
this.
Why
is
it
not?
Let
me
change
the
screen
share
out.
A
B
B
Right
so
I
actually
have
the
ipfs
desktop
client
running
in
the
background,
and
we
know
we
can
hit
browse
and
find
it
here,
and
so
this
was
that
hash
that
we,
the
CID,
that
we
got
that
Bakula
had
returned
and
you'll
see
here.
It
actually
returns
a
whole
file
structure.
But
if
we
go
to
outputs
you'll
see
the
image
right
there
and
there's
the
rainbow
unicorn
a
work
of
Modern
Art
with
its
three
faces
and
yeah
beautiful,
beautiful
AI,
art.
A
A
If
they're
on
about
the
actual
transaction
hash
of
the
transaction
you
just
submitted
or
the
if
they
mean
the
CID
like
lato's
I'm,
not
sure
which
one
you're
after,
but
if
you
have
the
the
CID,
if
you
can
either
put
it
in
in
the
Discord
in
the
twitch
chat,
if
you
have
open
or
just
put
it
in
the
chat
here,
there's
a
chat
button
down
the
bottom
of
this.
You
can.
B
B
B
B
B
B
We
have
a
brand
new
computer
over
data,
starter
kit
right
so
I'll.
This
will
probably
be
where
all
of
our
examples
live
migrated
from
Lily
Pad.
You
know
we'll
see
how
we
can
do
it.
Literallypad
repo
will
probably
still
be
where
all
of
the
main
development
takes
place
and
this
isn't
actually
linked.
So
we'll
just
go
away.
A
B
A
B
B
All
right,
so
this
is
the
Cod
kit
and
I'll
zoom
in
here.
So
hopefully
it's
easier
to
see
and
just
like
the
starter
kits,
if
you
aren't
familiar
with
the
hard
hat,
starter
kits
or
the
deal
making
app
kit
or
the
data
down
kit,
it
works
very
similar
to
all
of
those.
So
if
you
want
a
little
bit
more
in
depth,
I
suggest
watching
a
tutorial
on
one
of
those
but
yeah
you
see
that
the
structures
just
like
we
saw
on
GitHub.
B
You
know
when
you
first
get
in
here,
you're
gonna
type
in
yarn
to
download
all
your
packages
hit
enter
and
then
you
can
hit
yarn
hard
hat
deploy
and
it
will
run
the
deploy
script
which
just
deploys
in
this
single,
stable,
diffusion
collar,
V2
contract,
and
it's
already
deployed
I've
already
deployed
this
and
compiled
it.
So
you
know
it
would
compile
normally
and
deploy,
but
it
says
here
it's
reusing,
the
one
that
we've
already
deployed
at
this
address.
B
B
B
So
this
is
just
doing
it
from
the
command
line
and
I
think
the
important
detail
here
is,
if
you're
not
used
to
it,
when
you
send
the
transaction,
which
is
here
in
line
25
a
weight,
stable,
diffusion,
caller
V2,
dot,
stable
diffusion,
we're
going
to
pass
in
the
prompt
from
our
task
args,
but
we
also
need
to
pass
in
that
value
right
because
again,
this
is
a
payable
function
and
it's
not
going
to
go
unless
we
pass
in
that
.03
fill
right.
So
you
can
do
that
by
creating
this
object.
B
B
And
we'll
call
this
contract
we'll
do
Dash,
Dash
pumps
and
do
awesome
the
lives
enter
and
she's
gonna
say
it's
sending
a
problem
just
able
to
Fusion
running
a
Becky
now
on
network
hyperspace
and
yeah.
This
will
go
through
and
again
you
know
30
seconds
to
get
included
30
seconds
to
execute
making
loud.
Does
it
returns
everything
just
like
we
showed
you
on
remix?
Well,
this
is
done
in
hard
hat
now
and,
of
course,
for
all
this
to
work.
B
You
want
to
also
make
sure
that
you
have
your
environment
variable
here,
your
private
key
that
you
never
show
to
anyone
else.
The
git
ignore
is
already
set
to
ignore
this,
but
it
it
needs
this.
So
it
knows
what
wallet
to
use
when
transacting
on
chain
and
yeah.
So
this
is
just
a
you
know.
A
brief
introduction
to
the
Cod
starter
kit
excited
to
see
where
it
goes
from
here.
A
B
B
And
some
more
of
our
app
kits
if
you're
hacking
in
the
hackathon
and
want
some
inspiration,
there's
the
data
down
app
kit,
The,
Foundry,
starter
kit,
the
hard
hat
starter
kit
and
the
starter
kits
just
have
very
basic
contracts
in
them
to
get.
You
started
interacting
nothing's
too
specific
the
deal
making
app
kit.
This
is
a
kit
specifically
for
making
deals
using
that
client
contract
I
said
earlier.
B
B
A
A
B
Exactly
if
you
like,
yeah,
you
got
it
like,
the
transaction
will
go
through
and
it
when
it's
done.
It's
just
done
in
an
admitted
event
right.
So
that's
when
that
that
transaction
is
done.
When
you
call
the
stable
diffusion
but
then
yeah
back,
then
I
will
run
in
when
it
recalls
either
the
you
know,
job
fulfilled
or
the
job
canceled
it'll
return
like
a
job.
Id
and
it'll
return
an
image
and
sort
that
data
and
instruct
our
array
on
the
smart
contract
itself.
A
A
A
B
Yeah
yep
yeah,
so
you
can
go
to
the
baculao
docs
and
they
teach
you
how
to
like.
Add
your
own
job
to
vacuile
like
the
network,
and
you
know
all
you
have
to
do
so,
like
the
Lively
pad
caller
contract,
that
is
in
the
kit
and
in
Lily
Pad,
that
just
kind
of
defines
like
it's
just
an
example
to
show
you
how
you
can
make
your
own
contract
right.
You
can
make
your
own
contract,
you
can
reference
a
different
job.
That's
not
stable
diffusion
and
you
know
make
that
call.
B
A
So
you
know,
if
you
want
to
kind
of
find
out
more
kind
of
in
person,
then
then
certainly
come
along
to
that.
There's
going
to
be
a
whole
load
of
stuff
about
computer
data,
Hollow
stuff
about
Pacquiao
I'm.
Just
going
to
put
the
put
the
link
in
the
chat
as
well
so
yeah
there's
one
more
one
more
comment
from
Nick
as
well
a
question
from
Nick:
is
it
possible?
Do
we
have
to
run
backy
owl?
So,
no,
you
don't
have
to
run
your
own
node.
B
A
Right-
and
this
is
another
area
where,
like
Pacquiao
and
the
and
and
fvm,
are
quite
well
suited
to
each
other,
because
again,
bacchial
doesn't
have
any
like
inbuilt
payment
mechanism
or
anything
like
that
right
within
it.
So
using
tools
like
fem
and
using
things
like
this,
you
can
actually,
then
you
know,
pay
out
and
reward
the
you
know:
compute
providers,
all
the
content
creators.
In
the
case
of
this
case,
you
know
various
things
you
can.
A
B
A
So
it's
just
you
know
if
you've
got
a
large
amount
of
data,
sometimes
just
literally
loading
it
into
something
like
ipfs
can
take
some
time
and
there
is
using
backyard
to
do
that
in
a
kind
of
a
decentralized
fashion.
They
had
a
whole
bunch
of
data
that
needed
to
be
uploaded,
and
so
they
used
that
which
is
pretty
cool.
Yeah.
B
Those
things
really
like
excite
me
because
it's
like
you
know
on
chain,
you
can
do
a
lot,
but
you're
also
limited
by
all
the
the
limited
resources
on
chain
right.
All
these
nodes
have
to
be
run
all
this
data,
and
you
can't
do
these
like
kind
of
things
completely
on
chain
or
it'll,
be
way
too
cost
prohibitive.
So
yeah.
These
kind
of
ideas
like
open
up
a
whole
new
realm
of
possibilities
and
I'm
excited
to
see
like
where
people
take
this
and
the
cool
things
they
come
up
with.
A
So
you
know
your
compute
job,
you
know
unless
it's
something
very,
very,
very
trivial
is
going
to
cost.
You
know
an
exorbitant
amount
in
terms
of
gas
fees
and
may
not
even
you
know,
you
may
not
even
have
enough
compute
sort
of
time
and
Power
in
which
to
run
that
job.
If
you
think
about
it
on
a
blockchain,
you
know
if
each
block
in
the
case
of
filecoin
each
block
is
only
30
seconds.
That
means
no
compute
job
could
ever
last
longer
than
30
seconds
or
you
know
and
be
included
in
a
block
right.
A
So
so
that's
why
things
on
Smart
contracts
are
very
you
know
simple
they're
sandboxed
they're
restricted
in
what
they
what
they
do,
because
they
can't
hold
the
chain
up,
whereas
you
know
with
something
like
Baka
Yao
you're
able
to
do
this
off-chain
compute.
So
if
you've
got
some
processing
tasks,
you
know
some
big
data
processing
tasks
that
is
going
to
take
hours
to
run.
A
Then
you
can
run
that
on
backy
out
and
then
just
report
the
status
of
that
back
to
Fem
and
then
use
you
know
fem
as
the
kind
of
like
the
controller,
the
mechanism
by
which
you
know
these
things
are
orchestrated
paid
for
verified
or
validated
whatever
it
might
be.
You
know
you
could
run
a
compute
job
on
on
Pacquiao
and
then
get
fem
to
Mint,
say
some
sort
of
like
certificate
as
an
as
an
nft.
That
basically
gives
some
sort
of
stamp
of.
A
You
know
approval
that
that
job
has
happened
at
a
particular
time
or
was
run
on
a
particular
node
or
whatever
it
might
be.
So
you
could
actually
use
that
as
like
a
a
certification
process
on
top
of
the
actual
compute
process.
It's
done
on
Pacquiao,
so
yeah
that
stuff's
really
cool.
That
was
a
really
cool
demo
Zach.
Thank
you
very
much
to
see
that
so,
okay,
so
coming
up
in
a
bit,
we've
got
about
five
minutes
or
so
I
think
until
the
next
speaker
that's
coming
up.
A
So
the
next
chat
that
we've
got
is
Stephen.
That's
coming
up
from
axlea,
that's
going
to
be
talking
about
axler,
so
just
waiting
on
that.
So
why
don't
people
if
you
want
hop
off,
go
and
get
yourself
a
drink,
bathroom
break
whatever,
and
hopefully
we'll
be
back
in
about
five
minutes?
I'm
just
gonna
leave
the
stream
running
so
I'm
gonna.
Do
that
and
then
see
you
back,
but
thanks
a
lot
Zach.