►
From YouTube: TechTalk: State Of Web3.js by Eric Dvorsak
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
A
So
why
is
the
current
state
of
web
three
1.0
it's
still
in
beta,
but
we
can
already
see
that
there
is
a
lot
of
changes
compared
to
version
0.20
the
most
noticeable
one.
When
you
look
at
the
curd
is
that
everything
has
been
separated.
Every
functionality
has
been
separated
in
in
packages
and,
most
notably,
you
have
web
3
euros,
which
groups
all
the
utility
functions
that
don't
require
a
connection
to
an
ER
provider.
A
A
First
of
all,
a
word
of
caution.
I've
only
done
cold
code
analysis
so
far,
so
there
is
some
assumption
that
I
made
that
I
still
have
to
test
with
running
code
to
make
sure
it
works.
So
I've
asked
a
few
I
asked
on
the
channel
and
slack
if
anybody
had
questions
so
I
have
I
had
a
few
questions
for
steady
stream.
That
I
will
answer
at
the
beginning
of
this
talk.
I
will
start
with
the
question.
Does
it
has
all
the
features
work
with
aetherium
and
whisper?
A
A
So
Andy
mentioned
that
people
are
complaining
about
the
upgrade
a
lot
of
people
have
upgrade
or
upgraded
already
or
try
to
upgrade.
So
I
can
understand
that
it's
very
different
know
there
is
promises,
but
they
are
actually
quite
practical.
For
instance,
when
you
send
a
transaction
you
can
set
different
call
backs
depending
on
what
type
of
event
occurs.
So
when
you
send
a
transaction,
you
can
react
differently
on
the
transaction
hash
and
the
receives
on
confirmation
or
error,
and
also
there
is
no
more
sinkholes.
A
This
is
important
for
a
compatibility.
1.0
providers
are
not
compatible
with
the
previous
version
of
the
library
because
they
only
have
a
send
function
in
their
prototype,
which
is
the
old,
send.
A
sync
and
wine
point
old
library,
Rick,
cress
manager
will
use
and
I
think
when
send
is
called
on
0
20
providers,
which
means
that
when
you
have
an
old
library
it
doesn't
work
with
new
providers.
Iphone
I
can
tell.
But
if
you
have
a
new
library
it
will
still
work
with
all
providers.
So
as
adapt
creator
can
I
support
both.
A
But
you
have
to
be
careful
because
the
proper
pattern
is
to
use
your
own
version
of
web
3
library
and
only
rely
on
the
injected
provider.
So
because,
if
you
rely
on
a
web
free
library
that
is
also
injected
by
whatever
brother
you're
using
it
might
use
provide
you
with
the
old
version
of
web
3.
So
you
really
just
want
to
make
use
of
the
provider
that
is
injected
by
the
browser.
A
A
A
Requesting
the
provider
thing
it
can
be
problematic
as
well
with
all
the
apps,
because
then
they
won't
ask
for
it
and
they
won't
be
able
to
function
without
a
web.
3
object
so
without
a
web
3
provider.
So
it
is
something
that
we
have
to
think
about,
and
I
will
briefly
mention
a
possible
alternative
that
can
work
with
old
apps
as
well.
A
So
how
important
is
it
for
status?
React
to
use
web
3
0.20,
so
studies
doesn't
use
the
same
web
3
as
the
one
that
is
injected
with
in
depth.
The
web
3
that
is
injected
in
depth
is
using
LTC
URL
directly,
while
the
studies
web
3,
is
simply
an
object
which
has
seen
a
sinc
function
and
whenever
this
is
called
by
the
web
3
library
in
status,
it
calls
it
use
core
RPC,
which
is
a
function
of
status
code
that
is
accessible
in
status,
except
sometimes
it
doesn't
work
like
this.
B
A
For
to
Julian
to
recommend
for
recommending
me
to
do
that
to
clarify,
so
here
that's
what
I'm
saying
so.
That's
are
running
in
the
web
view
and
in
the
web
view
we
are
injecting
a
web
3
provider
which
is
100
lines
of
code
that
is
exist
in
web
3gs
in,
but
we
have
a
slightly
different
one
and
it
works
with
local
RPC
directly.
A
Like
you,
studies
react,
doesn't
see
the
JSON
RPC
that
goes
through
this
channel
and
instead
of
react,
you
have
the
web
3
object
that
we
are
passing
around,
that
will
call
color
PC
function
of
status
code
and
you
have
this
other
one
that
will
call
RPC
private.
So
this
is
the
one
and
only
then
the
one
and
only
example,
of
calling
this
private
web
3
and,
as
you
can
see,
it's
it's
done
by
by
setting
up
the
parameters
the
payload
of
json-rpc
directly.
So
we
have
345
uses
mention
of
word
3
in
our
code
and.
A
You
there
is
cases
where
actually
called
Webfoot
private
is
not
really
a
call
to
web
3,
but
just
direct
RPC
call
through
JSON
RPC,
with
parameters
that
I've
been
like
described
as
data,
and
when
we
don't
describe
as
data
when
we
use
web
3
the
web
3
object.
We
have
to
do
all
kind
of
things
like,
for
instance,
when
we
call
contracts,
we
have
to
prepare,
prepare
the
parameter
for
web
3.
A
A
There
is
two
use
cases
instead
of
four
for
using
web
three,
so
the
first
one
is
like
here:
contract
interactions,
but
as
you
can
see,
we
don't
really
have
to
use
web
3
for
that.
But
we
do
sometimes-
and
it's
a
thing
we
can
simplify
like
the
code
above-
could
be
more
clearly
described
in
terms
of
data.
So
it
takes
us
parameters
and
address
and
inside
into
integer
of
256
bits
and
it
returns
a
boolean.
A
A
Then
suddenly,
a
string
is
all
of
the
dynamic
parameters,
and
the
way
to
include
these
parameters
in
json-rpc
for
for
is
a
bit
more
complicated,
so
we
would
benefit
from
either
using
web
3/8
ABI
or
doing
our
own.
It's
not
super
complicated
to
implement,
so
the
other
use
cases
Stane
use
api
is
all
kind
of
api
is
whether
it's
wallet
or
so
whether
it's
the
wallet
whisperer.
A
A
A
You
don't
have
as
many
functions
available
for
for
whisper
as
we
within
web
three.
So
when
in
web
three
you
subscribe
to
a
filter,
you,
you
do
get
filter,
you
have
a
callback
that
is
called
every
time.
You
have
a
new
message,
but
when
you
look
at
whisper
functions
in
JSON
methods
in
JSON
RPC,
there
is
no
such
thing.
So
what
actually
happens
is
that
web
3
is
periodically
polling
is
falling.
The
RPC
is
polling
when.
A
A
B
A
B
A
B
Yes,
that's
you
know
we
can
show
me
the
time
around.
If
maybe
my
question
is
you
know
when
you
say
it
should
be
very
easy.
The
implements.
Do
you
have
any
kind
of
time
as
that's
around.
You
know
how?
How
long
would
it
take
and
how
many
developers
would
it
require
from
both
ago
and
the
react
sides
to
write
our
own
version
of
web
3?
B
You
know
a
lot
of
the
feedback
from
developers
has
been
not
only
that
there
were
these
breaking
changes
from
0
20
to
1.0,
but
also
that's
it's
worrying
that
it's
only
sort
of
one
person
who
is
maintaining
web
3
and
they're
doing
a
lot
of
other
things
at
the
same
time.
So
it's
not
a
very
responsive
repository
or
code
base.
Yeah.
A
So,
as
I
mentioned,
there
is
really
two
web
3
for
us.
There
is
the
web
3
that
we
have
within
studies,
react
and
that's
the
one
I'm
talking
about
when
I
say
that
we
could
replace
it,
and
then
there
is
the
web
3.
That
is
in
the
depths,
and
it's
really
two
different
things.
I
think
the
web
3
in
the
depths
are
the
interface
to
etherium,
and
it's
the
one
that
is.
A
Used
like
everywhere
for
for
every
dust,
I,
don't
think
there
is
a
depth
at
use
anything
else,
so
the
one
that
is
in
the
depths
I,
don't
know,
I,
don't
think
we
can
do
anything
about
it,
because
people
rights
their
dubs
using
that
API,
that
these
methods
and
all
we
can
do
is
have
is
act
on
the
provider.
So
I
think
I
actually
forgot
to
talk
about
that.
B
A
A
One
could
change
the
proof-of-work
value
so
that
the
user
doesn't
receive
messages
anymore.
So
we
don't
allow
that
anymore,
and
so
the
one
I
say
we
can
change.
We
can
actually
change
this,
the
web
three
within
status,
because
we
don't
really
need
it.
We
are
cooling
our
PC
and
we
could
even
call
go
functions
directly
through
the
bindings
that
we
have
and
reduce
the
level
of
indirection
between
our
code
and
status
quo
and
interesting.
B
A
And
that
can
be
done
progressively
because,
as
I
said
right
now,
we
have
a
name
implementation
of
the
ABI
and
we
so
we
we
don't
support
dynamic
parameters
and
so
reaching
that
point
where
the
this
version
of
calling
contract
without
web
3
is
reaching.
That
point
where
the
Colin
contract
without
web
3
is
equivalent
to
what
we
have
now
is
fairly
easy,
because
you
can
just
have
the
same
naive
implementation
that
doesn't
work
for
for
dynamic
parameters
and
call
send
transaction
of
statue
screw
directly
rather
than
through
web.
Three.
B
A
So
we
are
already
using
our
own
provider
and
provider
is
a
really
simple
piece
of
code.
Well,
simple,
relatively
simple:
it's
only
100
line
of
code
or
something-
and
we
already
inject
our
own
in
the
webview
so
and
our
version
is
so
when
I
said
they
are
not
compatible.
The
the
new
providers,
because
HTTP
provider,
which
we
have
is
deprecated,
though
there
is
still
code
to
support
it
in
1.0.
A
And
so
as
long
as
it's
deprecated
but
supported,
we
can
still
function
with
both
version
of
what
3.
So
the
the
trick
is
about
this
version
of
web.
We
that
we
inject
in
depth,
because
the
proper
way
to
develop
adapt
is
to
have
your
own
web
3
and
to
only
use
the
provider.
If
you
don't
have
your
own
web
3,
then
you
are
at
risk
that
the
browser
that
you
are
using
will
give
you
a
version
of
feel
that
you
are
not
compatible
with,
though
I
think
with
there
is.
A
I'm,
not
I'm,
not
fluent
enough
in
JavaScript
to
know
if
we
could
selectively
figure
out
which
version
of
web
3.
Why
is
using
and
inject
the
right
one,
but
but
it's
it's
not
supposed
to
be
our
our
role.
It's
it's
like.
If
you
will
website
and
it
it
it
gives
you
the
browser
that
you're
going
to
you
know
to
use
to
to
visit
it.
A
So,
to
make
it
clear,
there
is
two
things:
there
is
a
web
view
that
we
actually
use,
which
is
with
no
provider.
We
just
defined
us
in
de-icing
function.
So
it's
this
one.
Let's
do
when
we
use
so
that's
version,
twenty
point,
one
I
think
so,
and
we
only
define,
send
I,
think
and
then
we
we
do
RPC
calls,
or
in
one
case
we
call
our
PC
directly.
So
we
already
have
places
where
we
don't
use
web
three
at
all.
A
Then
we
have
all
these
contract
calls
that
are
actually
fairly
simple
to
use
the
same
way.
That's
for
studies
react,
and
then
you
have
web
three
in
the
web
view
where
we
have
the
most
important
part
is
the
web
three
provider
that
we
have
it's
not
like.
We
have
our
own
to
to
match,
with
some
specificities
of
the
interactions
between
the
webview
and
and
stylish
react.
A
So
here
one
could
say
it's
not
really,
depending
on
web
three
version,
because
the
one
we
have
as
the
interface
of
zero
twenty
and
the
the
prototype
I'm
not
familiar
with
JavaScript
lingua,
but
it
has
this
the
same
prototype.
So
it
functions
with
zero.
20
and
I'm
quite
sure
it
will
work
with
1.0
it
does
it
clarify
a
bit
or
it
does.
Thank
you
so
much.