►
From YouTube: IPFS Weekly Call 2019-05-06 🙌🏽📞
Description
IPFS Newsletter: https://tinyletter.com/ipfsnewsletter
A
B
For
the
people
on
the
call
you
know
that
is
three
times
but
ipfs
office
hours
is
a
thing
that
happens
just
before
the
idea.
That's
weekly
cool,
so
you
missed
it
because
this
weekly
pulls
happening,
but
it
will
happen
again
next
week
and
if
you're
interested
in
contributing
so
I
give
this,
but
don't
know
where
to
get
started
or
you're
running
in
a
production,
and
you
got
some
questions
like
we're
there
to
help
its.
We
are
available
to
talk
to
you
come
check
anyway.
Thank
you
very
much.
Awesome.
A
Once
again,
Ali
thank
you
for
doing
this.
It's
great
all
right,
so
we
don't
have
any
more
announcements,
so
we
will
start,
and
today's
presentation
is
about
network
tape.
Network
is
an
off
chain
container
for
our
private
data
and
we
have
block
if
your
chain
here,
to
tell
us
and
talk
about
keeping
Network
and
how
its
using
lid
p2p.
So,
if
I
further
ado
václav
appeal
to
thank
you
for
being
here
and
I
will
turn
it
over
to
you,
so
you
can
present
Thank
you
Thank.
C
D
C
Awesome
so
my
name
is
Pioche
together
with
raga.
We
would
like
to
give
you
a
presentation
about
how
do
we
use
the
p2p
keep
network?
We
will
first
talk
about
what
is
key
and
how
it
works,
and
then
we
talk
about
how
do
we
you
slip
it
to
pee
so
jumping
to
keep
if
I
had
to
describe
keep
in
just
one
sentence,
I
would
said
that
keep
the
privacy
liar
for
public
dog
chains
over
the
last
few
years,
public
blockchains
pros
incredible
transparency
and
auditability
with
in
the
table
and
censorship
resistant
records.
C
However,
any
smart
contract
that
is
published
to
the
blockchain
can
be
easily
accessed
by
competing
interests,
so
when
companies
consider
building
applications
on
blockchain
privacy
is
one
of
the
primary
issues
that
arise
and
keep
is
a
bridge
between
public
blockchain
and
private
data,
so
public
contracts
can
held
as
the
full
power
of
blockchain
technology
without
compromising
on
transparency
and
privacy.
We
can
also
say
that
keep
is
a
form
of
a
private
computer
able
to
store
and
compute
data
hidden
even
from
itself.
C
One
of
the
underlying
primitives
of
keep
network
is
the
random
beacon
which
is
responsible
for
providing
a
trusted
randomness
source
for
public
blog
chains.
We
can
divide,
keep
Network
into
two
parts.
The
part
that
we
call
on
chain
is
a
set
of
aetherium
contracts
that
sell
as
a
kind
of
an
api
to
our
network.
The
second
part
that
we
call
off
chain
is
a
connected
network
of
keep
clients
which
use
special
communication
protocols
to
serve
requests
from
the
chain.
C
For
now,
we
can
focus
on
random,
become
because,
from
the
perspective
of
the
PE,
we
will
use
pretty
similar
mechanisms
for
all
other
futures
of
hip
network.
So
the
way
when
the
beacon
works
is
that
external
client
publishes
a
request
to
the
chain.
The
request
says:
please
produce
a
random
number
for
me.
Keep
clients
receive
this
request
from
the
chain
and
subset
of
them.
Those
clients
that
are
in
the
group,
which
is
the
chosen
group,
cooperate
to
produce
a
random
number.
C
The
way
this
cooperation
protocol
is
designed
does
not
allow
anyone
to
employ
the
result,
and
the
result
can
be
later.
Cryptographically
proved
to
be
free
of
manipulation,
so
keep
coins
published
the
result
to
the
chain
and
they
start
another
protocol
called
group
selection
that
will
allow
them
to
elect
a
new
group,
and
this
new
group
will
be
added
to
group
registry
and
this
group,
this
new
group
may
or
may
not
be
asked
in
future
to
produce
a
new
random
number.
This
is
also
kinda
random,
which
group
is
chosen.
C
So
if
you
look
at
it
from
off
chain
perspective,
this
part
that
is
connected
to
the
chain.
We
have
a
clients
connected
to
each
other
using
clip
p2p
inside
this
network,
clients
form
groups.
One
note
one
pill
can
be
a
member
of
several
groups:
clients,
peers,
communicate
inside
those
groups.
Groups
are
chosen
randomly
and
they
have
a
limited
time
span
from
the
perspective
of
the
network.
We
need
the
following
properties,
so
clients
must
be
able
to
efficiently
exchange
messages
inside
those
groups.
Messages
must
have
a
very,
very
high
delivery
rate
inside
the
group.
C
Some
communication,
the
group
has
to
be
public.
Some
communication
has
to
be
kept
private
between
two
clients.
We
require
message
attribute
ability,
so
sender
must
be
well
defined
and
the
message
must
provide
senders
of
the
station.
We
require
integrity
of
messages,
so
we
need
to
be
able
to
detect
a
message
was
tampered
and
we
need
a
pill.
E
These
are
ECDSA
keys,
and
so
we
have
interfaces
between
our
aetherium
code
and
our
live
p2p
code,
and
we
take
these
ECDSA
keys
and
we
turn
them
into
the
Lib
PDP
representation
and
then
from
there
we
get
our
peer
ID
and
we
also
use
listen
address.
We
use
DHT
hosts
custom
transports,
so
we
instantiate
all
this
stuff
and
that
kicks
off
our
network
that
allows
the
client
to
connect
to
the
lid
p2p
network
and
then
going
to
the
next
slide.
E
You'll
see
that
what
we
do
from
here
is
that
clients
need
to
find
a
bootstrap
list,
and
so
like
well
table
show
a
bunch
of
bootstrap
nodes,
we're
a
little
worried
about
this,
because
they
seem
like
boss,
vectors
but
we'll
publish
these
nodes.
Clients
will
connect
to
the
bootstrap
nodes.
One
of
the
things
that
we
need
to
do
is
ensure
that
there's
a
good
diversity
of
bootstrap
nodes
that
clients
can
connect
to
also
retries,
and
things
like
that.
E
E
E
So
Peter
mentioned
that
we
have
a
group
selection
protocol
in
that
group
selection
protocol
clients
basically
submit
tickets
on
the
chain,
they're
validated
like
okay,
these
tickets
are
good.
This
is
how
many
shares
you
get
and
that
allows
you
to
join
the
pub/sub
channel
and
so
basically
the
pump
sub
channels.
Just
like
a
you
know,
a
randomized
words
just
a
hash
of
all
the
clients
and
they
join
this
channel
and
every
group
is
its
own
pubs
own
channel.
This
is
a
topic
and
go
with
PDP
pub/sub.
E
So
we
just
like
form
that
topic
and
we
currently
use
flood
sub.
We've
played
around
with
gossip
stuff,
but
we
want
to
initially
go
with
flood
song
so
that
there's
a
good.
You
know
diversity
of
messages
hitting
all
the
peers,
and
if
we
see
that
episode
of
gossip
sub
are
better
for
a
use
case
in
the
future,
will
do
that.
E
So
sending
a
message-
and
these
the
next
few
slides
are
a
little
bit
out
of
date
because
we
updated
the
p2p
to
take
advantage
of
the
strict
signing
and
verification.
So
what
we
do
is
we
just
you
know
we
get
this
protocol
message.
Whatever
protocol,
the
clients
are
executing,
so
there
could
be
dkg
or
relay
signing
and
what
we
do
is
we
marshal
be
specific
protocol
message.
We
like
register
sub
handlers
and
then
we
just
send
it.
E
We
just
call
publish
we
no
longer
have
our
internal
signing
code,
we
just
got
it
all,
let
out
and
we're
relying
on
the
PDP
for
signing
the
message
and
verifying
it,
and
so
this
is
what
the
message
layer
looks
like
again.
We
use
protobuf
you'll,
see
the
lid
PDP
pub/sub
message,
and
then
you
can
just
ignore
the
network
envelope,
because
we
removed
all
that
and
now
it's
as
simple
as
the
network
message
itself.
E
Right
and
so
for
receiving
a
message,
we
basically
call
next,
which
is
a
method
that
the
pub/sub
interface
exposes
and
every
message
is
basically
treated
like
an
HTTP
request.
We're
like
okay,
this
is
a
mute,
go
routine
process
that
message
and
then
call
the
correct
handler
to
send
it
to
the
correct
protocol
that
executes.
E
Right,
and
so
we
also
wrote
a
little
bit
of
custom
code,
for
example,
handling
the
different
key
types,
but
again
we
primarily
focus
on
ECDSA
and
ensure
that
they're
interoperable
with
each
other,
and
we
have
some
custom
handling
code
as
well
right,
so
things
that
we
need
to
do
or
that
we
could
use.
So
one
of
the
things
is
that
we
need
deep
connection
management.
I
believe
this
is
going
to
be
possible
with
the
connection
manager,
but
I'm
not
entirely
sure.
E
The
reason
we
need
this
is
to
disconnect
clients
that
fall
below
the
stinking
threshold
also,
if
we
need
to
disqualify
view
there's
a
given
round
of
the
protocol.
So
we
need
something
that
can
let
us
like
Band
connections
or
cut
them,
or
you
know
server
them
for
some
period
of
time.
We
need
more
resilient
bootstrap,
as
mentioned
before,
so
that's
to
ensure
that
we
get
a
good
diversity
of
booster
appears
and
then
we
need
to
have
a
retry
er
there's
a
few
options
here.
E
A
Okay,
next
is
QA,
so
if
anyone
has
a
question,
they
could
put
it
in
chat.
That
would
be
wonderful.
A
So
there
are
any
questions
regarding
network
and
Lupita
Pete
implementation.
A
E
So
we're
going
to
be
launching
our
private
test
net
pretty
soon
here,
so
we
haven't
launched
yet,
but
the
folks
that
were
looking
to
work
with
our
folks
lot,
who
need
who
need
these
private
containers
to,
like
you
know,
Aragon
or
a
few
folks
like
that,
are
pretty
interested
in
these
use
cases.
Folks
that
need
decentralized,
custodial
solutions
would
be
very
interested
in
this.
This
technology,
one
of
the
keeps
that
were
looking
at
in
pewter,
is
given
a
few
talks
on
this
that
you
guys
can
find
online.
Our
Tec
DSA
keeps
threshold.
E
At
least
DSA
keeps
that's
going
to
be
our
first
type
and
we're
actually
building
our
first
product
in
that
which
will,
you
know
we'll
announce
more
on
that
later,
so
anybody
who
needs
a
decentralized
custodial
solution
and
anybody
who
needs
private
containers
for
data
that
could
be
interesting
to
mask
some
information
from
some
period
of
time,
but
initially
we're
just
focused
on
tec,
tsa
cubes.
So
anybody
that
has
a
private
ECDSA
keep
that
needs
to
be
remote-controlled
or
kept
securely
on
it.
There
him
and.
A
All
right,
if
we
don't
have
any
other
questions,
then
I.
Thank
you
very
much
for
presenting.
We
can
leave
it
here.
We
can
end
here
on
everyone.
You
get
about
13
minutes
back
and
I
will
see
everyone
else
at
the
next
I
can't
that's
weekly
meeting.
So
once
again,
thank
you
very
much
for
representing
expression.