►
Description
IPFS Software Engineer Adin Schmahmann (https://twitter.com/IPFS) and NEAR Co-Founder & CTO, Alex Skidanov (https://twitter.com/AlexSkidanov) discuss how IPFS works, including its underlying components, and problems it solves.
------- About Whiteboard Series ---------
The Whiteboard Series with NEAR is a set of video interviews with Founders who are building scalable solutions for Blockchain. We deep dive into their story, what they're developing and how it is helping the ecosystem.
Follow the latest from NEAR Protocol on,
Website: https://near.org/
Discord: https://near.chat
Twitter: https://twitter.com/NEARProtocol
GitHub: https://near.ai/github
#WhiteboardSeries #Blockchain #FutureIsNEAR
A
B
B
A
B
You
know
if
we
try
something
slightly
different:
let's
say
that,
instead
on
alpha
centauri,
we
have
both
alice
and
bob.
They
both
went
together.
Bob
was
a
knew
that
they'd
be
in
for
a
long
trip,
and
so
he
brought
with
him
sort
of
all
these
books
right.
He
bought
with
him
all
the
gutenberg
books
and,
of
course,
earth
is
still
over
here,
still
very
far
away.
B
B
B
B
B
B
The
reason
why
hash
functions
are
nice
is
that
you
know
sort
of
exactly
what
you
are
getting
right.
They
actually
solve
both
of
these
problems
right
right,
so,
instead
of
and
this
will
change
effectively,
what
alice
is
asking
for,
so
alice
is
no
longer
alice.
Is
not
gonna,
ask
bob
right
sort
of
version,
one
as
she
asks
bob
for
our
war
and
peace
right,
but
who
knows
what
war
and
peace
means?
B
Right,
the
way
in
which
you
refer
to
the
content
is
by
what
the
content
is
itself
right
with
this
digital
fingerprint,
this
hash
function
of
the
data
right.
This
means,
in
a
sense
there's
only
one
of
these
things
right,
no
matter
where
the
data
is
stored,
no
matter
who
has
it
no
matter
what
system
it's
in?
B
B
B
And
turn
it
into
you
know
some
set
of
people
who
have
the
data.
You
know
we'll
call
them
providers
right
providers
of
the
data
of
the
content,
right
people
who
have
it
and
are
willing
to
give
it
to
me
right.
This
is
the
other.
This
is
the
function.
Ipfs
needs
to
provide
once
we're
on
the
same
page,
about
content,
addressing.
B
I
want
to
back
up
a
little
bit
on
this,
this
interplanetary
business,
I'm
going
to
sort
of
make
up
a
concept
I
haven't
seen.
Other
people
refer
to
explicitly
and
we'll
see
how
it
goes,
which
is
we'll
call
it
like
the
the
the
you
know,
the
benefits
of
this
like
interplanetary
property
right,
so
you
might
say
all
right.
Well,
I
mean
nobody's
going
alpha
centauri
anytime
soon,
so
why
do
I
care
so
yeah?
Let's
we'll
call
this
this
interplanetary
thing.
B
B
B
You
know,
there's
some
some
bad
ones
from
you,
know
africa
and
australia
to
each
other,
which
are
like
500
milliseconds
right.
Satellite
communications
get
even
worse.
You
know
just
like
long.
Just
like
long
pings,
you
know
even
here
on
earth
is,
is
a
big
problem
and
also
just
like
bandwidth
right.
Some
some
connections
are
more
expensive
than
others
right.
B
B
You
might
know
exactly
where
this
data
is
coming,
it's
supposed
to
be
hosted
or
it
might
be
hosted,
but
if
you're
going
to
do
any
sort
of
exploring
for
where
the
data
might
be
you're
going
to
have
to
you're
going
to
hit
some
latency
cost
right,
you're
gonna
have
to
do
a
little
bit
of
exploring
and
that's
gonna
get
some
latency.
But
if
you
can
make
it
up
in
in
throughput,
then
it
won't
be
such
a
big
deal
right.
B
B
B
Right
we
have
this
hash
function
and
so
right,
like
hash
of
you,
know,
war
and
peace,
isn't
changing
book
has
been
published,
but
let's
say
you
know
we're
working
on.
You
know
working
on
some
text
file
right.
It
might
be
version
one
or
working
on
an
academic
paper.
There
might
be
version
one
of
the
paper
and
there
might
be
a
revised
version,
two
of
the
paper
I
this
these
will
result
in
two
different
content
addresses
they're,
not
the
same
thing.
B
This
gives
us,
like
you
know.
If
you
go
to
wikipedia
it
gives
us
like
versioning
and
specificity
right.
If
you
go
to
wikipedia
and
you
you
know,
you
look
at
the
references
at
the
bottom
and
then
you
see,
like
the
references
are
out
of
date,
or
they
don't
really
make
any
sense
right.
That's
because
you're
getting
this
mutable
link
to
a
website
right,
which
is
in
which
is
in
a
sense
confusing
right.
It's
not
really
the
information
you're
looking
for.
B
B
B
B
B
But
in
order
to
get
this
you
know
we'll
say
these.
You
know
like
the
interplanetary
properties,
it
needs
to
be
self-certified,
and
so
one
way
to
do
this,
and
there
are
a
number-
is
I,
but
I
can't
ask
to
use,
is
author
addressing
right
again,
there's
probably
a
more
literature
generic
word,
but
this
is
what
it
is.
It's.
B
B
B
A
B
Depends?
Yes,
so
you
will
have
to
think
about
how
you
structure
your
data
to
grant
some
to
grant
you
some
of
these
abilities
right.
You
know,
if
you
take
a,
I
don't
know.
Let's
say
you
have
some.
You
have
some
json
file
right
and
you
want
your
china
you're,
trying
to
figure
out.
How
do
I,
how
do
I
make
any
use
of
that?
B
Which
brings
us
to
to
the
next
thing
I
want
to.
I
want
to
talk
about
which
is,
and
for
all
of
you
out
there,
I'm
sorry
about
all
the
acronyms
I
swear
ipld,
which
is
again
got
this
interplanetary
property
link
data
right,
which
you
know
if
you're
familiar
with,
like
jason,
ld
and
etc,
is
basically
I
just
want.
B
I
want
to
be
able
to
describe
sort
of
you
know
normal
things
like
like
lists
and
maps,
and
you
know
and
strings
and
integers,
but
I
also
want
to
be
able
to
describe
a
link
to
another
another
piece
of
data
right
instead
of
just
having
nested
structs.
All
the
way
down.
I
want
to
be
able
to
like
actually
have
a
thing
in
here
that
says.
B
Link
here
is
where
the
other,
here's,
where
the
rest
of
the
data
lives
and
an
ipld,
is
as
core
it's
it's
a
very
it's
like
a
very
generic
form
for
how
to
describe
this
information
and
and
how
sort
of
the
the
generic
properties
will
or
how
we
arrive
at
this.
Well,
we'll
go
into
a
little
bit,
but
but
high
level
from
the
linking
is,
let's
say
you
wanted
to
do.
I
don't
know
you
have
some
root.
Oh
all
right,
you
have
some
root
and
you
know
it's
got.
It's
got.
B
You
know
number
one
over
here
on
the
left
and
it's
got
number
two
over
here
on
the
right
right.
These
two
different
nodes.
You
might
you
might
look
at
the
structure
and
say
that
it's
something
like
you
know
you
know
left
is,
is
you
know
number
is
you
know
number
one
and
right
is
two
right,
but
where,
where
one
and
two
are
these
linked
objects,
so
there's
some
right
sort
of
it's
like
the
link
to
one
and
like
the
link
to
two.
B
In
this
you
know
d-web
space
and
everyone's
doing
it
a
little
bit
differently
for
pretty
good
reasons,
but
the
the
underlying
primitive
is
the
same,
which
is
why
you
know
when
people
say
merkle
tree,
they
tend
to
just
sort
of
gloss
over
exactly
what
it
is
right,
but
it's
just
the
hash.
You
add
up,
you
know
you
have
hashes
and
you
have
the
objects
in
the
child
nodes,
and
then
you
know
in
the
child
nodes
and
then
the
parent
node
is
just
the
hash
of
the
children
nodes
right.
B
B
B
People
have
different
hash
functions.
There
are
different
hash
functions.
People
have
very
good
reasons
for
preferences
for
for
these,
but
as
soon
as
you
try
and
change
the
hash
function,
you're
using
things
start
to
get,
or
you
start
to
allow
for
the
use
of
multiple
different
hash
functions.
Things
start
to
become
complicated,
because
now,
how
do
I
figure
out
whether
this
256,
you
know
bits
of
data,
is
a
sha-256?
B
B
Digest
right-
and
you
know
so-
I
can
say
that
for
shot
256
shots
to
256.
This
is
you
know,
the
code
is,
is
you
know
0x12
and
I'm
using
the
full
thing,
which
is
you
know,
which
is
20.
and
then
some
bytes
next
up
will
be
will
be.
So
this
tells
me
I
can
use
whatever
hash
function.
I
want
for
the
links,
which
is
good
now
people
serialize
the
data
in
different
ways,
so
we
need
to
account
for
that.
Some
people
are
gonna
they're,
the
ethereum
blocks.
B
Don't
look
like
the
bitcoin
blocks,
which
don't
look
like
json,
which
doesn't
look
like
cyborg,
which
right
so
we
need
some
way
to
describe
how
we
transform
or
how
we
abstract
over
sort
of
the
core
linking
properties.
And
for
this
we
will
use
a
coda,
a
multi-codec,
and
this
is
really
simple.
It's
just
a
code,
it's
just
the
code
in
some
table.
B
Some
examples
include,
you
know.
There's
one
that's
called
dag
sebor,
which
is
sort
of
you
know
include.
You
know
a
way
of
using
something
that
looks
like
seabor
to
to
encode.
You
know
direct
directed,
acyclic
graphs.
We
have
you
know.
We
have
like
a
bitcoin,
you
know
you
can
have
a
bitcoin
transaction.
B
B
It
is
you
know,
sort
of
the
version
number
of
the
cid
format
right
or
the
version
codec,
and
then
it's
the
coda
and
then
it's
the
multi-codec
and
then
it's
the
multi-hash
right.
We've
basically
just
glued
these
things.
Together
with
again
this
extra
property
where
hey,
we
might
need
to
change
this
thing
in
the
future.
So
if
we
just
throw
in
another
variant
in
front,
we
can
make
sure
that
we
can
upgrade
this
if
we
need
to.
B
A
A
B
B
Oh
no,
thank
you.
I
will,
I
will
go
down,
we
have
multi
bass
and
that
is
the
same
concept
as
all
the
other.
You
know
multis,
which
is
for
the
low
cost
of
a
character.
I
can
figure
out
what
base
encoding
this
thing
is
is
base.
Do
you
like
base64?
Do
you,
like
you
know
the
bitcoin
base
58
encoding?
Do
you
like
base
32?
Do
you
like
hex?
B
B
A
B
Hex
encoding
sometimes
makes
it
a
little
easier
to
see
where
all
the
bytes
are
right
would
be
now
f
for
hex
zero
one,
because
that's
the
codec
for
cid
version,
one
which
is
the
one
we're
using
right.
Now
there
is
one
that
is
so.
If
I
just
do
like
ipfs
added
a
file,
what
I
will
likely
get
is
something
like
this.
B
B
The
multi
is
the
fact
that
it
can
represent
many
things
right,
so
the
multi
base
says
any
any
base
could
go
here
and
everything-
and
this
should
you-
can
substitute
any
base
here
and
have
a
valid
object
right.
I
see
right,
multi,
codec
says:
hey
any
ipl,
you
know
says
like
substitute
any
ipld
codec
in
here
right.
B
No,
no,
no,
it
is
a.
It
is
a
good
question,
but
yeah,
no,
no
that's
yeah!
The
multi
is
is
for
the
the
sort
of
the
substitute
ability,
property
and,
and
so
with
our
you
know.
Now
that
we
are,
we
are
armed
with
cids
that
we
can
use
as
links
everywhere
now,
so
that
we
sort
of
generalized
this
hash
thing
right
for
some
context.
There
existed
cidv0
and
cidv0
was
didn't,
have
a
lot
of
these
multi-things,
it
had
multi-hash,
but
it
was
basically
like.
B
Oh
yeah,
we'll
just
use
a
shot,
256
and
we'll
assume
that
it's
always
you
know
it's
always
dag,
pb
and
and
whatnot,
and
it's
always
going
to
be
base
58
encoded
and,
like
these
things,
all
eventually
came
to
bite.
So
you
know
to
bite
us
at
some
level
and
so
working
with
primitives
based
on
multi-formats,
which
is
like
super
lightweight,
and
you
can
just
implement
the
parts
that
you
need
right.
You
don't
need
to
implement,
implement,
base
32
in
your
application,
if
you're
only
using
base
16
and
base
64..
B
You
can
have
whatever
it's
like
63
characters
like
you
know,
something
like
that
like
60
characters
or
something,
and
we
wanted
to
use
base
32
encoding
because
it
was
efficient
and
whatnot,
but
but
for
certain
for
certain
pieces
of
information
we
wanted
to
put
in
the
into
the
url.
It
was
just
a
little
bit
over
the
limit.
It
was
like
a
couple
characters
over,
so
we
switched
it
to
base
36
encoding
instead,
and
that
was
not
painful
right
or
not,
not
particularly
painful,
because
it's
just
another
way
to
represent
the
data.
B
B
Okay,
all
right,
I
think,
we're
I
think,
we're
good
on
time
so
but
we'll
see
how
it
goes
so
the
ipld
data
model
right.
So
I
guess
we'll
say,
like
the
the
base
thing
that
you
might
want
to
to
know
about.
Ipld
is
you
know
it's
going
to
have
all
the
normal
json
things
like
we
talked
about.
You
know
whatever
it's
sort
of
you
know
the
ipld
data
model.
B
Json
data
model,
plus
we
want
raw
bytes,
because
these
are
really
nice
for
things.
You
want
to
be
efficient
and
we
want
links
right
and
then
you
can
path.
You
can
path
through
things
so
say
I
have
some
some
cid
encoded
in
base
32.
Whatever
you
know,
you
know:
baffy
abc
dot,
dot
that
can
refer
to
some
content,
but
I
can
also
path
into
it.
So
I
can
say:
like
baffy
abc
slash,
you
know
you
know
field
one
or
whatever
you
know
my
slash.
B
A
B
Okay,
cool
all
right,
I
have
to
switch
back
windows
double
check
all
right,
so
a
little
while
ago.
You
brought
up
this.
This
point,
which
I
was
very
good
and
I
totally
glossed
over
it.
I
was
hoping
my
answer
would
be
good
enough
to
last
me
until
now,
which
I
think
maybe
it
did,
which,
as
you
said
well,
you
know
this
deduplication
stuff
doesn't
really
work
so
well.
B
You
know
up
into
smaller
pieces
right,
even
if
you're
talking
about
something
that's
just
raw
bytes
and
it's
not
going
to
have
a
dag
structure
and
we're
not
going
to
even
if
you're
not
going
to
create
some
graph
structure
around
this,
which
is
highly
optimized
and
you're,
going
to
use
some
existing
thing
like
a
zip
file,
you
may
still
want
to
chunk
up
the
pieces
or
you
know,
or
a
video
or
whatever.
You
may
still
want
to
chunk
up
the
pieces
smaller.
B
So
you
can
do
things
like,
so
you
can
do
things
like
allow
multiple
people
to
download
pieces
at
the
same
time
right
in
order
for
me
to
download
some
data
from
a
ran
from
an
arbitrary
person
and
be
okay
with
the
fact
that
I
don't
trust
them,
it
needs
to
have
some
hash
associated
with
it
right.
Some
way,
I
can
verify
the
data.
B
B
B
Unix
fs,
you
know
which
basically
just
takes
you
know,
file
system
things,
file,
system,
objects
and
turns
them
into
dags,
and
it's
not
the
only
way
to
do
this.
I
don't
think
it's
not
the
best
way
to
do
this.
We've
come
up
with
other
things,
we'd
like
to
do
since
then.
That
you
know
are
being
are
being.
B
Right
because
even
you
know,
you
have
things
like,
you
have
a
file
system
and
the
file
system
you
know
maybe
has
has
fi,
has
like
a
has
like
a
directory,
and
the
directory
has
another
directory
which
has
files
you
know,
and
that
one
has
files
and
so
on,
and
you
need
to
somehow
turn
it
into
some
dag
where
everything
is
a
little
more
broken
up
somehow
arbitrarily
right,
your
files
are
too
big.
You
want
to
chunk
them
up.
Your
directories
are
too
big.
B
B
B
You
just
keep
adding
more
to
the
end,
but
it's
not
great
if
you're
gonna
insert
something
in
the
middle
right,
because
then
you're
gonna,
like
throw
this
whole
chunking
scheme
out
of
whack,
and
your
deduplication
is
gonna,
go
down
so
for
this
you
can
use.
There
are
like
content-based
chunkers
that
take
into
account
the
data
that
you
are
hashing
in
order
to
figure
out
or
the
data
that
you
are
processing
to
figure
out.
B
Where
would
be
a
good
place
to
break
it
up
and
those
those
are
a
little
more
amenable
to
allowing
for
like
extra
data
in
the
middle,
but
this
is
like
just
you
know,
sort
of
like
one
area
of
exploration
and
relates
to
just
one
particular
type
of
codec
or
one
particular
type
of
not
even
the
codec.
This
is
a
layout
on
top
of
it.
This
is
right.
How
do
I
create
my
data
on
top
of
the
existing
codec?
That
just
helps
me
do
effectively
serialization
of
the
dag.
A
A
A
In
that
case,
if
there
is
a
particular
file,
that
file
has
only
one
address
right,
but
once
we
have
multiple
hashes,
multiple
ways
to
chunk
it
up.
Suddenly
the
same
war
and
peace
can
can
exist
in
in
multiple
like
if
I'm
uploading
war
and
peace,
the
probability
that
it
will
that
the
hash
will
be
the
same
as
the
same.
B
B
In
in
sort
of
in
the
abstract
sense
right,
these
two
things
that
are
chunked
up
differently
are
not
the
same
right
like
if
mike.
If
my
machine
has
like
you
know,
two
megabytes
of
ram
and
the
and
one
version
of
this
had
things
in
one
megabyte
blocks
and
the
other
had
five
megabyte
blocks
like
I
could
reproduce.
One
thing
like
one
of
these
I'd
be
like
I'm
having
problems
with
this
one
dag,
but
not
the
other
one
right.
So
these
things
are
not
the
same,
but
yet
they
are
right,
like
the
thing.
B
A
B
B
It's
it's
like.
It
depends
on
how
you
think
about
it.
I
guess
whether
data
means,
like
the
data
I've
received
over
the
wire
or
data,
means
the
concatenation
of
the
leaf
nodes
that
you
care
about.
I
would,
as
I
was
writing
it.
I
was
like.
I
don't
even
know
what
the
right
way
is
to
describe
this,
which
is
like
a.
A
B
B
If
I
could
search
the
ipfs
network
to
say,
hey,
I'm
looking
for
the
shot,
I'm
looking
for
this
like
shot
256,
anyone
know
where
it
is,
but
someone
could
be
storing
it
using
the
shot.
Three.
Someone
like
there's
any
number
of
things
that
could
change
here,
even
without
the
dag
itself
right,
even
just
the
hash
function
referencing
it
could.
A
B
B
B
Is
like
how
the
web
is
built,
and
so
it's
one
of
these
things
that,
like
it,
it
hurts,
but
it
doesn't
hurt
that
bad
and
there
are,
I
think,
schemes
that
you
could
use
to
get
around
this.
You
know
you
could
have
schemes,
some
of
which
could
be
like
kind
of
really.
You
know
you
could
go
like
you
know,
full
trust
and
just
or
you
know
not
full
trust,
but
you
know
high
trust
and
be
like
okay,
I'm
just
going
to
ask
you
to
send
me
the
shot
256
of
the
whole
file.
B
If
you
have
it,
you'll
keep
a
separate
index
that
has
it
for
for
files
in
particular
and
then
like
you
could
send
it
to
me,
and
I
have
to
download
the
whole
thing
before
I
can
check
it.
I
could
do
that,
but
it's
a
little,
but
that
would
be
a
little
unfortunate
right.
We'd
lose
some
of
these
other
properties.
B
You
could
take
advantage
of
the
fact
that
things
like
sha-1
and
shot
2
are
streaming
hashes
and
I
could
download
the
file
backwards
so
that
I
could
keep
confirming
that
the
I
could
download
it
from
the
end.
Going
back
so
that
I
could
keep
confirming
that
that
the
blocks
I'm
downloading
can
hash
into
the
final
results
I
could
use.
Some
sort
of
you
know
zero
knowledge
proof
to
to
prove
that
two
dags
are
equivalent
under
some
rep
under
some
set
of
properties
that
I
care
about.
B
B
B
Right
who
has
who
has
the
data
ipfs
is
built
on
the
p2p,
which
is
a
peer-to-peer
networking
stack
or
using
it
for
for
all
sorts
of
stuff
right?
The
idea
is
to
make
it
sort
of
pluggable
to
what
you
need.
Do
you
need
tcp
or
websockets
or
quick,
you
know
or
you
do
you
want
tls
or
noise,
like
all
sorts
of
you
know
what
kind
of
multiplexer
do
you
want?
B
B
It
is
newer
and
very
useful
for
for
reasons
that
will
sort
of
become
obvious
as
we
look
at
bitswap
and
bitswa,
and
this
finding,
who
has
the
data
is
mostly
the
dht,
although
also
a
little
bit
of
bit
slop
which
we'll
we'll
come
to
so
bit
swap
works
like
this.
We
have
alice
and
we
have
bob
and
we
have
some
graph
or
we
have.
We
have
a
set
of
people
we
have
whatever
we
have
bob,
we
have
charlie,
we
have
dan
and
we
have
some
graph.
B
B
She'll
ask
for,
b
and
c
she'll
get
back
and
then
she'll
ask
for
you
know:
d
e,
f,
g
and
she'll
get
them
back,
and
these
can
be
divided
up
between
all
of
the
all
of
the
peers
right,
the
more
peers
there
are,
the
more
I
can
send
off
the
blocks
right.
So
obviously,
for
the
first
round
a
I
can't
chunk
that
one
up,
I
don't
have
enough
information,
I
don't
know
what
else
I
need.
B
and
c
I
can
send
to
different
people.
The
efg
I
can
send
to
three.
B
B
B
Of
course.
The
unfortunate
thing
here
is
like
obviously,
in
the
case
where
bob
has
the
data
is
the
only
person
who
has
the
data
right.
If
bob
is
the
only
person
who
has
the
data
or
your
data
looks
like
it
looks
like
a
chain
instead
of
like
if
your
data
is
deep
instead
of
wide
right.
If
it
looks
like
this
you're
going
to
be
really
sad,
because
this
whole
process
is
latency
bound
right.
B
You
know
alice
can
send
some
like
selector
along
with
a
so
she
could
say,
like
you
know
a
you
know,
plus
everything
underneath,
for
example
right
or
you
could
ask
for
subsets
of
a
you
know.
I
want
a
b
and
everything
underneath
and
I
want
to
ask
someone
else
for
ac
and
everything
underneath,
so
you
can.
You
can
do
more
of
that.
This
will
probably
make
its
way
into
ipvs.
You
know
in
in
the
future,
but
it
requires
you
might
imagine.
B
A
B
Yeah,
so
so
bitswap
is
basically
it
swaps
bits.
It
knows
nothing
about
the
structure
of
graphs,
there's
a
thing
that
lives
above
it.
That
knows
what
graphs
are,
and
so
it
tries
to
traverse
the
graph,
and
it's
like
I
want
a
bit
swap,
can
you
or
do
I
have
a
locally
no
bit
swap?
Can
you
get
me
a
sure
and
then
it
says
okay.
B
We
are
connected
to
right,
I
mean
those
are
those
are
like
pretty
cheap
right,
it's
like
one,
you
know
just
like
send
a
packet,
do
you
have
stuff
and
they're
like
yes
or
no,
and
if
yes,
they
get
added
to
the
session,
and
then
we
don't
have
to
broadcast
to
everyone
anymore
right,
because
you've
already
found
the
limited
subset
of
people
who
actually
have
some
stake.
Have
some
interest
in
this
data
and
the
second
is
we
ask
the
dht.
B
B
So
running
a
little
long
time,
so
I
we
can
go
into
some
of
this.
A
little
bit
here
is
the
crash
course
to
cademya,
which
is
the
dh
which
is
sort
of
the
the
the
structure
of
the
dht
that
we
use.
We
do
some
things
a
little
bit
differently,
but
that's
like
the
the
main
the
main
underlying
component
is,
it
can
never
is
based
on
kedamalia,
okay,.
B
B
B
A
public
key
yeah
it
may
be
a
hash
of
a
public
key.
Also
if
the
public
key
is
too
big,
rsa
keys,
we
use
hashes
of
public
keys,
elliptic
curve
keys.
We
just
use
the
public
keys
because
they're
small
enough,
but
they
all
have
to
be
in
the
same
space,
no
matter
what
key
type
they
are,
so
we
shot
256
all
of
them.
B
We
ordered
by
sha256.
You
know
as
integer
interpreted
as
integers,
okay
and
now
they're
all
ordered,
and
what
we're
going
to
do
is
basically
treat
this
thing
like
a
skip
list
right.
So
in
a
skip
list,
you
are
connected
to
people.
You
know
one
two,
four
eight
away
right,
and
so
you
can
get
to
any.
You
know
you
can
get
to
like
the
70th
element.
B
You're,
basically
tracking
the
peers
that
are
closest
to
you
in
that
are
closest
to
you
in
reality,
we're
actually
using
the
the
xor
metric.
So
what
it'll
be
is
I'll
say
you
know
I
want
to
keep
track
of
the
peers
where
you
know
say
zero.
I
want
to
keep
track
of
the
peers.
Where
you
know
me,
you
know
xor,
you
know
pierre
is
like
where
we
have
zero.
We
have
zero
bits
in
common
right
where
we
have.
Our
common
prefix
of
bits
is
zero.
A
B
It's
like
breaking
a
hash
function
and
and
I'll
keep.
Maybe
you
know
we'll
I'll
keep
some
number
of
these
guys.
Maybe
I'll
keep
20
maximum
in
each
bucket,
and
so
that
will
allow
me
to
sort
of
jump
around
the
routing
table,
because
when
I
everyone
always
knows
the
people
closest
to
them,
everyone
knows
always
the
the
20
people
closest
to
them,
because
those
guys
those
those
will
be
down
here.
You
know
in
this
end
and
those
tables
will
be
sparse.
B
I'm
not
going
to
run
out
of
slots
for
them,
and
so
I
can
always
get
traverse
closer
and
closer,
because
I
ask
this
node:
hey:
do
you
know
anyone
closer
to
the
the
target
I'm
looking
for
and
they
say
yeah.
I
know
this
guy
and
you
ask
them:
do
you
know
anyone
closer
and
so
on
until
you
find
the
target
and
and
in
order
to
sort
of,
I
guess
the
the
generic
form
of
this
is
that
when
we
do
a
when
we
do
a
put
slash,
get.
B
B
Okay-
and
this
is-
and
this
is
basically
kid-
emilia-
has
logarithmic
lookup
time-
logarithms
are
are
good.
They
they
make
this
like
really
small.
The
number
of
hops
you
need
to
find
data
should
be
like
three
at
most
right,
as
these
networks
get
large
and
maybe
get
up
to
like
four
I
mean
like,
as
these
networks
start
to
get
like
really
large,
they
go
up,
but
the
constant
number
of
hops
is
like
not
that
big
and
there
are
there
there.
B
B
There
are
other
schemes
you
could
use
to
to
speed
things
up
right.
The
other
schemes
like
coral,
which
which
focus
on
like
how
do
I
create
latency,
ring
based
dhts
so
that
I
sort
of
create
smaller
groups
before
I
go
up
to
the
larger
groups,
so
that
I
can
find
the
data
closest
to
me
more
efficiently
right.
So
there's
other
sorts
of
schemes
here,
but
reminder
it
does
not
matter
what
this
routing
system
right.
The
dht
is
like
not
intrinsic.
B
B
So
the
you
know-
and
there
are
people
like
there-
are
people
who
are
building
on
top
of
ipfs
in
various
ways
who
you
know:
we've
improved
the
dht
a
lot
in
the
last
year
in
particular,
and
there's
still
there's
still.
Some
really
like.
You
know
nice,
big,
big
chunks
of
work
that
we've
got
ahead,
but
for
the
people
who've
had
like
more
specialized
these
cases
where
they
they
need
to
find
other
ways
to
do.
B
This,
they've
been
able
to
build
other
routing
systems
or
they
are
they're
in
the
process
of
doing
so,
because
why
not
ipfs?
Is
this
flat
space
right,
everybody's
hashes?
They
live
in
the
shared
space
right.
If
there's
a
c
id
of
data
stored
in
swarm
all
right,
because
swarm
can
use
cids
to
refer
to
data
and
we
have
a
swarm
codec
which
we
do,
which
there
is
right,
then,
realistically
I
I
could
find.
B
I
could
look
for
swarm
data
in
ikfs
and
if
anyone
who
who
was
publishing
it-
and
you
know
if
I
knew
where
to
go-
look
for
them,
I
could
set
up
a
routing
system
that
way
if
they
were
providing
and
saying.
I
have
this
data
and
telling
everyone
in
the
public
dht
that
they
have
it.
I
could
find
the
swarm
data
in
ipfs,
and
that
would
just
work,
so
I
would
say,
like
the
key
like,
I
guess,
the
the
the
key
takeaway
for
me,
at
least
with
this
stuff,
is
like
content.
B
Addressing
is
really
nice,
because
I
I
do
not
have
to
care
where
the
data
comes
from,
not
just
from
like
a
which
ip
address
has
a
perspective,
but
even
from
a
system
perspective
right
there
there
are.
There
are
blockchains
that
incentivize
data
storage
and
it
doesn't
matter
which
one
of
those
you
would
use
right.
It
doesn't
really
matter.
If
I'm
storing
the
data
on
amazon,
it
doesn't
matter.
If
I'm
running
my
own
server.
B
It
I
can
just
it
doesn't.
I
don't
have
to
depend
on
sort
of
the
success
of
other
systems.
I
don't
have
to
be
tied
so
deeply
to
them.
I
can
diversify
in
the
same
way,
I
don't
have
to
be
tied
to
the
success
of
a
particular
sterilization
format
by
pld.
I
can
diversify
same
with
all
of
these
things.
The
idea
is
to
the
stack
has
been
designed
to
try
and
make
it
as
easy
to
swap
out
things
as
possible
so
that
we
don't
have
to
guess
in
advance.
B
What's
going
to
become
successful,
we
can
adapt
to
the
ecosystem
and
how
it
is
evolving
and-
and
I
think
that's
that
is
something
I
would-
I
would
recommend
other
projects
to
to
look
at,
because
I
that's
been,
I
think,
very
helpful
for
us.
It
also
helps
with
our
engagement
with
with
other
people
in
the
web3
ecosystem
is
like
we
just.
B
We
just
want
to
work
with
them,
because
we
want
to
make
sure
that
if
they
have
good
ideas
that
like
people
who
exactly
fast,
can
make
use
of
their
good
ideas,
yep
right
this
sort
of
like
collaborative,
open
source
thing
where,
like
you,
don't
need
to
use
everything.
You
just
need
to
use
the
parts
you
need-
and
I
think
we
are
we
are.
We
are
out
of
time,
but
we
can
talk
about
naming
another
time
because
mutability
is
a
whole
other
can
of
worms.
Yeah.