►
From YouTube: July 3, 2017 - IPFS All Hands 🙌🏽📞
Description
Monday Check In
- IIIF Demo
- Ethereum on IPFS demo
A
B
Alright,
thank
you
so
much
for
the
patients.
We
have
finally
ready
to
start
the
July
3rd
ipfs
Islands
hi,
everyone
I'm
to
be
going
to
be
the
moderator.
For
today
we
have
Friedel,
who
is
going
to
be
the
note-taker
as
usual,
like
feel
free
to
add
items
to
the
agenda.
One
of
the
items
that
was
added
especially
to
this
agenda
was
a
roll
call,
bring
back
the
roll
call.
Since
we
have
so
many
new
faces
as
a
tradition,
let's
go
from
west
to
east,
which
I
believe
it
means
starts
with
you.
G
B
I
J
I
K
D
H
B
Yeah,
please
do
outcome.
Thank
you.
Take
everything
all
right.
So
if
we
don't
have
any
more
introductions
for
now
continue
mine,
let's
go
into
the
second
item
of
the
agenda,
which
is
what
award
so
well,
but
that
so
buff
award
added
by
B
so
well.
Well
again,
we
started
using
the
waffle
board.
So
if
you
go
to
things
like
what
award,
what
I
do
I
PF
s?
B
Just
BFS
you
can
you
can
see
like
issues
that
the
team
is
currently
acting
like
the
the
contributors
are
currently
active,
working
on
on
the
in
progress
column,
like
our
people,
ask
through
our
see
our
crew
Twitter?
What
are
people
focusing
on
right
now
and
like
the
waffle
board,
is
a
perfect
place
to
get
a
sense
of
what
is
the
current
focus
of
specific
and
never
within
the
whole
ipfs
project?
There's
a
walk
award
for
leap
year,
there's
a
waffle
board
for
GPFS
one
for
go.
Not
all
the
waffle.
Words
are
updated
like
live.
B
It
requires
some
time
for
us
to
actually
go
to
all
the
issues.
We
try
to
be
as
diligent
as
possible
to
make
sure
they
are
up
to
date,
but
even
if
they
are
not
like
we'll,
never
turn
up
today,
they
are
still
a
very
useful
tool
and
you
can
help
estrella
some
of
those
issues.
If
it's
something
that
is
interesting
for
you
as
a
contribution
to
help
us
identify
what
are
the
one
star
like
bugs?
B
What
are
the
ones
are
that
questions
provide
answers
to
the
ones
of
the
questions
that
I've
got
already
answered,
or
just
like
make
sure
that
people
get
the
attention
like
me
on
all
of
those
issues
in
jessup
EFS,
specifically
even
like
I've,
been
doing
this
weekend
like
cleaning
up
all
that
you
can
find
a
bunch
of
issues
on
the
ready
column,
which
typically
means
it's
issues
that
have
been
identified
as
things
that
would
be
great.
Someone
was
working
on.
B
They
are
just
not
active
because
someone
like
the
rest
of
the
people
that
are
actively
contributing
are
already
busy
busy
with
a
in
progress.
The
flow
is
as
soon
as
you
finish,
something
on
the
in
progress.
You
pick
something
from
the
ready
column
and
if
you
get
blocked
in
something
in
the
in
progress
column,
you
move
it
back
to
the
ready
or
to
the
backlog,
and
then
you
pick
some
other
card
this
way,
it's
like
a
way
for
us
to
be
all
in
sync:
it's
just
like
what
like.
B
We
have
talked
about
the
waffle
board
extensively
during
the
first
quarter
of
this
year,
but
like
since
we
haven't
brought
it
up
for
quite
some
time.
I
thought
it'd
be
useful
for
everyone
and
that's
it
cool
all
right.
If
no
one
has
questions
on
that,
let's
jump
into
the
demo
section
are
people
here
for
the
demos
I've
been
saying,
develop,
there's
like
some
exciting
demos.
Today
can
I
see
I
see
by
marketing
strategy
all
right.
We
have
a
call
for
people
so
yeah
like
we
have
two
exciting
demos.
B
J
C
J
So,
for
a
little
bit
contactslaw,
it
gets
set
up
I
work
at
Stanford,
where
I've
been
the
developer
of
a
research
tool
called
mirador
which
allows
people
to
allows
researchers
and
students
to
build
or
to
view
and
annotate
high-resolution.
Imagery
and
Edie
has
developed
a
similar
viewer
for
a
lot
of
cultural
heritage.
Institutions
in
the
UK
called
the
universal
viewer,
and
both
of
these
viewers
rely
on
a
standard
that
was
developed
by
in
an
international
community
of
cultural
heritage.
J
Institutions
called
triple
I
F
or
the
international
image
interoperability
framework
and
the
set
of
standards
that's
been
developed,
allows
annotations
that
are
created
on
in
one
viewer
to
be
viewed
in
another
because
of
the
interoperability
between
them.
So
what
we've
set
up
here
is
demo
in
which
mirador,
which
has
an
annotation
creation
tool,
will
create
annotations
on
an
object
that
gets
propagated
through
ipfs
to
the
universal
viewer,
where
it
can
be
viewed.
C
Yeah,
so
this
is
the
repository,
so
we
call
this
organization
called
viuda
I.
Think
we
decided
in
a
row
I'm
going
to
rename
this.
Actually
it's
a
triple
eyath
labs
or
something
because
it's
less
confusing
but
yeah.
If
you
got
a
reader,
slash,
ipfs
experiments,
we're
thinking
this
is
just
gonna,
be
like
a
general
repo
for
any
any
IP,
fest
related
experiments.
We
do
and
then
it's
in
your
annotations
and
the
cell,
pretty
straightforward,
my
browser's
pretty
slow,
he's
clean
it,
npm,
install
and
PM
to
start
and
when
you
run
it
npm
start.
C
K
Yeah
well,
I'm,
not
exactly
sure
about
the
the
whole,
the
whole
story,
but
the
thing
the
symptom
is
that
using
WebRTC
with
chrome
throttles
somehow
throttles
the
process
that
behind
the
resources
the
processes
are
behind,
not
on
not
viewed
so
you
in
order
to
run
these
and
propagate
the
changes
in
real
time.
It
works
best.
If
you
just
have
well
and
it's
the
separate
windows
and
they
are
on
top,
they
are
not
hidden
well,
they
are
not
fully
here
and.
L
I
write:
this
is
just
so
that
you
can
do
it
demo
right
if
you
come
over,
if
you
have
both
screens
open
in
order
to
get
it
to
perform
right,
you
need
to
have
them
be
in
separate
windows
that
are
not
overlapping
the
actual
internality.
If
you
were
actually
using
this
in
a
real
situation
where
each
viewer
is
on
a
separate
machine,
you
wouldn't
have
this
issue.
B
C
C
C
N
C
J
So
libraries,
don't
really
have
annotation
servers
right
now,
but
they
run
as
a
matter
of
course,
and
a
lot
of
the
users
that
rely
on
our
software.
Aren't
that
technically
savvy
and
most
of
them
aren't
going
to
set
up
their
own
annotation
server
or
even
necessarily
plug
into
to
various
services
that
could
someday
be
adapted
or
configured
for
that.
J
So
this
solves
a
major
problem
by
letting
ipfs
run
in
the
browser
directly
with
JSI
BFS
and
the
annotations
are
just
stored
and
the
user
doesn't
really
have
to
to
think
about
how
they're
going
to
get
around
and
get
shared
and
republished
anyone
who's.
Subscribing
to
that
channel,
you
know
who
has
a
certain
link
essentially
can
can
easily
view
those
in
real-time,
so.
C
J
C
These
are
just
like
peers
and
then
you
could
easily
set
up
a
third
peer.
We
have
an
example
of
that,
actually,
where
it
can
track
the
annotations
being
created
and
preserve
them.
So
that's
really,
you
could
imagine
a
scenario
where
you've
got
a
roomful
of
people
and
they're
all
annotating
away,
and
then
you
know,
Stanford
of
preserving
those
annotations
for
them
or
multiple
institutions
are
tracking
that
kind
of
partition
or
unique
ID
that
the
annotations
are
being
saved
under
and
reserving
them.
C
K
K
L
So
let
me
just
if
anyone
is
confused
about
the
flow
of
what's
happening
there.
This
is
using
IP
FS
pub/sub,
underneath
so
both
of
these
viewers
I
have
chosen
before
it's
hard.
It's
currently
hard-coded
into
the
code
they've
chosen
an
identifier
for
the
channel
that
they're
publishing
these
annotations
on
and
each
of
these
windows
currently
is
running
its
own
IP
FS
nodejs
ipfs
node
in
the
in
the
browser
in
the
window,
and
so
there
are
basic.
L
What
you're
looking
at
is
the
viewers
which
are
each
running
an
IP
FS
note,
and
when
you
write
an
annotation
on
in
our
door,
it's
writing
that
annotation
to
that
IP,
FS,
pub
sub
channel
and
the
only
other
node
on
the
network
right
now.
That's
listening
on
that
on
that
channel
is
that
is
the
other
window
is
Universal
URI,
but
what
they're
talking
about
is
like
you
could
have.
L
You
could
have
a
hundred
nodes
listening
on
listening
on
that
channel
on
that
pub/sub
channel,
it's
just
that
right
now
we
only
have
two
and
since
there's
only
two
and
the
information
is
only
being
written
into
those
two
ipfs
nodes.
If
you
close
these
browser
windows,
you
lose
those
nodes
and
you
lose
the
information
that
those
nodes
are
holding.
But
then
we
have
tons
and
tons
of
options
how
you
could
store
that
information
all
the
ways
just
by
running
other
node
or
node.
It.
B
There
is
no
a
new
organization
on
kidnap
call:
I
could
set
up
like
being
just
ipfs,
exactly
fest
labs.
We
are
trying
to
pick
up
a
better
name
for
it,
but
we
get
up
we'll
do
redirects.
So
if
you
go
to
get
out
of
comm
/
ipfs
labs,
you
will
see
a
bunch
of
those
building
blocks
for
real-time
applications.
On
top
of
my
PFS
that
are
using
Jessup
EFS
and
only
peer-to-peer
pub/sub
we
see
are
these
and
without
charities.
J
Helps
visualize
the
kind
of
third,
fourth,
fifth
and
node
idea
for
libraries
and
cultural
heritage.
What
what
we're
all
what
all
the
ipfs
people
in
the
know
are
thinking
about?
That
is
that,
hopefully
down
the
line,
libraries
will
be
these
kinds
of
kind
of
backup
listeners
to
a
lot
of
small
research
group
activity
and
they'll
have
command-line
tools
that
run
in
the
background
to
listen
on
these
channels
and
persist,
research
data
so
and
like
provided
every
Pisan
and
things
like
that
for
additional
research
and
and
all
the
kind
of
official
archiving
of
the
data
passively.
J
L
You
know
so,
for
example,
if
you
were
a
researcher
at
a
research
institution,
you
would
basically
just
have
to
tell
the
library
what
channels
you're
using
to
create
this
data.
That
should
be
that
the
library
should
be
collecting
and
then
the
library
can
just
add
it
to
the
list
of
channels
that
it's
following
in
archiving,
so
it
becomes
there's
no
like
drop
and
upload
all
of
your
data
to
the
library
system.
J
K
It's
it's
tracking,
basically
tracking,
as
matt
said,
pub/sub,
add
a
channel
and
in
logging,
every
change
on
a
CRT
over
that
so
but
for
channel
is
just
a
way
to
transmit
the
changes
and
broadcast
all
the
changes
to
all
the
listening
peers
and
the
tracker
is
it's
just
one
of
them
and
I'm.
Just
the
track
is
just
logging
when
a
mutation
event
happens,
bass,
I,.
B
It's
like
when
one
interesting
thing
to
note
is
like
all
of
the
annotations
data
model
was
was
already
built
beforehand
and
it
was
using
json-ld
and
right
now,
it's
like
being
put
into
ipfs
using
the
back
api
with
tech
support,
so
there
was
no
need
to
like
change
the
object.
It
was
just
like
that.
Put
the
Jason
Paul
and
you
got
a
nice
rack.
B
C
Is
all
the
Jason
looks
like
this
is
a
annotation
list?
This
is
all
based
off
the
open,
annotation
spec
future
feature
of
triple
if'
will
be
to
use
the
web
annotation
data
model,
which
is
a
bit
different
to
this,
but
the
purpose
of
the
demo
and
the
UV
and
marital
only
support
this
currently,
but
a
lot
of
annotation
data
models.
Really
you
know
kind
of
quite
generic,
so
you
and
I
say
you
know
anything
with
it.
C
Just
the
code
really
I
just
want
to
show
you
how
easy
it
is
to
you
know,
improve
their
senior
page,
it's
just
going
from
unpackage
calm
and
we've
got
this
kind
of
yeah
browserify
distribution
file.
It's
absolutely
great
because
we
started
off
using
drew
and
I
experiment
a
bit
with
orbit
and
we
found
it
slightly
difficult
to
get
started
with
and
I
think
that
kind
of
began.
J
Pedro
set
up
the
API
very
nicely,
though,
because
well
for
I,
guess,
first
of
all
from
just
say
another
note
on
distribution,
it's
also
an
NPM,
so
we
could
just
you
know
just
as
easily
compose
it
into
a
larger
application.
So
Mirador
recently
released
a
desktop
version
that
runs
inside
of
electron
and
that's
a
really
good
candidate
for
including
ipfs
trip
yfd
be
over
NPM.
And
then
you
know
all
the
data
that's
created.
There
has
a
place
to
live,
even
though
it's
not
you
know
not
in
the
browser,
and
it
can
be
shared
easily.
C
And
then
this
is
where
it's
getting
set
up:
you're
initializing
the
OPF
s,
trip
alive,
DB,
object
and
then
waiting
for
it
to
be
ready
and
then
creating.
This
annotation
list
objects
which
is
kind
of
the
container
for
all
your
annotations
and
it's
using
this
ID
property
to
kind
of
set
the
unique
endpoint
for
the
annotations
to
be
it.
C
J
Open
the
the
Mirador
code
to
show
you're
writing
an
equal,
so
Mirador
has
this
every
just
scroll
actually
down
at
the
bottom
there
so
they're
under
annotation
endpoint.
This
is
the
this
is
the
mirador
instance.
Configuration
object.
Lets
you
kind
of
set
up
what
the
workspace
is
like
on
that
line.
59
you
see
annotation,
endpoint
and
whereas
supplying
a
module.
So
that's
been.
J
Released
into
the
namespace
as
a
as
a
javascript
object,
this
ipfs
and
a
point
and
mirador
is
going
to
take
that
and
it
wraps
it
and
there's
a
standard
kind
of
API
for
that
and
ipfs
just
provides
the
implementation
for
each
of
those
methods.
So
if
we
scroll
up
slightly
in
this
file
here,
you'll
see,
this
is
how
the
this
is
again,
the
the
DB
initialization.
J
So
it's
same
as
for
per
universal
viewer,
we
set
the
ID
and
in
the
channel
and
give
it
the
initial
kind
of
container
annotation
list,
and
then
it
goes
into
this
constructor
right,
BFS
endpoint.
So
we
pass
in
the
initial
the
initial
DB
instance
and
that's
what
Mirador
is
reading
off
of
off
of
itself
in
order
to
use
the
annotation
endpoint
so
going
into
the
annotation
endpoint
code.
J
Just
provide
this
module
and
it
just
accepts
the
instance
and
kind
of
sets
some
set
some
properties
there
and
we
just
have
basically
crud
methods.
You
know
great
read,
update,
destroy
we're,
calling
it
search
for
read,
and
you
know
so.
This
is
the
writing
portion
that
create
here
we're
doing
some
logging
for
demo
purposes,
and
then
it
really
was
just
as
simple
as
typing.
You
know
push
resource
and
it
just
works.
Basically,
we
just
push
it
onto
the
under
the
CR
DT
and
and
that's
it.
K
If
you're,
also
interested
in
in
the
underlying
codes
of
this,
there
is
a
kind
of
new
github
organization
called
ipfs
labs.
So
this
is
where
some
code
that
allows
these
lives,
namely
y
PFS
connector.
The
connector
for
watch
is
which
is
your
duty
library.
The
talk
before
I
told
you
before,
and
ipfs
pub/sub
room
and
the
EFS
apply
f
DB,
which
is
directly
what
what
true
and
add
are
were
using
to
integrate.
B
B
B
Yeah
it
is,
it
was
like
a
shame
that
we
cannot
record
that
session,
because
there
was
also
like
some
really
interesting
questions
there
and
that
yeah
like
we'll
we'll
try
to
do
like
prepared
to
capture
next.
But
but
that's
why
I
like
we
have
asked,
drew
and
the
girls
to
come
here
today
and
like
and
share
the
demo
again.
So
that's
because
they
have
a
recording
of
it,
so
that
if
you
want
like
to
share
it
with
other
people,
it
might
be
interested
on
like.
So.
B
O
O
O
Parody
parody
is
the
rust
implementation
of
the
etherium
client
and
they've
been
very
kind
as
to
merge
into
a
sort
of
ipfs
api.
So
they
don't
connect
to
the
ipfs
network
themselves,
but
they
expose
all
their
hash
address
data
using
content
ids.
So
so,
basically,
we
enable
that
and
then
I
have
this
sort
of
custom
JSF
s,
client
that
uses
parody
as
a
data
source
and.
O
O
It
should
be
like
five
lines
or
so
basically,
you
can
create
an
IP,
FS
client
and
then
here
we're
kind
of
hacking
in
when
the
note
says
it's
ready,
then
we
add
this
extra
data
store
and
this
data
store
is
it's
just
a
uses
HTTP
to
hit
the
parody
client
and
actually
it's
in
the
yes
I
read
this:
this
wrapper
module
called
hooked,
datastore
hooked,
read-only
data
store,
and
so
I
just
give
it
this
function.
It
takes
a
CID
and
Kol
back
and
I'm.
Just
saying
like
oh,
is
this
something
that
we
possibly
care
about?
O
It
is
then
hit
the
parity,
client,
orig
DP,
and
then
you
know
fail
or
return
the
result,
and
so
what
that
looks
like
is
over
here.
So
first
we
want
to
get
we're.
Gonna
hit
the
ask
a
parity
client.
What's
the
latest
block
and
it's
gonna
give
us
a
bunch
of
data
here
and
all
we're
looking
for
is
the
Hat.
This
is
a
raw
hex,
encoding
and
so
I'm
gonna
use
this
little
tool
called
effect
LD
to
convert
it
into
a
Content
ID,
and
you
want
the
block.
O
O
A
O
B
O
B
O
Do
transaction
receipts
or
transaction
trees
or
transaction
receipt
trees,
but
everything
else
you
should
be
able
to
look
at
the
note
is
also
it's
not
an
archive
mode,
so
it's
like
pruning,
so
it
has
to
be
relatively
recent
data
or
it's
gonna,
throw
it
away.
That's
again,
just
some
configuration
and
DevOps
fix
that
part,
but
yeah.
The
parity
client
does
not
expose
those
other
things,
the
transaction,
trees
and
stuff
just
because
it
doesn't
store
them.
It
generates
them
as
needed.
B
B
I
was
just
thinking
like
it
would
be
really
interesting
to
just
like
preload
in
a
bunch
of
notes.
The
entire
block
chain-
or
it
was
like
just
follow,
just
make
it
follow.
So
that's
like
then,
when
we
first,
if
you
invoke
chain,
you
have
multiple
notes
to
like
fetch
the
box
and
it's
just
buy
stuff
for
everyone.
Yeah,
we
probably
could
like
I,
was
standing
our
in
some
of
our
notes
as
well.
Yeah.
O
That
would
be
nice,
I.
Think
I'll
probably
give
this
once
this
is
up
and
in
useful
I
mean
maybe
it's
useful
right
now,
I
haven't
really
tried
using
it
for
anything
intensive,
there's
some
teams
inside
any
consensus.
That
would
also
spin
up
quite
a
few
of
these.
As
far
as
to
see
that
would
be
nice
yeah.
The
goal
is
to
is
to
turn
meta
mask
into
an
ethereal
light
client
eventually,
currently
we're
just
100%
trusting
the
posted
nodes
to
to
give
us
the
data,
and
it
has
terrible
caching
properties
this.
O
O
O
That
would
take
a
lot
of
load
off
of
our
hosted
trusted
servers.
Apparently
they
have
over
60,000
users
and
then
just
like
consoling
pounding
away
at
this
VM
yeah
there
are
hosted
nodes
and
so
taking
the
heat
off
of
them
a
bit
by
sharing
that
same
information
between
peers,
and
so
these
60,000
users
they're
pretty
much
all
chrome
extension
installs,
and
so
it's
like
always
running
in
the
background.
So
if
you
have
a
little
lightly
at
that's
node,
you
can
sure
that
do
they.
B
Because
then
we
can
have
just
like
two
super
peer
nodes
that
what
one
is
running
inside
one
context
and
another
one
said
bring.
On
the
other
extent
they
will
just
connect
to
each
other.
It
is
still
an
open
problem.
It's
something
like
we
kind
of
like
are
dependent
on
browser
implementation,
but
yeah.
O
I'm
a
little
concerned
how
performant
this
is
going
to
be
when
what
because
you
may
need
to
do
some,
some
rather
deep
lookups
like
if
you're
something
as
simple
as
looking
at
the
token
balance,
may
involve
going
from
the
block
state
right
down
to
the
account,
and
that
could
be
several
hops
down
the
myrtle
tree
and
from
there
going
inside
that
contract
storage
tree.
And
then
let's
have
a
little
more
look
up.
So
if
you
have
to
do
20
lookups
for
a
single
value
that
might
not
practically
perform
it,
their.
B
Babies
were
the
discussion
around
something
like
next
version
of
bit
swap
or
an
improved
version
of
bit
swap
comes
around
because
then
you
can
just
like
send
your
your
query
to
the
other
nodes
and
if
it's
a
node
willing
to
cooperate,
it
can
like
try
to
resolve
the
query
locally
and
understand
how
many
nodes
you
have
to
fetch
from
like,
because
right
now
like.
If
you
the
way
that
will
work
now,
but
you'll
realize
the
first
nodes,
and
you
will
see
the
first
know
that
I
do
realize.
B
Just
do
one
round-trip
and
then
you
realize
all
right
now.
I
have
to
go
to
some
other
node,
but
you
would
have
to
do
that
anyway.
If
the
data
we've
seen
some
other
part
of
the
network
and
then
and
then
another
thing
that
can
happen
is,
if
you
have
no,
does
you
have
right
now
that
you
trust
or
nodes
that
are
willing
to
pay
the
costs
of
being
proactive
in
that
caching,
stuff
I
can
send
queries
to
like
three
nodes
that
I'm
connected.
B
If
and
if
one
of
those
nodes
is
kind
of
like
this
Proactive
very
friendly
notes,
you
can
actually
be
the
one
like
fetching
at
content
for
me
from
the
network
and
then
like
replying
all
at
once.
So
if
you
have
a
canoe,
that's
like
in
a
very
good
location
which
has
been
late
like
past
memory,
that's
also
a
lot
of
connections
open
and
so
on.
Then
it
might
make
sense
for
an
infrastructure
of
an
application
12
that
nodes
being
a
friendly
nodes
to
the
rest
of
the
application
notes.
O
One
yeah
those
would
be
huge
improvements
in
performance.
We
didn't
see
in
the
near
term.
So
another
thing
that
might
be
nice
is,
if
you,
if
you
do,
that
full
request,
like
hey
I'm,
trying
to
path
all
the
way
here
and
be
able
to
include
the
hashes
that
you
have
like
you,
you
think
this
state
is
probably
stale,
but
this
is
what
you
have
and
then
it
only
has
to
you.
Can
you
know
meet
you
halfway?
You
only
have
the
latter
half.
B
O
Like
no
no
sort
of
the
other
way,
because
because
we
have
a
Merkle
tree
and
the
state
hasn't
changed,
let's
say
I'm
asking
about
your
balance
and
your
balance
hasn't
changed,
but
a
bunch
of
other
things
have
changed,
so
the
state
is
different,
and
so
you
don't
know
whether
or
not
your
balance
exchange
but
like
here's.
The
data
I
have
from
a
previous
balance
and
I
want
to
go
down
to
my
balance,
and
so
it's
like,
oh
yeah.
Actually,
your
balance
is
the
same,
but
all
this
stuff
changed
in
the
middle.
O
So
here's
the
middle
data,
where
you
can
tell
that
your
balance
is
the
same
that
make
sense,
go
ahead.
Yeah
it
makes
sense
miracle
branch
of
like
10
nodes,
the
bottom
five
are
the
same.
The
top
five
are
different,
but
you
need
to
hear
about
the
top
five
in
order
to
be
sure
that
the
bottom
five
are
different.
Yeah.
B
I'm
trying
to
think
what
would
be
the
closest
I
think
possible,
but
we
couldn't
do
to
support
those
kind
of
queries
and
it's
fun.
It
is
something
like
so
wait.
Top
was
being
built
is
very
portable.
You
can
even
like
in
Jessica
fest
to
change
the
egg
change
and
try
different
bit
swaps
and
if
I
know
that
David
prism
is,
is
working
on
making
it
work
better.
So
if
you
guys
want
to
talk
more
about
that,
you
know,
I
can
either
be
sure.
There's
not
a
bit
now.
B
M
B
All
right
does
this
answer:
I
am
partially
because
it's
essentially
yes,
we
need
to
think
about
it.
For
that
part,
for
the
the
graph
query
where
you
send
like
the
selector
that
I
peel
this
elevator
like,
then
those
are
smart
enough
to
like
give
you
back
more
complete
responses.
That's
definitely
like
very
much
or
like
the
plan.
We
definitely
know
we
want
that,
and
we
are.
We
have
a
more
clear
picture
about
to
achieve
that
soonish
for
the
other
part
for
like
seeking
Michael
trees.
B
B
All
right,
yeah,
I,
think
like
one
good
thing,
would
be
go
through
all
the
issues
that
we
have
open
games
of,
like
compatibility
between
with
Peter
Pierre,
and
that
field
appear.
Madam
asked
and
a
defense,
and
so
on
is
just
like
review,
because
that
one
of
things
have
been
changed
like
a
lot
of
things,
I've
been
shipped,
let's
see
what
is
still
missing
and
what
is
the
right
direction
right
now
feel
like
there
was
an
issue
like
parity
to
ipfs
or
ipfs,
a
parity
to
ipfs,
I
think
on
Jessup
EFS.
B
B
All
right:
okay,
if
there
is
no
more
questions,
thank
you
so
much
from
others.
It
was
awesome,
really
excited
I
feel
this
was
an
awesome
call.
Today
one
of
people
have
joined.
We
had
two
awesome
demos,
one
of
you
building
blocks
for
people
to
try
on
again
like
if
you
are
looking
for
ways
to
contribute,
definitely
check
always
the
community
repo
denotes
repo
and
the
waffle
boards
for
the
projects,
because
that's
where
you
can
like
at
least
epigrams
of
where
most
of
activities,
and
if
there
is
there,
is
no
more
questions
or
thoughts.