►
From YouTube: The Graph | Core Devs Call #18
Description
The Graph is an indexing protocol for querying networks like Ethereum and IPFS. Anyone can build and publish open APIs, called subgraphs, making data easily accessible.
The Graph Core Devs coordinate work using the publicly accessible The Graph Core R&D Workspace: [https://thegraphfoundation.notion.sit](https://thegraphfoundation.notion.sit/)...
Timestamps
00:00 Intro
04:13 L2 Support
13:30 File Data Sources
25:28 Subgraph Bridge
40:57 Substreams
Link to external sources mentioned in the call:
L2 Support: [https://thegraph.com/blog/mips-multi-](https://thegraph.com/blog/mips-multi-)...
File Data Sources: [https://forum.thegraph.com/t/grc-001-](https://forum.thegraph.com/t/grc-001-)...
Substreams: [https://substreams.streamingfast.io/](https://substreams.streamingfast.io/)
Need help migrating subgraphs to the network? Here's a complete tutorial: [https://thegraph.com/blog/how-to-migr](https://thegraph.com/blog/how-to-migr)...
Feel free to reach out if you need help: migration@thegraph.foundation
Follow The Graph on social media
Twitter: https://twitter.com/graphprotocol
Instagram: https://instagram.com/graphprotocol
LinkedIn: https://www.linkedin.com/company/thegraph/
GitHub: https://github.com/graphprotocol
Website: https://thegraph.com
A
Nice
all
right,
hey
everyone!
Welcome
back
to
our
18th
core
Dev,
School
I,
think
it's
been
almost
two
months
since
we've
been
having
these
with
holidays
and
busy
January.
It's
been
a
while,
since
this
last
public
call
but
yeah
regardless
there's
been
lots
of
progress
and
we'll
continue
with
this
cause
in
four
weeks.
A
Everything
is
out
there
in
the
open,
so
you're
free
to
continue
discussing
this
async
and
yeah.
We
don't
want
to
hear
your
feedback
and
questions
as
always
so
I'll
paste
in
the
chat
in
show
notes
also
the
link
to
the
graphs
ecosystem
calendar
so
that
you
can
be
subscribed
to
all
future
public
or
Dev
calls,
and
these
are
uploaded
to
YouTube
and
I.
Think
I
mentioned
that
before
so
that's
yeah
I
forgot
to
change
my
slide.
That's
pretty
much!
It
I'm
going
to
check
the
links,
and
now,
let's
go
quickly
through
the
agenda.
A
It's
going
to
be
Fact
one,
so
yeah.
First,
we've
been
talking
about
the
graph
Network
scaling
on
an
L2
through
arbit
room,
and
we
recently
hit
nice
set
of
Milestones,
so
we'll
be
hearing
from
Pablo
and
Nana,
both
from
Azure
node
on
when,
where
we
are
currently
with
this,
my
migration
and
what's
coming
to
products
such
as
the
the
graph
Explorer
2.,
so
another
big
milestone
for
subgraph
developers
and,
let's
say
data
consumers
in
general
is
or
our
support
for
file
data
sources
and
Leo.
A
Also
from
Azure
node
will
go
over
this
new
feature
in
the
past,
we've
been
having
Adam
going
on
to
these
calls,
also
explaining
what
this
would
be.
We're
now
super
close
to
shipping
it
so
we're
going
to
have
a
nice
demo
and
yeah
we'll
go
over.
These
new
feature
supports
for
off-chain
data
data
of
like
ipfs
and
others
and
yeah
we'll
get
to
know
when
exactly
this
is
coming
to
graph
mode.
So,
thirdly,
we
have
Soul
Bond
labs.
A
This
is
a
team,
that's
that
it's
a
grantee,
that's
been
building
on
the
graph
for
quite
some
time
already,
and
they
will
also
be
demoing,
a
new
paradigm
called
subgraph
Bridge,
which
essentially
allows
offloading
of
computation
to
the
graph
Network,
while
also
bridging
back
the
state
to
on
chain.
So
it's
pretty
cool
and
Alexander
is
with
us
too,
and
is
going
to
do
a
is
going
to
talk
a
little
bit
about
it.
Explain
it,
but
the
value
prop
is
what
the
use
case
is.
It
unlocks
are,
and
also
do
a
nice
demo.
A
And
finally,
such
streams
we've
been
talking
about
this
for
for
a
while,
hey
Alex.
This
is
truly
a
cross-functional
effort
by
different
teams.
Streaming
fast
edges,
node,
I'm,
sorry,
the
guild
pinx
I
mean
pretty
much
all
teams
that
have
been
working
on
this
and
different
things.
Like
core
functionality,
tooling
development
experience,
docs
support
for
new
things,
there's
plenty
of
stuff
coming
and
so
today,
I
think
this
will
be
yeah.
A
This
will
be
led
for
the
by
the
by
the
streaming
fast
team
and
we're
going
to
take
some
time
to
hear
all
about
the
major
Milestones
so
far
and
yeah
again,
hopefully,
we'll
have
time
to
do
some
brainstorming,
q,
a
and
hear
from
you
community
members
on
what
you
would
like
to
see
next
and
your
questions
on
all
of
these.
So
that's
it.
Let's
move
enough
of
me.
Let's
get
into
it,
I
think
we're
starting
with
L2
and
that's
Nana
right.
A
B
All
right
cool
morning,
everybody
I
am
just
going
to
do
a
quick
demo
of
the
products.
All
right.
Can
everybody
see
my
screen,
yep
awesome
cool,
so
what
we
are
doing
to
enable
L2
supporting
our
products,
so
we
already
released
it
on
testnet.
So
we
have
this
network
switcher.
It's
allowed
to
switch
the
entire
Explorer
to
Arbitron
Gurley,
and
then
you
can
access
different
subgraphs.
B
So
we
have
different
things
here
and
if
you
switch
back,
for
example,
we'll
take
you
to
the
ethereum
girly
subgraphs,
because
it's
a
difference
of
pretty
the
same
with
participants.
Basically
on
whatever
page
you
are,
you
can
essentially
run
the
whole
app
in
arbitrum
and
see
all
the
things
are
going
on
there
on
in
studio
you
can
publish.
Let
me
find
one
of
the
softgress
that
I
just
deployed.
B
You
can
publish
a
subgraph,
it's
something
weird.
This
Zoom
is
slowing
down
the
app.
Let's
try
this
one,
maybe
I've
just
uncovered
a
buck.
No,
it's
working!
Okay,
cool!
Sorry!
Let
me
move
these
out
of
the
way.
So
here
you
can
publish,
there's
several
options
and,
given
that
I'm,
an
admin
I
see
these
extra
options,
but
essentially
for
now
you
can
publish
the
arbitrary
in
addition
to
other
networks,
so
keep
in
mind
once
we
do
arbitrine
one
once
this
is
all
going
to
be.
A
B
A
C
C
C
The
Gateway
oracles.
Everything
else
is
slowly
building
up
into
having
a
fully
working
thing
and
for
stage
two
we
need
to
enable
indexing
rewards.
This
is
not
straightforward.
This
is
the
diagram
that
I'm,
showing
there
I'm,
not
gonna,
go
into
detail
into
how
how
it
works,
but
basically
we're
going
to
be
minting
GRT
for
the
rewards
on
both
sides,
and
this
is
cap37,
which
you
can
check
out
in
the
forums.
If
you
want
the
pr
for
that,
all
of
the
changes
to
the
contract
are
ready.
C
They've
been
audited,
we're
ready
to
go
we're
just
going
through
the
formal
testing
to
make
sure
everything
works
properly
and
checking
off
all
of
the
items
in
the
checklist
of
all
of
the
stage,
one
testing
getting
all
of
the
infrastructure,
ready
and
the
products
and
so
on,
and
once
that
is
done,
we'll
put
this
forward
to
the
council
for
actually
deploying
these
contract
changes
and
then
finally,
the
migration
helpers.
That
means
so
we
have
a
protocol
on
all
two.
C
We
have
a
protocol
on
a
one
right
now,
if
you
wanna,
if
you're
an
indexer
and
you
wanna,
move
your
stakeover
tool.
2
you'd
have
to
unstake
bridge
the
GRT,
then
stay
tunnel
2
and
same
if
you're,
a
delegator
or
a
curator.
You
have
to
you,
know,
remove
the
tokens
from
the
contracts
Bridge
them
over
and
then
put
them
in
L2,
and
we
want
to
provide
easier
ways
to
do
that,
but
maybe
one
or
two
transactions,
so
we've
got
the
contracts
for
that
we've
developed
most
of
it.
C
We're
still
doing
some
some
fixes
and
changes
and
trying
to
get
that
ready
for
audits,
but
hopefully
we're
gonna
go
through
that
process.
Soon
and
all
of
the
testing
and
everything
so
that
soon
after
the
the
stage
two
contracts
are
deployed
and
and
all
of
the
product
side
is
ready,
we
should
be
able
to
provide
helpers
as
well,
so
that
yeah
people
can
actually
move
our
tool
2
in
the
easiest
way
possible.
C
C
We're
hoping
that
soon
after
these
missions
on
how
to
test
net
we're
also
going
to
do
missions
on
auto
mainnet.
That
is
return
one
so
that,
through
that,
if
things
go
well
and
the
participants
decide
to
stay
there,
we'll
also
be
bootstrapping
some
index
Arsenal
too,
so
that
once
we
we
have
the
contracts
and
the
products
and
the
infrastructure
already.
We
also
have
some
indexers
actually
serving
subgraphs
there,
so
yeah
I,
that's
all
I,
have
any
questions,
or
you
can
obviously
find
me
in
Discord
as
well,
in
the
forums
foreign.
A
A
D
So
that's
a
that's
very
requested
and
it's
great
because
you
know
we're
known
for
being
great
for
thinking
on
chain
data
from
multiple
chains,
but
you
know
the
apps
increasingly
have
needs
to
incorporate
off-chain
data,
so
you
know
nft
metadata
dollar
proposal,
social
posts.
All
of
those
things
are
stored
off
chain,
of
course,
to
to
save
on
gas
costs,
so
file
data
sources
delivers
that
for
subgraphs,
initially
supporting
FPS.
But
you
know
it's
designed
to
be
extensible
to
supporting
other
networks
such
as.
Are
we
even
so
on?
D
There
was
like
a
sort
of
experimental
support
with
an
API
called
ipfs
cat.
If
you
know
what
that
was,
but
this
is
supposed
to
replace
that
because
it
offers
more
determination
guarantees
as
we're
going
to
see-
and
it's
also
just
just
bad
overall.
So
this
is
like
the
architecture
of
how
this
works
in
graph
node.
So
you
have
the
data
coming
from
from
the
chain,
so
you
have
a
trigger,
that's
an
event
trigger
on
ethereum
and
that's
going
to
create
a
file
data
source
based
on
the
CID.
D
So
for
determinism
there
are
a
few
restrictions
to
make
because
you
never
know
when
a
file
is
going
to
be
found
right
or
the
origin
which
they're
going
to
be
processed.
But
still
you
need
the
results
of
in
indexing
to
be
reproducible,
so
these
are
the
the
rules
and
sort
of
limitations
which
are
necessary
to
enforce
that.
D
So
an
entity,
that's
created
by
a
cloud
data
source
is
immutable
of
how
their
Source
Handler
cannot
access
entities
from
anywhere
else
from
India
from
another
cloud
data
source
or
from
the
on-chain
data
and
the
also
like
the
file
data
source,
and
it
cannot
be
accessed
by
the
on-change
data
sources
so
yeah.
So
this
is
so.
That
means
like
the
idea
is
pretty
isolated
so
that
the
data
from
off
chain
their
sources
did
not
get
mixed
up
in
non-deterministic
orderings.
D
But
even
then
you
still
don't
know
if
the
file
is
available
or
not
right,
so
to
get
determinism
around
that
we're
going
to
need
some
form
of
Oracle
for
the
availability
of
these
files,
which
is
a
future
design,
a
future
step
into
getting
through
determinism.
For
this
feature,
so
let's
go
to
the
demo.
D
So
I've
got
here
a
subgraph
which
is
in
this
case
thinking
locally,
but
still
enough
is
going
to
be
able
to
sync
it
on
on
the
network
or,
and
it's
a
subgraph
for
the
for.
The
purpose
of
the
demo
is
for
the
crypto
coven
nft,
the
app.
So
you
know,
nfcs
are
a
major
use
case
for
this
feature,
so
the
crypto
Kevin,
the
app
is
about
witches,
so
the
the
nfcs
are
witches
and
they've
got
nice
little
attributes
such
as
the
astrological
chart
types
and
so
on
so
yeah.
D
So
we
have
a
subject
for
that
which
we've,
which
we
have
migrated
to
the
new
cloud
data
sources
API.
So
what
does
it
look
like?
So
here
you
have
your
ordinary
data
sources
from
listen
to
the
ethereum
contracts
for
this
for
the
crypto
coven
nfts-
and
here
you
this
is.
This
is
new
right.
This
is
a
template
of
kind
file
ipfs.
So
this
is
the
biod
sources
template
and
it's
going
to
be
called
the
handle
media
data
Handler
whenever
it
finds
an
the
file
on
my
PSS.
D
So
what
the
Handler
looks
like
here,
we
have
the
handle
transfer
for
the
nft
nfts
tokens,
so
so
this
is
happening
on
chain.
So
if
the
token
has
not
had
never
been
seen
before
on
a
transfer
you're
going
to
create
here,
a
new
file
data
source,
that's
going
to
listen
to
it
right.
So
there's
that
template
that
we
just
saw,
which
is
inside
the
resource,
template
and
also
cool
here,
you
can
see
that
it's
actually
accessing
a
file
within
an
IPS
test
directory.
D
So
this
is
also
supporting
directory
directories
on
this
first
release:
a
file
within
a
directory,
and
it's
a
Json
file
right.
So
this
is
going
to
happen
on
chain
and
you
create
this
data
source.
But
then
this
does
not
block
the
progress
of
the
syncing
of
the
subgraph.
The
subgraph
continues
to
sync
on
chain
normally
and
then
asynchronously
when
when
the
file
is
found,
this
handle
is
going
to
be
called
right
with
the
contents
of
the
file.
D
So
these
are
Json
files,
so
we're
going
to
parse
the
Json
here
and
then
this
contains
all
of
the
nice
details
of
the
specific
nft
emitter
data.
So,
in
this
case,
as
we
just
saw,
the
The
Witches
have
astrological
birth
chart,
so
you
can
get
the
where
the
sun,
moon
and
and
so
on.
Yes,
so
so
now
this
you
create
this
entities.
D
They
they
go
into
your
sub
graph,
and
now
you
can
query
them
in
the
in
the
graphql
API
the
opt-in
and
launching
anys
together,
and
this
isn't
going
to
demo
next
to
queries,
and
this
is
cool
because
it
also
showcases
another
feature.
Another
major
feature
which
is
shipping
on
the
next
graph
of
release,
which
is
child
filters,
which
is
also
long
being
requested,
and
it's
also
very
powerful
and
plays
very
well
without
data
sources.
So
here
I
can
query
just
sort
of
the
the
list
of
all
the
nft
tokens.
D
The
which
name
and
the
astrological
chart
data
and
sort
of
the
basic
token
ID,
and
what
I
can
do
I
can
filter
this
now
using
child
filters
by
the
the
properties
of
the
metadata
so
like
by
those
restrictions
of
the
of
the
the
restrictions
of
the
file
data
source
determinism.
I
could
not
have
all
of
the
all
of
these
these
fields
in
a
single
entity
right,
it
must
be
split.
The
token
meter
data
must
be
a
separate
entity,
but
that's
not
a
problem,
because
we
can
use
shell
filter
to
query
it.
D
So
I
I
want
to
query
here.
I
want
to
find
all
of
the
witches
which
have
the
their
sun
in
Leo,
their
Moon
Neo
and
their
Rising,
whatever
that
is
in
Leo
as
well.
So
you
know
so:
I'm
gonna
get
a
cryptocurren
which
this
is
the
one
that
I
want
to
get
and
I've
probably
messed
something.
Oh
yeah,
so
I
just
need
to
add
this
here.
Okay
still
doesn't
like
it.
Why
not?
D
Well,
the
demo
gods
are
against
me.
I
just
tried
this
opposite
in
times.
Oh,
it's
called
ipfs
you're
right,
not
token
URI,
okay,
there
you
go.
Aha,
there
you
go.
So
these
are
all
the
Witch
of
the
chapter.
Three
astrological
characteristics
on
Neo,
so
I
can
pick
one
of
these.
So
let's
say:
oh
okay,
volcano
the
raw
missile.
D
This
sounds
cool,
so
I
can
go
here
and
just
pick
that
which
by
ID
and
there
it
is
so
now,
if
you're,
building
a
an
ft
if
front
end,
you
can,
you
know,
integrate
with
a
sub
graph
and
you
can
have
that
super
powerful
search
functionality
by
the
metadata
based
on
the
centralized
infrastructure,
because
it's
going
to
be
available
on
the
essentialized
network
very
soon,
as
you're
looking
to
get
a
new
graph
and
release
waiting
for
next
week.
Currently
yeah
and
that's
my
demo.
A
D
E
A
Would
be
here,
Simone,
just
I
just
want
to
add
something
which
is
the
foundation
is
also
trying
to
RFP
this
particular
r
with
integration,
because
it's
as
Leo
mentioned,
it's
super
extensible,
so
it's
easy
to
plug
in
another
data
sources.
Let's
say
following
this
APL.
So
if,
if
there's
anyone,
that's
that
wants
to
do
this
work,
please
reach
out
to
me
and.
D
D
E
Okay
and
then
a
use
case,
I
think
that
cannot
be
solved
if
the
current
implementation
is
it's
very
common
for
nfts
that
we
say
like,
for
example,
the
moon
Leo,
like
only
10
out
of
or
like
in
a
percentage
of
the
of
the
total
collection.
How
many
have
that
particular
trade
that
would
would
need
to
be
stored
currently
on
indexing
time?
I?
Think
it's
almost
impossible
to
do
its
own
query
time,
but
because
of
this
cross
references
it
that
you
cannot
load
another
entity,
it's
hard
to
get
that
out.
D
Yes,
definitely
the
right.
We
currently
don't
have
applications
in
the
API,
so
you
recommend
that
you
do
it
like
at
indexing
time,
but
these
restrictions
would
basically
impede
you
from
doing
it
at
indexing
time,
so
yeah.
That
would
be
that
sort
of
functionality
will
be
blocking
on
the
query.
Time
solution
welcome.
A
F
Yeah,
let's
hope
that's
always
the
that's
always
the
hope,
so
I
don't
have
a
nice
PowerPoint
or
anything,
but
I'm
just
going
to
talk
for
a
few
minutes
and
get
some
background
to
this
so
hi.
My
name
is
Alexander
gusev
I'm,
a
engineer
at
soulbound
labs
and
together
we
built
the
thumb
graph
Bridge,
which
is
a
way
to
use
subgraphs
as
a
data
source
for
smart
contracts,
as
well
as
offload
computation
and
use
the
graphs
Network
as
an
L2.
F
Some
more
I
want
to
give
a
special
thanks
to
Adam
Fuller,
as
well
as
the
people
at
semiotic,
because
they
helped
us
quite
a
bit
answering
some
of
the
more
lower
level
questions
with
graph
node
for
generating
some
of
the
cids
and
and
whatnot
so
yeah
a
little
bit
of
background.
So
I
work
for
a
company
called
solvon
Labs,
as
Pedro
said
earlier,
we've
been
working
with
the
and
building
on
the
graphs
ecosystem
for
a
little
while
now
and
we're
trying
to
build
on-chain
reputation
tooling
for
Dows.
F
So
this
means
tracking
certain
types
of
on-chain
behavior,
which
can
be
defined
by
a
Dao
and
reward
said
Behavior,
with
either
positive
or
negative
reputation
to
determine
voting
power.
You
know
for
or
against
proposals
without
using
normal
erc20
token
Podium,
and
we
found
that
subgraphs
are
the
best
way
to
track
on-chained
data
to
reward
with
said
voting
power.
F
We
even
built
a
little
no
code
GUI
to
make
building
replication,
subgraphs
easier
and
more
accessible
for
people,
but
there's
one
problem,
which
is
that
subgraphs
are
still
technically
off
chain,
and
so
we
needed
a
way
to
put
them
back
on
Jane,
and
so
traditionally
you
would
be
like.
Oh
okay,
we
want
to
get
data
off
thing
and
we
want
to
put
it
on
chain.
We
should
just
use
like
an
oracle
service,
something
like
chain
link
or
anything
else,
and
those
are
fine,
like
those
are
a
valid
option
for
bridge
and
data.
F
However,
we
thought
that
there
is
a
better
way
to
do
this
because
of
the
crypto
Economic
Security
guarantees
that
the
graphs
Network
already
has
in
place,
and
so
basically,
we
built
a
bridge
which
provides
no
extra
cost
to
for
users
to
use
to
just
access
their
subgraph
data
on
chain,
with
a
few
Hoops
jumped
through
and
so
kind
of
the
the
mechanism
of
the
bridge.
This.
F
F
Who
has
an
eligible
amount
to
stake
as
well
as
a
that's
the
correct
subgraph
of
your
specific
querying
for
and
then
this
freeze
period
begins,
which
is
sort
of
similar
to
how
optimism
or
any
of
these
other
optimistic
rollups
work
where
there's
a
dispute
window
and
after
this
dispute
window,
it
is
free
for
anybody
to
three
for
anyone
to
use
and
so
I'll
go
ahead
and
share
my
screen
now
and
we
can
give
a
demo
of
how
this
all
works.
So
let
me
go
ahead
and
share
my
screen.
Everyone
see
it.
F
So,
let's
create
a
bridge.
So
the
way
to
create
a
bridge
is,
we
click
the
create
Bridge
button
and
we
select
which
blockchain
we'd
like
to
make
it
to,
and
we
the
first
bit
is.
We
need
to
have
a
subgraph
deployment
ID,
which
is
a
subgraph
that
we're
actually
creating
from,
and
so
we
can
go
over
here
to
the
test
net
subgraph
Explorer
and
find
some
subgraph
if
it
loads
in
a
second.
F
F
We
used
block
hash
to
prevent
against
reorganizations
messing
up
the
query,
results
and
also
to
add
deterministic
query
results
because
subdrops
are
deterministic,
and
so
the
request,
identifier,
that
you
have
for
a
query
at
a
block,
hash
or
a
block
number,
will
always
be
the
same
as
well
as
the
response.
Data
should
ideally
always
be
the
same
unless
an
indexer
is
serving
incorrect
or
bad
data,
and
so
for
here,
I
already
have
made
a
couple
ones
for
this
subgraph,
and
so
we
can
grab
some
factories
and
we
can
grab.
F
F
Subgraphs
have
a
very
low
percentage
of
bad
requests,
and
so,
where
security
isn't
the
utmost
concern,
the
immediate
Fidelity
is
more
than
acceptable
because,
again
we
do
all
these
tracks
in
the
smart
contract
itself,
to
prevent
people
from
spoofing
it
or
serving
data
which
didn't
actually
exist
in
the
subgraph.
It
does
a
lot
of
checks
under
the
hood
to
make
sure
that
the
data
it's
receiving
is
coming
from
an
indexer.
F
The
signature
is
all
valid
Etc,
and
so
the
dispute
window
is
there
to
determine
how
long
people
should
have
to
wait
and
so
I'm
not
going
to
worry
about
sending
transactions
or
anything,
because
I
don't
have
to
deal
with
that
awkward
ux
when
we're
getting
this
demo
and
so
I
have
this
pre-made
one.
So
we
can
see.
F
This
is
not
good.
We
don't
want
like
these
should
be
the
exact
same
query
response,
let's
figure
out
what's
going
on
and
then
finally,
once
that
has
been
settled,
it
is
eligible
to
be
certified
and
the
incorrect
proposal
is
removed
from
the
queue
and
so
to
certify
the
subgraph
response
data.
We
just
go
ahead
and
click
certify,
which
then
we
can
send
the
transaction
I'm.
F
F
F
A
Now
it's
good
at
all.
This
is
recorded.
We
can
always
go
back
like
I've
seen
this
probably
three
times
already,
but
there's
always
something
new
and
it's
there's
a
lot
going
on
there.
But
it's
extremely
interesting
I
guess:
did
you
cover
what
sort
of
use
cases
you're
aiming
for
and
are
you
said,
reputation
right.
F
Yeah
so,
as
far
as
use
cases
go,
I
think
some
of
the
obvious
ones
that
come
to
my
mind,
are
offloading
computation
and
also
having
kind
of
dynamic
data
sources
so
for
reputation.
This
is
particularly
nice
because
if
we
are
defining
a
set
of
sold
out
nfts
which
can
be
used
to
represent
voting
power
in
a
dow,
we
can
Define
how
those
should
be
tracked
in
the
subgraph,
and
then
we
can
merkalize
all
eligible
users
and
put
them
on
chain,
and
then
we
can
have
a
static,
fixed
piece
that
updates
as
the
subgraph
indexes.
F
So
anyone
can
Bridge
the
subgraph
bridge
data
over,
because
we
specify
this
query
and
if
it
passes
all
the
security
checks
that
we
have
it's
eligible
for
use
and
so
there's
no
sort
of
like
manual
overrides
that
need
to
be
done.
There's
no
admin
control
that
has
to
be
done.
We
can
specify
how
this
should
be
done.
You
know
how
how
we
use
reputation,
badges
should
be
awarded
and
we
submit
them
out
to
people.
F
I
think
that
it's
also
pretty
interesting
as
well.
I
think
mercilization
is
a
pretty
powerful
primitive
in
this
sort
of
case,
because
you
can
do
a
lot
of
cool,
weird
computation
in
the
subgraph
that
you,
it
would
kind
of
be
unfeasible
or
perhaps
even
impossible
to
do
on
chain
in
any
sort
of
gas,
efficient
manner
so
yeah
and
the
first
one
that
comes
to
mind,
though
obviously
is
reputation
or
any
sort
of
batched
group
in
that
you
want
to
use
as
a
sub
graph.
Actually,
that's
not
entirely
true.
F
There
is
one
thing
which
I
think
is
very
powerful.
This
technically
does
enable
composable
subgraphs,
because
you
can
use
subgraph
responses
and
which
do
get
emitted
from
the
subgraph
bridge
itself,
so
you
can
actually
use
subgraph
bridge
data
as
a
source,
so
you
can
kind
of
have
weird
composable
subgraphs
without
needing
composable
subgraphs,
because
you
have
subgraphs
which
are
being
bridged
back
on
chain.
So
that's
actually
another
really
cool
thing.
I'm
excited
about.
A
It's
all
about
Legos
right
if
the
data
is
like
we've
seen
with
defying
these
money
labels,
but
bridging
all
of
this
stuff
on
chain
and
then
just
unfurl,
the
Merkle
rules
or
whatever
it's
it's
pretty.
It's
pretty
cool
yeah
raise
your
hands.
If
you
want
to
ask
questions
to
Alexander,
if
not
we'll
move
forward,
I
know
right
on
time.
Super
happy.
A
No
questions
cool,
you
know
how
to
reach
the
solvonne
labs
team
yeah.
Please
feel
free
to
share
all
of
the
links
you
just
mentioned
here.
The
GitHub
repo,
the
dogs
and
then
take
a
look
and
I'll.
Also
add
it
to
the
to
the
show
notes:
okay,
I
see,
Alex
is
leaving
so
I'm
gonna
call
him
out
Alex
you
ready
for
some
streams.
Yeah
thanks,
Alexander.
G
Good
morning,
the
graph
so
I
wanted
to
just
show
a
few
things
and
a
few
news,
because
it's
been
a
while,
since
we've
synced
up
about
mostly
substantly
going
to
do
a
new
around
there's
been
a
lot
of
improvements
to
the
documentation.
So
you
can
take
a
look
at
this
website
here.
Substreamstreaming
fast.io
then
revamped
quite
a
bit
a
lot
more
information,
references
and
stuff
for
you
to
consume.
Okay
and
one
important
thing
that
we
added
there
is
the
production
mode.
G
So
you
have
in
the
change
log
here
all
the
details
of
what
it
means
to
have
production
versus
development
mode.
I
want
to
give
you
a
quick
overview
of
that,
because
that
was
you
know.
The
promise
of
substreams
were
to
to
synchronize
the
chain
a
thousand
times
faster.
Okay,
that's
the
goal,
and,
prior
to
like
a
few
weeks
back,
we
had
done
parallelized
processing
of
the
history
prior
to
the
point
where
you're
streaming.
That
would
mean,
if
you
want
to
stream
at
block
12
million.
G
We
would
do
parallel
processing
for
everything
before,
but
then
it
would
be
linear,
okay,
but
that's
not
how
the
graph
node
expects
information.
The
graph
node,
for
example,
if
we
want
to
have
sub
graphs,
needs
to
have
forward
pressing.
We
want
to
stream
everything.
So
that's
what
we
did
we
implemented.
We
call
that
forward
parallel
processing,
meaning
you
can
start
at
the
beginning
and
the
work
is
being
done
in
parallel,
while
you're
streaming
out
everything
that's
coming
through
as
fast
as
possible.
G
Okay,
so
production
mode
also
means
that
we've
made
some
a
few
more
constraints
to
make
it
fast.
You
can
only
specify
one
module:
a
mapper
module
as
an
output
thing
now
and
if
you're
in
development
mode
there's
a
few
things
that
change
now
is
that
we
will
send
you
all
of
the
modules
outputs
plus
logs
they're,
now
debug
output,
stuff,
you
don't
rely
on
these
things
for
production
production.
You
rely
on
the
output
of
you
know
only
the
mapper
module
you're
interested
in
okay.
G
So
that's
the
shift
and
I
want
to
demo
you
a
little
thing
that
I
haven't
even
shown
to
the
team.
Here,
a
GUI
I've
been
prototyping
that
shows
the
production
mode
like
on
steroids.
Let
me
show
that
to
you,
it's
like
it's!
It's
Half
Baked!
Since
yesterday.
Okay,
it's
not
done
so
you'll
see
it's
really
quirky,
but
this
is
a
new
function.
You'll
get
on
on
the
GUI
here
in
the
substream's
command
line,
gooey
and
it'll
open
that
little
thing
here.
G
Hopefully
that
works
I,
don't
know
if
you
see
that
this
is
like
processing
in
forward
fashion
and
you've
already
received
payloads.
You
know
you
see
that
this
is
streaming
out
to
you
as
fast
as
possible,
because
it's
probably
using
the
cache
or
using
paralyzed.
You
know
engine,
that's
once
it's
done,
you
see
get
a
batch
of
blocks
and
eventually,
when
you
have
the
paralyzed
engine,
that's
covered
the
blocks
you're
after
it
would
just
saturate
your
pipe
like
that
and
I.
Don't
know
if
you're
looking
at
here,
but
we're
seeing
the
the
GUI
in
action.
G
G
G
So
you're
used
to
that,
but
now
you
can
switch
to
the
output
view
or
back
to
the
pro
progress
key
with
the
Tab
Key.
Isn't
that
neat
okay
and
then
with
a
simple
demo
here,
you'll
see
that
you
can
have
outputs
and
you
can
also
navigate
between
the
modules.
Look,
you
see
how
the
factory
module
here
and
with
the
key
you
and
I,
you
can
switch
from
module,
but
that
doesn't
change
the
block
at
which
you're
looking
at
things.
G
This
is
the
block
navigation,
which
you
can
also
change
here,
I'm
hitting
the
different
Keys
here,
so
you
can
see
for
a
given
module.
The
output
has
a
different
block
right
and
if
you
switch
the
module,
you
keep
the
block
at
which
you
were
at
keep
the
context,
so
you
can
independently
switch
from
modules
and
over
here
you
have
the
logs,
and
you
have
you
know
the
output
of
the
thing
decoded
and
all
the
bells
and
whistles
all
the
while
progress
is
happening
perhaps
on
your
forward
processing.
Okay,
so
that's
the
GUI
I
think
it's!
G
G
G
Okay,
so
what
we've
done
wrap
up
the
integration
for
graph
node
means
that
graph
node
now
supports
substreams
based
subgraphs,
so
you
can
use
the
the
paralyzed
engine
of
substreams
to
push
data
into
subgraph.
There's
no
assembly
script
needs
to
that
needs
to
be
written
in
the
subgraph
side
of
things.
It
just
pushed
everything
into
postgres,
and
then
you
have
the
query
layer
that
you
know
and
love
already
it's
available,
so
we
have
done
some
work
there
and
we've
synced
uniswap
V3.
G
With
that
you
know
we
have
prototype
and
all
that
and
we've
done
that
in
86
hours,
correct
86
hours.
So
that's
without
a
bunch
of
optimization
that
are
still
to
come,
but
still
a
thing
that
would
take
normally
many
weeks
now
was
able
to
be
synced
in
a
few
days
and
we're
gonna
make
it
faster.
Even
so,
that's
it,
and
so
that
should
come
out
very
soon.
Someone
might
say
something
about.
You
know
the
release
schedule
there,
but
it's
all
bolted
into
graph
node
and
it
works
now.
G
Another
thing
we've
done
that
we
helped
clarify.
You
know
some
people
were
using
substreams
the
store
modules,
thinking
of
them
as
the
place,
they
would
end
up
querying
their
data.
But
that's
not
the
proper
model
of
substrings
substance
is
a
transformation
layer
and
the
stores
are
there
for
transient
information,
because
you
want
to
do
some
aggregations
and
stuff
like
that.
It's
not
the
place
where
you
want
to
query
your
your
data
you're
not
going
to
put
terabytes
of
things
in
there.
So
to
make
it
clearer,
we
developed
a
thing.
G
G
So
you
run
that
thing:
it
syncs
it
in
the
K
Value
store,
but
it
also
acts
as
a
small
server,
and
you
have
a
you:
can
query
from
the
web
using
you
know,
I,
don't
know
if
you
guys
checked,
connect
web
and
connect
go
we're
using
a
lot
of
go
here.
Connect
web
allows
you
to
use
grpc
Services
directly
in
the
web
browser
in
a
way
that
does
not
suck
and
it's
built
by
the
guys
at
buff.bill.
G
So
if
anyone
uses
protobuf
check
out
connect
web
and
their
stack,
there's
sort
of
an
abstraction
similar
to
grpc
web
anyway,
so
we're
offering
that
little
service
so
that
web
users
can
query
the
key
Value
Store
directly
by
getting
one
key,
my
prefix
search
by
scanning
or
whatnot,
and
you
get
responses
as
if
you
were
very
close.
But
it's
not
SQL.
It's
not
graphql.
It's!
You
know,
you're
querying
the
key
value
store,
so
that's
out
it's
being
used.
It
can
load
the
data
at
massive
scales
because
it's
a
very
simple
thing.
G
You
know
key
value
stores.
Normally
you
can
augment
to
the
throughput
because
these
stores
scale
horizontally
pretty
well.
It
supports
Badger,
which
is
a
disk
based
thing.
It
supports.
Also
tikv,
which
is
tikv,
is
a
you
know
on
press
key
Value
Store
built
by
the
pink
got
cap
guys
it's
what
backs
you
know
tidb,
which
is
a
my
sequel.
You
know
horizontally
scalable,
MySQL,
drop-in
replacement
and
so
tikv,
and
also
bigtable
by
Google,
The,
Thing,
That
vaccine
or
Gmail
I.
Think
that
scale
massively,
you
can
write.
G
The
guys
have
worked
also
on
dropping
that
on
disk
and
files
to
load
into
bigquery
and
other
data
stores,
and
some
folks
at
missare
are
working
to
transfer
the
you
know
the
data
from
sub
streams
into
parquet
file
to
load
it
in
yet
another
bunch
of
data
stores.
So
slowly
we're
seeing
the
ecosystem
around
sub
graph.
Sub
streams
grow
in
power,
and
now
it's
very
it
becomes
very
tempting
for
layer
ones
that
are
looking
at
all
the
benefits
they
would
get
to
say.
G
Oh,
if
only
we
integrated
the
fire
hose
instrumentation
there,
we
would
get
all
that
machinery
for
free
all
the
sinks.
So
we
want
to
grow
that
ecosystem
of
sinks,
and
we
want
to
roll
that
out.
You
know
as
fast
as
possible
all
these
units
of
deployment
like
this
one
as
services
on
the
decentralized
network,
so
not
only
substreams.
You
know
as
a
service
there,
but
also
a
Deployable
unit
of
a
KV
which
contains
a
reference
to
you
know.
Spkg
and
I
want
to
share
just
a
little
bit
a
vision
about
you
know.
G
G
You
know
interface
to
the
key
Value
Store
means
the
the
the
the
front
end
needs
to
understand
the
layout
of
your
keys,
which
might
be
annoying
so
what
I'm,
imagining
in
the
future
and
we've
been
thinking
about,
that-
is
that
these
little
servers
would
be
deployed
not
only
with
a
sub
streams
package
as
a
source,
but
also
as
a
wasm
with
including
sorry,
a
wasm
that
acts
as
the
server
in
which
you
could
Define
random
and
custom,
formed
grpc
or
graphql
or
rest.
You
know,
interpreters.
G
That
would
then
turn
around
on
the
server
and
query
the
key
value
store
to
do
all
sorts
of
crazy
operation
to
package.
The
data
for
responding
to
end
users
using
you
know,
a
custom
thing
so
I'm
imagining
Deployable
units
of
wasm
for
query,
which
would
be
something
similar
to
you
know:
custom
resolvers,
you
could
imagine
in
graphql
land
and
on
this
on
the
the
query
side
internally,
the
wazen
would
have
access
to
the
key
values
for,
but
then
also
take
that
same
little
box
there
and
put
it
on
the
postgres
sync.
G
Where,
on
the
other
side,
you
can
choose
the
interface,
your
design
or
an
offering
to
your
end
users
as
Deployable
units
and
internally,
you
have
access
to
postgres
to
do
all
sorts
of
wonky
queries.
So
that's
sort
of
an
other
Deployable
units
would
mean
that
this
full
ecosystem
would
flourish,
and
you
know
responding
really
to
all
the
the
needs
that
I
can
still
see
like
you
have
a
store.
G
You
have
custom
query
layers,
you
have
powerful,
you
know
real
time
and
and
paralyzed
processing
engine
for
history
select
the
sink
in
the
middle
for
your
use
case,
I'm,
not
sure,
there's
anything
left
in
Big
Data
land.
That
would
not
be
satisfied
by
these
things,
so
I'm
pretty
excited
by
where
we're
at
where
we're
headed.
If
you
have
questions,
I
would
love
to
answer
them
and
you
raise
your
hand
right
now.
You
send
a
question.
Otherwise
stay
silent
forever.
H
G
I
Really
great
demo
exciting
to
see
the
unit
swaps
of
substream
synced.
What's
the
latest
on
adding
substreams
to
the
network
and
I
think
you
know
we
have
talked
about
wanting
to
support
different
I,
guess,
databases.
You
know
data
Stores
didn't
think
it
would
happen
this
fast.
It's
cool
to
see
already
these
different
syncs
and
I
guess
our
plans
to
support
you
know
these
different
types
of
services
on
the
network.
So
what's
kind
of
in
progress
there,
and
and
what
do
you
see
coming
up.
G
So
progress
is,
we've
did
designed
a
way
for
substreams.
As
you
know,
a
streaming
engine
to
be
made
available
on
the
network
and
probably
unit
economics
would
be
you
would
be
billed
by
the
bytes
red.
This
is
closest
to
the
way
the
cost
or
structure
and
substreams.
So
you
know
back
in
the
retreat
there,
with
Giannis
we've
designed
and
sort
of
came
up
with
where
these
things
would
fit,
how
they
would
be
exposed
on
the
network.
It
was
sort
of
you
know,
unit
of
deployment
that
would
be
shown
on
chain.
G
So
that's
been
designed
as
there's
work
to
be
done
in
scheduled,
that's
not
fully
complete
and
we
need
to
make
some
efforts
now
there
to
to
see
figure
out
who's
going
to
take
on
that
ball
and
yeah.
There's
the
Gip
has
been
started
there
to
to
add
additional
services.
So
that's
for
the
sub
streams
and
fire
hose
services
and
then
we'll
need
to
work
a
little
bit
more
like
the
KB
is
just
released
last
week,
so
we
don't
need
anyway.
G
The
goal
is
to
put
the
ball
rolling
right
now
that
it's
there
we
we're
going
to
need
to
to
design
and
think
through
what
it
means
and
how
we
we
reel
it.
In
so
I
mean
it's
gonna,
be
exciting.
There's
some
some
work
to
do,
of
course,
to
bring
it
to
the
centralized
network,
but
it's
planned
and
it's
being
planned
more
and
more.
I
Yeah,
so
that's
going
to
be
huge
and
is
really
going
to
expand
the
scope
of
the
sorts
of
things
people
can
do
on
the
network
so
hoping
that
different
folks
in
the
community
I
think
you
know
it's
going
to
touch
a
lot
of
different
people.
Developers
are
going
to
have
a
lot
more
things
they
can
do,
and
indexers
will
want
to
support
these
different
things.
So
please
check
out
the
Forum
and
participate
in
the
gips
as
we're
discussing
how
to
bring
this
stuff
to
the
network.
A
Absolutely
and
in
the
meantime,
will
also
be
the
releasing
more
dogs
on
the
graphernal
in
preparation,
so
people
can
also
test
it
on
the
graphs
testnet
hope,
hopefully,
to
get
a
first
glimpse
of
how
they
could
still
leverage
the
graph
node,
the
graphql
in
interface
and
then
just
use
the
sub
streams,
as
you
know,
as
Alex
sustained
this
just
as
the
transformation
layer
that
could
be
also
a
nice
first
step,
all
right,
I
think
we're
at
the
top
of
the
hour.
Perfect
timing
last
call
for
questions
for
Alex
or
anyone
else
really.
A
Okay,
not
seeing
anything
again,
keep
it
up.
You
can
find
us
on
Discord
Forum.
Of
course,
let's
continue
the
discussion
and
we'll
see
you
all
in
four
four
weeks.
So
thanks
for
all
of
those
that
came
out-
and
that
is
nice
demos
and
quick
updates
and
yeah
pretty
cool.
Thank
you.
Well
see
you
thanks.
Everybody.