►
Description
This talk was given at IPFS Camp 2022 in Lisbon, Portugal.
A
My
name
is
Arthur
and
I'm,
a
software
engineer
with
ceramic
and
I'm
here
with
my
friend
Alex
we're
going
to
talk
mostly
about
two
things:
the
first
10-15
minutes,
I'm
gonna,
speak
about
a
little
bit
about
what's
called
kakaus
and
this
session
library
and
then
Alex
is
going
to
take
over
and
drive
you
through
that
developer
preview
of
our
new
cool
product
called
compose
DB
yeah.
So
let's
get
started,
not
sure
if
you
have
heard
of
ceramic
but
basically
I
hope
you
have.
We've
been
in
the
web.
A
A
Let's
start
with
cacao
and
this
session
a
quick
question
about
who
of
you
haven't
heard
of
cacao
and
what
it
is,
but,
okay,
great,
so
Cacao
is
kind
of
like
abbreviations
plus
acronym
for
chain
agnostic
capabilities,
and
this
session
is
first
of
all,
who
has
heard
what's
about
of
what
did
is
or
what
dids
are
okay.
So
this
are
basically
the
centralized
identifiers
and
it's
a
standard
to
describe
many
forms.
A
Many
different
applications
for
the
centralized
identifiers
that
are
pretty
useful
in
web
free
because,
as
opposed
to
web
2,
where
you
have
lots
of
big
companies,
Facebook,
Twitter,
etc,
etc.
Having
your
their
own
account
identifiers
that
you
don't
know
about
really
in
web
free,
we
take
care
and
ownership
of
our
own
decentralized
identifiers
that
we
then
use
to
connect
with
dubs,
so
that
dubs
know
about
the
data
that
we
want
to
share
with
them.
A
As
mentioned,
my
name
is
Arthur
I'm,
a
software
engineer
at
Ceramic.
You
have
some
details
about
how
to
reach
out
to
me
here,
but
of
course,
we're
going
to
speed
here
for
the
rest
of
the
day.
So
if
any
of
this
sounds
interesting,
please
reach
out
and
let's
have
a
chat
cool.
So
this
session
is
library
that
is
like
a
really
simple,
easy
way
to
basically
Define
store
and
recreate
web
free
session
based
on
edit
and
on
a
cacao.
A
Basically,
so
the
way
it
works
is
you
create
a
session
object.
This
session
object
gets
its
own
did
key,
and
then
you
ask
to
authenticate
this
session
with
one
of
available
authentication
methods.
The
default
one
is
signing
with
ethereum,
so
if
you
use
signing
of
ethereum,
what
happens
is
basically,
the
user
is
redirected
to
the
signing,
with
ethereum
ux,
using
their
favorite
wallet
or
other
authentication
method.
A
They
are
this
being
shown
a
nice
human,
readable
explanation
of
the
capability
that
they
are
asked
to
share
with
your
session
and
the
capabilities
described
in
terms
of
like
what
resources
the
session
wants
to
use,
update
and
that's
basically
it
you
get
a
session
object.
You
can
serialize,
it
store
it
somewhere
in
your
dub
in
some
keychain
anywhere.
A
So
this
is
kind
of
like
a
really
web
to
like
experience,
enabled
by
cacao.
This
session-
and
this
so
I
have
a
quick
demo
for
you
that
basically
shows
exactly
what
I
have
just
described
and
let's
see
really
quickly,
if
that's
gonna
work
for
us
here.
So
that's
a
live
page
that
you
can
yeah
just
you
know
put
in
your
favorites
check
out
later.
A
You
can
just
do
it
with
me
right
now
as
well,
just
to
see
that
it
really
works,
and
it's
really
really
simple,
so
I,
basically
I
don't
have
any
session
right
now.
This
is
just
a
simple
react.
Web
page
I
clicked
that
click
the
authenticate
button
and,
as
you
can
see,
I
have
this
like
almost
perfectly
formatted
message,
and
that
gives
you
the
date
of
the
session
that
I
want
to
create
very
soon
announce
the
time
of
issuance,
so
that
you
can
check
that.
A
This
is
right
now
and
you
know,
there's
no
meddling,
the
expiration
date
which
I
set
in
the
app
I'm
sewing
for
one
week.
So
you
can
roughly
check
that
it
adds
up
here,
chain,
ID
I'm,
doing
this
on
mainnet,
of
course,
I'm
demoing
on
my
net
and
then
you
have
the
resources
which
are
basically
entered
by
me,
entered
by
the
dub
developer
when
they
are
creating
the
session.
A
A
So
it's
a
little
bit
difficult
to
see
I
guess,
but
if
I
zoom
in
a
little
bit
you
can
see
this
is
the
cacao
object,
I
mentioned
and
not
to
maybe
go
too
deep
into
this,
because
I
don't
think
there
are
many
people
here
really
familiar
with
like
cacaos
or
cups,
Yukons
and
so
on.
If
you
want
more
detail,
please
reach
out
afterwards,
but
suffice
it
to
say
that
this
cacao
object,
uses
Yukon
format,
which
is
a
format
to
describe
how
protocols
communicate
about
permissions
basically
and
yeah.
A
So
it
has
like
a
header
in
which
there
is
a
type
according
to
the
ucan
protocol.
This
EIP
is
signing
with
ethereum.
So
basically
it
says
that
hey
this
Cacao
is
a
Yukon
of
type
sign
in
with
ethereum.
This
is
the
payload
in
the
payload.
You
basically
have
the
information
about
the
capability
that
the
session
requests
from
the
wallet
owner
to
serve
with
the
session,
and
then
you
have
the
signature
so
that,
basically,
at
any
point
in
time,
whenever
you
pass
this
cacao
object
somewhere.
A
Anybody
who
gets
it
can
actually
verify
that
it
was
issued
properly
by
the
owner
of
the
wallet,
and
here
the
owner
is
the
issuer.
This
is
a
one
of
the
did.
Formats
called
did
pkh.
This
format
basically
describes
like
describes
how
to
define
Deeds
as
in
a
one-to-one
correlation
with,
like
a
chain
type
sign,
ID
and
wallet
address,
and
this
is
the
authorized
entity
which
is
a
did
key.
It's
a
different
did
format
that
basically
creates
a
did
out
of
like
a
random
seed.
A
So
that's
one
thing
that
you
can
do
in
this
simple
demo
app.
You
can
see
that
it
creates
a
cacao
that
can
be
stored
and
verified,
but
you
can
also
store
this
whole
session.
The
second
button
is
just
logging
a
realized
session,
so
this
is
a
base,
64
string
that
basically
I
can
copy
sent
to
any
one
of
you
and
then
you
can
use
the
date
session
library
with
the
string
to
recreate
this
session
so
that
basically
it
can
be
passed,
stored
somewhere
and
so
on,
and
the
last
thing
I'm
going
to
show
you.
A
A
Persona
identity,
like
it's
kind
of
difficult
to
we're,
still
kind
of
figuring
out
the
right
wording
behind
that,
but
that
can
be
used
to
sign
stuff
so
that
you
can
later
verify
that
something
was
signed
by
a
particular
did
and
they
can
also
be
used
to
encrypt
stuff
for
other
dates.
So
basically,
I
did
is
a
public
keeper.
A
A
So
basically,
if
I
send
this
message
and
the
signature
to
somebody
and
the
date
of
the
session,
they
will
be
able
to
check
that
it
was
actually
this
date
of
this
session
that
signed
this
message,
and
similarly
it's
not
shown
here,
but
you
can
also
use
that,
as
I
mentioned,
to
basically
encrypt
any
message
in
a
way
that
it
will
be
only
be
only
particular
other
dips.
Dips
will
be
able
to
decrypt
it.
So
we
can
also
use
it
for
public
private
keeper
encrypted
communication
between
this
yeah
and
that's
I.
B
What
I'm
here
to
talk
about
today
is
compost
DB,
so
that's
a
very
new
product.
We
just
recent
recently
launched
in
the
developer
preview.
The
initial
version
I'm
sure,
like
the
current
version
I'm
showing
you
right
now,
is
one
that
supports
relations
specifically
so
as
I
can
dive
into
it,
but
on
a
high
level,
imagine
kind
of
like
having
database
tables
with
a
left
join
across
web3.
So
that's
really
the
idea.
So
my
name
is
Alex
I'm,
a
protocol
engineer
at
three
box
feel
free
to
reach
out.
B
If
you
want
to
jump
ahead
like
if
you
look
at
my
GitHub,
there
is
going
to
be
a
compose
DB
Workshop
there
that
we
can
run
through
together
and
I'll.
Also
try
to
run
with
you
through
the
demo
here.
I
know
that
the
internet
has
been
a
little
bit
the
wife
a
little
bit
flaky,
so
we'll
see
how
that
goes.
I
pray
to
the
demo
Gods
right
now
and
how
that's
gonna
go,
but
to
jump
in
it's
like
I.
Think
anybody
of
you
that's
familiar
with
ceramic.
B
It
is
all
about,
like
you,
know,
data
metadata
storage
like
off
chain
and
then
also
giving
agency
back
to
the
user.
What
I
mean
here
with
no
agency
is
that
in
the
current
implementation
of
web
2,
you
don't
really
own
your
data.
It
is
all
behind
silos,
it
is
all
owned
by
companies
and
it
is
not
transferable.
B
So
if
I
would
look
at
a
journey
from
an
end
user
today,
you
go,
let's
say
to
a
social
lab,
a
you
sign
up
again,
you
put
in
your
your
name,
you
put
in
your
username
your
location,
your
birthday.
You
set
everything
up
like
how
you
had
it
before.
Then
you
go
over
to
the
second
social
app
and
you
have
to
add
it
all
all
over
again.
So
at
some
point
it
runs
out
of
sync
at
different
point
as
well
like
you
cannot
delete
it.
A
lot
of
issues
there.
B
So
what
we're
trying
to
do
is
kind
of
like
use.
What
is
currently
in
a
decentralized
world
like
where
also
it's
very
bespoke,
very
application,
specific
that
you
want
to
jump
in.
That's,
for
example,
for
example,
say
like
ipfs
is
file
sharing
right.
Like
you
file
coin,
you
have
activity,
streams,
blockchains
or,
for
example,
the
graph.
That's
indexing
data
on
chain.
What
we
want
to
do
is
we
want
to
index
data.
You
know
that's,
for
example,
off
chain,
but
also
give
you
batteries
almost
included
to
answer
the
question
of
like.
B
What's
next
Once,
you
use
one
core
technology:
where
can
you
jump
on
next
to
really
build
very
quickly,
a
great
application
and
that's
what's
kind
of
like
the
impetus?
What
I
would
call
for
composable
data?
What
we
call
composable
data
to
enable
you
to
transfer
and
share
data
that
you,
as
the
user,
are
in
control
of
with
other
applications
that
you
authorize
and
the
key
components
for
that
are
the
existing
ceramic
node
that
we
already
have
a
little
small
I
think
here,
but
that's
the
underlying
infrastructure.
B
The
data
flow
example
and
the
user
agency
is
what
I
described
before
it's
really
about
putting
the
the
data
and
the
agency
back
into
your
hands
really
so
what
we
built
on
the
network,
qualities
and
that's
why
we
built
on
top
of
ceramic
and
why
I
think
you
should
really
have
a
look
at
it
is
we
are
a
scalable
solution.
You
know
it's
like.
We
are
a
local
first
design.
It's
like,
we
don't
have
to
like
read
through
everything
here,
but
basically
it's
like
what
we.
B
However,
you
want,
and
then
you
know,
update
in
the
future
if
you
want
to
win
and
publish
a
new
version
of
it.
What
has
to
just
pull
like
sorry
singled
out
here
is
schemas
or
Composites
once
you
create
them
and
publish
them,
they
are
immutable
and
they
have
to
be
mutable,
because
otherwise
the
data,
contract
or
reusability
of
the
data
model
falls
apart.
B
So
we
really
like
trying
to
solve
web3
with
ceramic,
giving
you
Dynamic
content
a
decentralized
P2P
Network,
the
flexible
data
models,
I
touched
on
and
then
decentralized
this
and
that's
all
basically
within
one
ecosystem
that
you
can
just
jump
on
in
and
what
we're
really
trying
to
like
enable
here
is
the
building
blocks
of
the
kind
of
like
the
always
the
question
of
what
next
you
find
the
one
technology
you
want
to
build
something
on
top
of
it.
Now
we
can,
you
know
ceramic
lets.
B
B
So
thank
you
for
for
building.
On
top
of
it
already
and
then
you
know
Shameless
plug
here.
We
are
hiring
so
I'll
just
leave
this
up
for
a
second
while
I'm
using
around,
because
we
need
your
help,
we're
like
an
ambitious
team.
We
have
about
25
people
currently,
but
we
just
need
your
expertise
and
also
like,
through
this
Workshop
as
well.
Looking
for
feedback
from
you
to
make
this
product
better,
you
know
I,
just
don't
want
to
have
too
much.
That
is
a
developer
preview,
but
that's
why
we
say
batteries
have
included.
B
We
need
your
feedback
to
make
it
better
and
make
it
suitable
for
you
and
then
I
think
we
can
jump
into
the
demo,
but
before
maybe
that,
like
I
can
answer
some
some
oval
arching
questions.
If
you
have
them,
if
not
yeah,
we
can
also
just
move
into
it.
So
it
seems
like
everything
is
running
so
far.
So
that's
that's
fun
like
I.
Also
like
recommend
you,
if
you
want
to
get
along
with
like
the
the
demo
or
we
can
do
like
afterwards
jump
in
and
just
help
you
walking
through
it
very
simple.
B
B
Yeah,
here
we
go
so
this
will.
This
will
essentially
just
like
walk
you
through
the
installation
itself,
but,
like
you,
need
the
compulsdp
client
and
the
compo
in
the
ceramic
Network
client,
which
is
the
node
like
after
you've
installed
those
it's
like
I've
I've
heard
that
the
ad
next
is
not
necessary
anymore.
B
So,
if
you
just
install
the
current
the
current
versions,
you're
good
to
go
after
that's
done
what
you
want
to
do,
you
want
to
create
a
private
key,
and
that's
also
just
like
with
the
library
that,
like
Arthur
already
like
you,
know,
demoed
before
so
it
really
shows
you.
You
have
everything
ready
in
this
one
kind
of
like
package
and
that
private
key
in
the
for
the
course
of
this
demo
I'm
doing
something
that
is
not
very
good,
I'm,
storing
it
inside
a
private
key
file.
B
If
you
want
to
do
that,
go
ahead,
there
is
the
the
other
option
of
just
setting
an
environmental
variable.
This
just
makes
it
a
little
bit
easier
to
do
overall,
but
you
know
it's
just
a
way
to
do
it
just
like,
if
you
do
it
with
a
private
key
and
like
in
a
file,
and
you
you
know,
want
to
store
it
on
GitHub,
just
make
sure
to
exclude
that
file
or
add
it
to
your
git
ignore.
So
what
the
next
step
is
done
for
us
is
to
either.
B
If
you
already
already
had
started
a
ceramic
node
prior,
you
should
just
be
able
to
add
the
the
key
in
the
configuration
file.
You'll
find
that
under
your
homedirectory.ceramic
and
thedaemanc.json,
what
that
does
is
just
like
you
get
the
the
did
that
was
created
alongside
the
private
key
and
that
is
to
interact
with
the
server.
So
you
kind
of
like
as
an
admin.
It's
a
local
development
environment.
B
You
used
any
private
key
to
sign
and
you
use
the
did
to
interact
with
the
server
itself,
and
this
is
just
an
example
here,
like
how
a
configuration
file
works.
We
do
Support
also
for
indexing,
sqlite
and
postgres.
So
how
compose
DB
works
in
the
background
it
creates
like
tables
that
will
then
store
the
the
index
models
and
also
then
the
index
streams,
including
the
content
like
on
your
note,
and
that
will
basically
give
you
the
interaction
that
you
need
there.
B
Just
I
can
quickly
show
you
on
my
on
my
machine
I'll
be
going
through
with
postgres
instead
of
sqlite.
Sqlite
is
just
a
default
just
to
show
you
a
little
bit
what's
happening,
while
I
step
through
the
demo
kind
of
like
on
the
database
level,
two
well
and
then
from
that
on.
We
can
just
jump
right
in
so
this
is
how
we
build
a
first
relation
on
compost
DB.
What
we're
using
here
as
an
example
is
an
address
book.
B
You
know
because,
like
obviously
like
there
are
the
discussions
around
like
what
data
should
be
shared
and
not
shared
in
a
public
setting,
you
know,
obviously
that's
then
up
for
the
community,
decide
and
like
where
the
discoverability
comes
in,
but
I
just
want
to
like
point
that
out.
Just
be
careful
what
you
put
out,
because
it
is
public,
but
to
have
a
look
at
this,
we
would
create
a
first
graphql
schema,
which
is
the
main
address
book.
So
really
imagine
like
we're.
B
Creating
a
table
and
I've
have
that
in
the
in
the
people
like
repository
itself,
but
this
is
just
super
simple
to
be
creating
a
new
type
which
is
an
address
book.
So
that's
the
model
and
the
schema.
What
we're
creating
and
it's
of
a
of
a
calculation
of
a
list
we
just
can
give
it
a
description.
So
that's
all
going
to
be
encoded
into
the
model
and
then,
as
a
single
value,
we're
gonna
give
it
like
an
address
book
name.
B
A
B
Arthur
feel
free
to
jump
in
if
you
want
to
have
like
any
like
any
additional
information,
so
we
use
the
compost
epcli
to
use
that
graphql
schema
file
to
create
kind
of
like
the
encoded
representation
in
Json,
with
the
signed
with
our
private
key.
So
if
I
run
this
and
like
this
is
where
you
know,
we
use
our
command
line
magic
a
little
bit
to
cut
it
out
there
without
you
know,
seeing
it
and
boom
it
created
the
the
schema,
the
composite
and
it
created
it
against
our
running
node
here.
B
So
you
see
that
immediately.
It
was
like
that
it's
said
it
started
indexing
for
the
model
and
it
started
creating
the
database
table.
So
if
I
go
back
onto
my
postgres
database,
I
see
now
this
model
was
created
with
the
encoded
ID.
That's
the
stream
ID,
like
the
model
ID,
essentially
that's
like
assigned
to
that
model
which
we'll
need
in
a
little
bit
as
well
to
reference
the
composite,
the
second
one
which,
where
brings
us
you
know.
B
So
we
get
like
the
the
address
book
ID.
So
in
this
case
then
sorry
yeah,
okay,
and
then
we
create
the
relation.
Now
so,
if
I
look
back
into
like
the
schema,
I
have
a
second
address
book
entry.
So
what
we
do
here
is
this
is
really
now
the
entry
to
the
address
book
itself,
so
you
have
like
the
upper
container.
Now
we
have
like
the
the
embedded
document,
the
relational
document.
So
here
is
the
type
address
book.
B
That's
what
we
discussed
that
you
just
created
before,
and
what
I
do
here
is
I
reference
it
with
the
ID
that
was
created
prior.
So
this
is
what
we
saw
here
on
the
command
line
being
generated
or
like
also
here
the
table
that
has
been
generated,
and
if
any
of
this
is
confusing,
please
speak
up
because
I
know
it's
a
lot
of
steps
going
through
it
initially,
but
just
let
me
know
so.
B
Putting
in
you
know
like
address
book,
which
is
a
reference
and
then
if
you're
familiar
with
orms
or
any
other
kind
of,
like,
for
example,
with
Django
you'll,
be
very
familiar
with
just
like
getting
that
reference,
essentially
up
into
like
the
previous,
like
primary
one,
the
primary
table,
and
then
we
have
the
entry
name
and
we
have
like
a
wallet
address,
because
you
know
it's
like
just
like
some
little
properties
that
we
can
play
around
with,
like
very
simply
and
then
from
wallet
address.
I
can
even
add
embedded
types.
So
this
is
like
another
type.
B
That's
now
part
of
the
SQL
schema
or
if
the
postgres,
sorry
of
the
graphql
schema
and
here
I'm,
just
adding
an
address
and
I'm,
adding
a
blockchain
network
so
that
you
know
those
are
all
properties.
I
can
then
edit
and
publish
how
I
want
to
so.
The
next
step,
then
here
is
that
I
do
the
same
step
as
I
did
with
the
initial
address
book
model.
I
just
have
to
compile
it
into
a
Json
file.
So
that's
this
Command
right
here.
B
Then
this
was
created.
You
see,
there's
a
second
table
that
was
created
now
within
postgres,
which
is
now
the
representation
of
the
address
book
entry.
Both
tables
are
completely
empty
right
now
and
like
also
available
on
the
basis
of
what
we
built
on
top
of
it.
So
the
step
after
this
here
is
now
we
create
the
composite
because
you
know
it's
like
as
it
is
in
the
name,
is
I.
Take
these
two
Json
representations
and
I
merge
them
together
into
like
the
composite
itself.
B
That
is
like
basically
my
build
file
that
I
can
then
use
as
a
runtime
file
against
my
server.
So
what
I'm
doing
right
here
and
just
like
to
show
you
as
well
currently
I
have
two
Json
files,
which
is
the
address
book
and
the
address
book
entry,
and
here
with
the
merge,
I'm
merging
those
two
files
together.
B
So
this
created
now
for
me
my
merged
composite.
So
this
is
really
what
we're
going
to
use
for
now
to
interact
then
through
the
graphql
interface
like
of
the
on
the
Node
and
then
the
last
step
I
have
to
do
here
is
to
come,
is
to
deploy
this
merged
composite
onto
my
node.
So
now
I
can
know
it's
like
that's,
essentially
not
building
the
interface
to
be
able
to
interact
with
the
composite
on
the
Node,
and
we
do
that.
A
B
Here,
yep
yep
I
saw
boom,
and
this
has
been
now
deployed,
and
this
is
like
the
representation
here.
It
has
been
added
to
the
node
as
well.
It
is
ready
to
be
interacted
with
so
for
the
runtime
steps.
What
we
have
to
do
now
is
like
this
is
normally
where
the
development
from
the
back
end
ends
like
this
is
where
now
like,
the
your
front-end
application
would
jump
in
you
build
your
react
app.
B
You
build
everything
on
top
of
it,
how
you
want
it,
but
since
we
just
want
to
make
like
a
quick
demo
against
the
node
itself,
like
composit
B
ships
with
a
graph
graphql
client,
a
graphql
server,
it's
graphical,
so
it's
like
right
off
the
box.
You
can
use
it
to
like
query,
query
and
interact
with
your
Composites
just
to
help
you
and
Aid
you
in
the
development
process
and
for
that
I'm.
B
So
if
I
create
that
runtime
file
now
we're
good
to
go
so
the
only
thing
I
have
to
do
now
is
part
of
part
of
the
process
is
to
run
the
graphical
server.
So,
as
you
can
see,
it
is
built
in
you
also
Connect
Now,
against
the
node
directly
with
your
private
key.
So
that's
you
stick
to
enable
you
to
interact
and
create
the
mutations
and
add
data
to
it.
So
if
I
do
that
here.
B
The
URL,
which
is
the
same
one
that
is
right
here,
you
are
now
connected
directly
to
the
API.
Basically
the
graphql
API.
So
go
back
to
the
example.
So
if
I
just
want
to
like,
let's
say,
query
the
address
book,
so
this
is
just
a
single
first
model
that
we
created
and
I
just
say
query
against
the
address
book.
Obviously
nothing
is
going
to
come
back
because
we
haven't
added
any
data
yet
so
this
is
completely
empty.
Looking
at
the
database,
we
can
confirm
that
if
I
look
against
the
address
book
table
here,.
B
B
So
if
you're
unfamiliar
with,
like
graphql
I,
would
say
like
just
reading
to
it,
it's
fairly
standard
like
going
forward
but
like
on
the
high
level,
we
just
say
we
want
to
create
a
new
address
book
entry.
You
know
in
like
in
our
model
in
our
document,
and
then
we
just
like
put
in
the
address
book.
Name
ID
is
just
like
a
reference
of
the
ID
that
would
be
created
anyway,
but
I
can
just
say
here.
This
is
like
ipfs
camps.
B
B
Run
it
creates
the
second
entry
going
back
now
to
our
previous
query
of
the
address
book.
Obviously,
now
you
will
see
I
have
two
entries
in
here:
I
just
have
to
take
this
out,
and
you
see
here:
I
have
the
ipfs
camp
entry
and
I
have
the
Alex
book
entry.
So
that's
really
just
like
the
initial
address
book
that's
been
created.
So
as
the
more
interesting
step.
Now
we
create
a
new
address
book
entry
into
the
address
book
so
as
we
did
before
as
well.
B
I
put
this
essentially
like
as
the
schema
and
then
here
I
put
the
values
I
want
to
put
in,
but,
as
you
can
see
here,
it
asks
now
which
address
book.
Do
you
want
to
put
it
in,
and
this
is
where
you
know,
obviously,
as
part
of
the
application,
you
would
keep
track
of
the
stream
IDs.
But
in
this
case,
like
I,
can
say,
I
want
to
put
this
in
my
ipfs
Camp,
because
I
want
to
get.
B
You
know
in
touch
with
all
of
you
and
put
the
stream
ID
in
so
that
created
now
the
entry
into
the
address
book
entry.
So
we
have
like
those
two
data
streams
are
now
completely
unrelated,
like
they're
still
I
mean
like
related,
but
they're
like
not
being
created
right
now
as
one
and
if
I
look
into
the
database.
Backend
here
is.
B
B
Is,
as
you
can
see
here
is
a
querying
the
address
book
entry.
We
use
the
book
as
the
reference
already
like
that
we
created
before
so
as
a
reminder
that
is
here
in
the
address
book
entry
schema,
we
have
a
book
and
the
book
is
the
property,
the
reference
to
the
previous
table
to
the
upper
table.
So
if
I
run
this
now
against
the
node,
we
should
have
a
nice
representation
of
all
the
stuff
we
created.
B
And
there
it
is
so
it
creates,
like
it,
pulled
out
the
ipfs
entry
with
my
fantastic
entry
right
here
and
that's
kind
of
like
you
know
where
you
build
on
top
of
it
and
you
keep
on
building
and
you
start
kind
of
like
the
iteration
process
of
of
those
Composites.
But
with
that
you
know
you
hopefully
are
composed
to
be
Pro.
I
know
there
is
a
lot
of
steps
still
like
in
between.
Thank
you
still
stops
the
steps
in
between
and
we
are
continuously
like
improving
the
user
experience
and
development
experience.
B
B
Let
me
just
pull
this
up
here,
how
to
create,
like
data
composition,
the
concepts
overview
and
also
like
how
to
create
and
discover
Composites
themselves,
so
I
would
have
a
look
into
that,
and
also,
if
you
have
want
to
have
a
recap
of
the
whole
work
workshop.
We
have
that
here
on
the
on
the
GitHub
as
well,
just
like
for
after
after
watching
get
in
touch
with
us.
B
Please,
on
Discord,
if
you
can
like
we're
very
communicative
like
if
you
have
questions
during
implementations,
like
we've
heard
already
like
a
lot
of
people,
were
helped
like
just
getting
started
with
that,
and
then
also
we
have
a
community
Forum
also
with
a
subsection
for
compose
TP.
That
really
helps
you
out
as
well,
if
necessary,
yeah
and
I
hope.
With
that
I
got
you
somewhat
excited
about
compost,
DB
and
what
we're
building
are
there?
Any
questions
awesome.