►
From YouTube: IPFS Weekly Call 2019-04-22 🙌🏽📞
Description
Newsletter: https://tinyletter.com/ipfsnewsletter
A
A
A
B
Hi
everyone
is,
he
Bogdan
before
building
stuff
for
web
3
I
worked
at
GoDaddy
and
it
started
up
got
acquired
by
it.
So
there
I
was
also
building
developer
tools,
so
web
3
developer
tools
were
kind
of
natural
fit
for
me,
and
people
that
love
GoDaddy
and
started
building
stuff
forward
3.
So
right
now,
I'm
working
in
Thunder
Lee,
which
is
in
the
etherium
smart,
went
to
the
contract
monitoring
platform.
But
it's
interesting
to
see
how
we
got
to
the
idea.
B
So
before
doing
this,
we
actually
built
a
decentralized
to
the
public
procurement
platform,
so
public
procurement
is
if
the
government
wants
to
buy,
for
example,
100
chairs,
they
have
to
make
like
a
huge
auction
and
people
apply,
etc.
So
there
we
use
ITSs
in
cerium
to
make
this
totally
decentralized,
but
the
problem
with
that
was
that's
well
developing.
All
of
that
there
was
a
lot
of
friction
on
our
site,
especially
with
aetherium.
B
So,
while
talking
to
government
people
first,
we
found
out
that
we
don't
know
how
to
talk
to
government
people,
so
that
was
one
of
the
problems
that
we
couldn't
solve.
But
the
problem
that
we
did
manage
to
solve
internally
was
actually
building
development
tools
and
we
decided
to
through
having
much
more
fun
building
that
and
actually
solving
the
public
procurement
problems
like
corruption,
like
that,
so
we
started
building
tenderly.
So
let's
get
started
so
just
to
share
my
screen.
Give
me
a
sec.
Nice.
B
Okay,
so,
as
you
already
mentioned
so
tenderly
just
give
me
a
sec.
I
actually
don't
see
my
mouse
here,
just
like
I'm,
sorry,
okay,
here
we
go
so
tenderly,
as
I
said,
is
the
first
e3
employer
contracts,
monitoring
platform
that
the
bars
do
with
real-time
EVM
little
insights
for
every
transaction
of
the
network.
Now
what
does
this
actually
mean?
It
means
that
we
have
tenderly
on
one
side
which
we're
really
running
full
archive
notes,
and
then
we
can
actually
listen
to
every
transaction.
That's
happening
with
the
Syrian
Network.
B
Then
we
think
every
one
of
these
transactions
and
we
analyze
them
and
so
far
we
are
analyzing
everything,
but
we
actually
surface
data
only
about
failed
transactions.
So
if
a
transaction
failed
centrally
catches,
the
transaction
itself,
it
analyzes
it
and
uses
the
source
code
of
the
smart
contract
itself
to
give
you
a
useful
Factory,
and
then
we
also
have
this
as
a
CLI
version.
B
So
if
you're
doing
local
development,
there's
usually
stuff
like
invalid
opcode
or
require
that
fails
or
something
else-
and
you
don't
know
where
it's
actually
failed
and
coming
from
traditional
languages
having
the
normal
sectors
is
a
must.
So
we
built
up
factories
you're
more
or
less
so
with
that
trait,
on
the
platform
side
of
things,
we
can
alert,
you
can
shoot
the
web
hooks
and
your
slack
message
do
something
automatically
and
stuff
like
that,
and
so
basically
I'm
not
going
to
go
into
too
many
details
about
this.
B
On
this
specific
link,
you
can
actually
see
one
of
the
co-founders
speaking
of
how
we
build
the
tracer
itself,
which
is
totally
open-source,
and
he
goes
into
great
detail
how
you
can
max
elyda
T
byte
code
from
from
the
byte
code
itself
to
a
specific
line
of
code.
So
we
did
this
with
a
couple
of
stops,
so
we're
using
a
custom,
EDM
implementation.
Idiom
is
the
cerium
built
virtual
machine,
so
we're
running
full
RM
notes
for
both
the
main,
it's
intestine,
and
it's
interesting
that
the
set
and
maintenance
are
have
noticed
two
terabytes
of
data.
B
Actually,
so
we
have
to
start
at
somewhere.
So
we
have
a
custom
version
of
CBM
which
is
constantly
analyzing
all
the
transactions
and
eventually
mining
them.
And
then
we
have
a
this
whole
huge
custom
data
processing
pipeline,
which
is
a
combination
of
Google
cloud
platform
in
kubernetes
on
top
and
Asia
for
running
the
nodes
themselves,
and
we
also
use
IP
FS
to
start
to
store
user
contract.
So
you
can
make
sure
you
will
see
you
can
either
import
contracts
from
either
scan
and
then
we're
using
the
data
they
have.
B
But
if
you,
if
you
upload
it
to
us,
we
actually
use
IPS
as
we're
storing
the
data
in
Eclipse
the
way.
So
you
can
generate
this
person.
If
you
have
any
question
about
this,
but
better
than
telling
you
all
of
this,
let
me
show
you
actually
how
it
works.
So
here
is
how
a
failed
transaction
when
theorem
mix
right
now.
B
So
here
you
cannot
know
actually
where
a
transaction
failed
and
the
contract
itself
is
fairly
simple
and
we
still
cannot
know
where
it's
actually
failed
and
we'll
see
what
this
contract
actually
does
it,
how
it
uses
ID
FS.
But
here
we
cannot
see
any
information,
that's
useful,
even
if
they
go
to
Paris
and
trace.
For
example,
we
can
see
that
it
just
got
reverted
and
there's
nothing
actually
useful
and
we
will
see
how
that
really
can
actually
help
with
that.
B
So
to
build
this
and
I'm
gonna
actually
do
a
quick
build
here
to
show
cases
how
this
works.
We're
gonna
build
a
decentralized
password
manager
with
aetherium
and
IDPs
s.
So
what
we're
gonna
make
is
the
smart
contract,
a
really
simple
one,
which
is
going
to
store
an
IPSS
hash
for
us,
which
is
a
really
common
design
pattern
for
ECM
development
and
then
we're
going
to
use
the
IRS
the
encryption
to
stall
everything
in
an
encrypted
way
on
IDF
s.
So
to
show
you
how
this
actually
works
just
give
me
a
sec.
B
B
So
what
I'm
going
to
do
is
I'm
going
to
say,
update
master
file
and
again
because
we
know
security
is
a
must
I'm
going
to
do
one
two
three
one
two
three
again
here
and
do
this
once
more
so
I'm
going
to
get
a
pop-up
format
the
mask
here
just
give
it
a
sec
I'm
going
to
confirm
the
in
action
itself,
and
here
we
got
the
transaction
hash.
So
if
we
go
to
either
scan
just
great
to
be
free
to
finish,
actually
give
it
a
couple
of
seconds,
this
is
calling.
So
it
should
there.
B
So
you
got
mine
here.
We
can
see
at
the
actual
IP
SS
cache,
storing
this
transaction,
and
if
we
go
to
the
contract
itself,
we
can
see
that
the
transaction
was
mine
and
we
historian
is
here
now
how
we
actually
build
this,
and
how
did
this
actually
work
and
actually
another
thing.
So
if
I
ever
load
this
up
or
that
using
I
DNS,
for
example,
we
should
actually
do
load
it
up.
I
can
say:
load
Master
File
after
the
super
secure
password
that
we
use,
and
it's
actually
getting
the
query.
B
The
blotching
for
the
ipfs
hash,
pull
down
the
back
binary
data,
decrypt
it
and
show
me
the
information
that
we
entered.
So
you
can
see
it
1
2
3
1
3.
So
this
is
how
we
can
use
the
theorem
in
IVFs
to
store
data,
because
when
a
theorem
is
too
pricey
to
search
data
and
it's
really
inefficient
and
that's
where
ideas
that
shine
to
be
a
good
data
storage.
So
let's
see
what
actually
happened
in
the
background
for
the
demo
that
I
showcase.
B
So
we
have
a
JSON
document
that
we
used
an
encryption
key,
which
was
the
master
class
master
password
a
enter,
and
we
got
some
gibberish,
which
is
binary
data
encrypted
binary
data.
Then
we
take
the
data
submitted
to
ipfs
and
we
head
back
the
multi
hash
that
ipfs
gives
back
and
then
we
take
the
multi
hash,
send
it
to
metamath
to
sign
our
transaction
and
send
the
transaction
to
the
Syrian
Network.
B
So
the
payload
itself
that
it
sent
looks
like
this,
which
is
fairly
simple,
where
you
have
like
a
website
a
username
and
password,
and
the
encryption
itself
is
really
easy
and
I
thing
that
I
love
about
ipfs,
that
you
can
use
like
really
simple
stuff
to
make
great
abstractions
to
do
complex
stuff
in
a
simple
way.
So
what
we
do
here
is
we've
run
for
a
master
password.
We
use
cryptic
ojs
library,
which
is
really
easy
to
use
to
generous
and
our
generates
an
RSA
key
pair.
We
strain
it
by
the
bachelors
that
we
have.
B
We
encrypt
everything
and
we
just
send
it
to
IDF
s,
and
this
is
so
easy
and
we
got
the
hash
back.
So
now
we
can
actually
see
the
smart
contract
itself
we
saw
so
we
have
something
called
password
manager
which
has
the
password
owner,
which
is
the
address
of
some
of
the
person
that
deployed
the
smart
contract.
B
So
that's
where
we
have
math
and
standard,
then
we
have
a
really
really
simple
function
called
send
hash,
which
uses
which
just
gets
a
string,
and
here
we
assert
that
the
message
sender
is
actually
the
password
owner
of
the
password
manager,
and
this
is
actually
where
the
first
transaction
failed.
But
we
will
see
how
generally
I
can
actually
map
this
to
this
at
the
contract.
B
And
then,
if
the
yesterd
passes,
we
can
store
the
I
BFF
cash
that
we
send
send
there,
and
also
we
have
a
simple
view:
function
which
is
more
or
less
like
the
utility
function,
where
we
just
returned
the
ipfs
cash
that
the
classroom
manager
is
holding
so
again
a
couple
of
lines
of
code
and
we
can
use
the
theorem
and
I
guess
that's
star
stuff,
which
is
really
cool,
so
submitted
a
transaction
itself.
We
need
a
small
set
up,
so
usually
I'm
coming
cerium.
B
We
have
something
called
an
ABI
which
is
an
application
binary
interface
when
we
have
an
address
of
the
contract,
which
is
for
this
conjugate,
I'm
Demming
is
this
one,
and
then
we
have
an
ABI
which
is
literally
like
an
API
that
you
can
use
to
interact
with
your
smart
contracts.
So
we
build
up
the
web
3
provider.
We
get
the
cerium
account
for
metamath.
In
this
case
we
passing
the
control
detail,
so
the
ID
I
and
the
address-
and
we
said
state
because
we're
using
react,
but
here
is
where
the
magic
happens.
B
So
after
we
added
everything
to
ITSs
and
we
got
the
multi
hash
back,
we
can
send
the
hash
to
the
contract
itself
and
if
everything
works,
fine,
we
can
just
store
the
transaction
hash
from
the
etherion
effort
and
also
the
idea
that
hash
and
again
this
is
why
a
lot
of
ideas,
because,
like
this
four
lines
of
code,
this
is
stored
stores
almost
forever.
So
so
how
we
do
like
loading
an
existing
file.
Again,
we
prompt
the
user
for
the
master
password.
We
get
the
ITSs
cash
from
the
contract
itself.
B
On
the
third
line,
we've
been
get
hat
and
we
do
get
cash
fall.
Then
we
use
the
files
API,
which
is
actually
abstracted
with
the
get
IPSS
method
method,
to
get
the
file
itself
converted
to
a
buffer.
Again
we
create
a
keeper
with
cryptic
Oh
and
we
just
decrypt
what
IPSS
gave
us
back
and
if
we
jason
parse
disk,
we
are.
She
got
the
batteries
from
the
beginning
of
Babu's
life,
so
again
a
couple
of
lines
of
code
and
you
get
public/private
key
encryption.
B
You
get
IDF
s
essentially
storing
and
you
called
you
got
the
multi
a
hash,
also
from
a
decentralized
storage,
Eugene
cerium,
which
is
good.
So
if
we
just
wanted
to
adjust
for
fun,
if
we
wanted
to
actually
see
how
we
can
make
this,
maybe
even
better
or
cool
or
whatever
we
can
use
one
contract
for
all
user,
which
is
basically
you
using
a
map
to
map
an
address
and
a
theorem
address
to
an
idea.
That's
multi,
hash
or
I
DNS
cache
also
work.
B
We
can
use
icns
hosting,
which,
on
a
workshop,
that
I
did,
we
actually
did
that.
So
we
had
this
serial
for
storing
the
multi
hash.
Then
we
had
ipfs
for
storing
the
encrypted
payload
and
we
also
had
IP
and
I
suppose
the
whole
thing
as
a
tab.
So
the
whole
thing
was
totally
decentralized
and
indestructible
indestructible
and
then
we
can
also
use
events
at
storage
on
the
etherium
network.
So
we
can
just
replay
events
and
in
that
way,
store
information,
but
idss
is
much
more
usable
so
to
actually
showcase
how
this
with
tenderly.
B
So
you
remembered
that
I
submitted
the
transaction
we
can
see.
It
was
let's
see
five
minutes
ago
and
it
succeeded.
But
now,
if
they
go
back
here,
choose
a
different
account,
which
is
the
klog
one
we
can
see
in
the
password
in
the
password
contract
that
we
have.
This
required,
which
says
message:
sender
must
be
password
owner
and
password
owner
was.
The
person
is
actually
deployed
the
contract.
So
if
they
go
back
here
and
using
the
different
accounts,
which
is
secured
in
metamath
I
can
try
actually
rewriting
the
account
I
just
made.
B
B
B
Now
there
are
two
ways
to
actually
add
the
contract
to
us.
So
if
you
pick
the
CLIA
method,
this
is
actually
going
to
either
upload
to
our
Google
cloud
or
to
idss.
This
is
where
we
actually
use
idea
fest,
and
we
also
have
very
excited
contracts,
so
I'm
going
to
pick
here
call
button
which
is
going
to
use
the
interest
and
one
I'm
going
to
say
AB
contract
and
here,
in
the
background,
we're
checking
if
the
contract
is
valid.
B
We're
also
going
to
pull
the
contract
itself
from
either
scan
we're
going
to
compile
the
contract,
and
now
we
suspect
everything
we
will
actually
see
the
transaction
to
failed
a
minute
ago,
but
instead
of
just
seeing
this,
which
is
unusable
to
actually
debug
something.
If
I
go
here,
we're
actually
going
to
see
the
exact
lines
of
code
where
it
broke,
and
this
wasn't
possible
until
Thunder
really
was
built.
So
this
is
what
we
built,
and
this
is
more
or
less
my
key
demo
and
what
I
wanted
to
share
here
so
I'm
open
for
question.
A
B
I
remember
when
I
was
doing
stuff
with
idns,
it's
kind
of
for
people
that
are
just
getting
into
ITSs.
It
can
be
quite
complex,
especially
when
you
want
to
map
map
it
to
T
name,
because
you
can
map
the
night
DNS
cache
to
a
cname
and
then
like
use,
regular
domains
to
actually
redirect
to
adapt.
That's
hoped
in
the
night
PMS.
So
that
was
one
of
the
things
which
is
which
isn't
lacking.
B
It
was
just
hard
to
kind
of
figure
it
out
for
the
first
time
when
we
use
it
so
I
think
that
was
the
first
thing
and
I
don't
know.
I
really
love
before
you
guys
did
like
the
WebSocket
thing
where
stuff
is
published
on
the
network
and
something
is
added
instead
they're
just
like
traversing,
the
back
I,
wouldn't
say
to
have
a
sub-sub
feature,
but
now
you
have
it
so
then
I'm
good,
so
we're
using
it
and
we're
really
happy
with
it.
So
I.
B
Yeah
for
more
advanced
stuff,
so
definitely
the
files
API
is
so
rich
and
you
can
do
so
much
cool
stuff
with
it
and
then
you
have
abstractions
like
get
and
add
and
stuff
like
that.
But
then,
if
you
like
go
to
the
files
API
after
that,
the
complexity
goes
much
higher,
like
their
learning
curve
goes,
is
much
deeper
from
that
point.
On
so
I,
remember,
I
read
a
couple
of
articles,
a
medium
that
really
helped
me
out,
but
maybe
on
an
official
dog.
That
would
be
one
of
the
stuff
that
this
could
help.
A
What
I
can
is
that
we
do
have
protocol
and
protocol
is
current.
Protocol
is
a
list
of
like
activities,
so
individuals
are
able
to
learn
more
about
ipfs
evening
API
and
how
it
works,
and,
if
I'm
not
mistaken,
their
next
lesson
is
on
like
dealing
with
files
and
handling
the
files.
So
if
you
can
even
take
a
look
at
that
and
like
give
us
some
feedback,
we
would
love
it.
The
person
who
created
protocol
is
actually
on
this
call,
and
that
is
to
Terry.
A
C
C
Yeah
we
launched
in
January,
so
the
one
that
I'm
working
on
right
now
is
specifically
about
I'm
a
fast
the
mutable
file
system
version
of
dealing
with
files
and
then
at
a
later
point
we
would
be
adding
something
about
the
non
Emma
fast
version
of
dealing
with
files,
but
we're
waiting
for
it
to
support
blobs
in
the
browser
with
that
version
before
we
built
that
content.
So
there
is
an
open
PR
right
now,
if
you're
interested
in
looking
at
the
work,
that's
in
progress
if.
B
A
We
have
compliments.
We
have
rad
demo
bogman
thanks
for
sharing
Hart
part,
your
approach
to
developer
workflow
and
debugging.
Thanks
for
the
walkthrough
I
have
another
question:
have
you
worked
with
major
ideas
like,
for
instance,
visual,
Visual,
Studio
or
sublime,
because
this
would
be
something
that
would
be
great
to
work
with
like
while
and
like
that
text
editor?
A
B
We
actually
have
the
thing
that
I
showed
you
like
a
dashboard.
You
can
run
it
as
a
CLI
itself
and
we
are
going
to
work
so
after
we're
finished,
with
the
learning
for
the
platform
itself,
looking
into
actually
integrating
with
stuff
like
Visual
Studio
code,
definitely
because
of
the
language
server
stuff
like
that,
and
also
to
see
like
with
the
whole
jetbrains
suite
of
tools,
because
a
lot
of
people
use
that
as
well
and
maybe
stuff
like
Assam
and
stuff
like
that.
B
A
Course,
of
course,
excellent,
so
we
don't
have
any
other
questions
or
comments
we'll
end
now,
but
once
again
often
thank
you
very
much
for
the
demo.
Thank
you
very
much
for
the
presentation.
We
really
appreciate
it.