►
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).
A
Today,
I
want
to
talk
a
little
bit
about
how
stars
go,
interact
with
go
etherium
and
what
does
it
mean
for
the
apps
and
for
status,
reacts
and
settle
client
in
general?
So
first
I
want
to
talk
about
like
a
little
bit
about
high
level
architecture,
so
in
general
we
can
see
that
both
that
is
react
and
the
apps
they
mostly
interact
with
growing
theorem
to
see
availables
using
their
web
tree
api
except
status,
tree
arts,
because
it's
sort
of
a
trusted
source.
A
It's
also
have
access
to
some
more
like
a
private
API,
but
so
like
the
vast
majority
of
the
functionality,
goes
to
the
same
channel
for
both
status
reaction,
yep
and
essentially
what
it
does
is
so
both
DF
and
others
react.
They
have
this
web
tree,
javascript
libraries
that
we
inject
our
custom
provider
in
which
isn't
using
HTTP
or
anything
like
this.
So
essentially
what
it
does.
It's
called
this
native
RPC
method.
So
this
one
is
a
native
flavourful
library,
and
so
this
provider
just
called
this
method.
A
So,
let's
start
so
a
little
bit
of
disclaimer
here.
So
there
are
multiple
implementation.
Even
there
are
few
ones
for
the
theory
on
quiet.
There's
like
people
of
past
employment
Asian,
there
is
no
interpretation,
so
what
I
will
say
will
be
deeply
technical
and
specific
to
go
a
serial
because
we
use
if
it's
implemented
differently
in
some
other
clients.
Well,
it
can
be
implemented
in
area
so
as
I
promised
there
is
this
call
to
some
RPC
method
that
actually
sends
transaction,
and
you
see
it's
sort
of
divided
into
two
parts.
A
A
So-
and
you
probably
haven't
heard
this
word
before,
so
what
is
the
service?
What
is
this
service
and
to
explain
what
services
I'll
tell
that
the
nose?
The
thing
that
we
launched
is
by
itself.
It
does
very
little,
it's
sort
of
discovers
other
nodes
can
connect
to
them
and
that's
some
very
basic
stuff,
but
it
doesn't
do
any
like
business
logic.
It
doesn't
create
word
chain
by
itself,
doesn't
interact
with
blockchain
with
other
certain
messages
and
stuff
like
that,
so
everything
they
denote
does.
So
you
can
think
about
it.
Like
a
clear,
concise
writing.
A
You
can
put
anything
with
so
to
actually
do
some
work
note
has
to
have
something
from
the
something
is
services
and
each
node
can
have
multiple
services
running
on
it,
and
one
service
might
be
like
ECU
and
blockchain
implementation
and
another
service
might
be
the
whisper
implementation,
and
it
might
be
something
like
swarm
or
something
else.
Reading.
B
A
It
can
be
anything
and
then
each
service
is
actually
registered
within
the
node,
and
there
is
some
registry
of
nodes
and
each
service
is
registered
and
it
reduces
its
own
namespace
like
each
one
of
this
and
to
do
that.
Each
service,
whether
it's
like
some
built-in
service
or
something
that's
provided,
will
go
easy
on
something
that
we
do.
It
has
to
provide
this
method
called
api's
that
actually
returns
a
list
of
things
that
has
names
the
names
in
it.
So
essentially
in
here
we
reduce
there's
one
service.
A
So
but
the
service
name
is
just
like
the
first
part
of
the
method
goal,
as
you
remember
so
well,
in
the
second
part
we
come
from,
and
it's
actually
each
services
actually
described
some
method,
and
you
see
that
their
names
are
translated
like
this
here
and
this
method
in
door
theorem
again,
they
are
discovered
dynamically
using
reflection.
So
essentially,
if
you
have
an
API
that
has
SSH
X
somewhere
and
it
has
this
API
object
that
is
registered
under
this
name
from
this
ad
I.
B
A
A
So
in
real
life,
things
are
a
bit
more
complicated
because
each
service
is
ten,
as
we
see
register
mode,
multiple
namespaces
that
might
or
might
not
be
the
name
of
the
service
and
within
this
different
namespaces.
It's
also
can
register
methods
with
the
methods
with
the
same
name,
but
to
make
things
even
more
complicated.
You
can
register,
let's
say
your
own
servicing
here
and
in
your
own
service.
A
So
the
note
does
very
basic
functionality
and
then
it
has
to
answer
some
CPM
service
that
implement
blockchain
and
it
might
also
we
might
also
run
a
whisper
service
and
stuff
like
this.
It's
very
composable
and
made
from
different
small
things
that
you
better
pull
together
so
now
how
we
use
it
in
status,
go
essentially
to
do
our
job.
So
third,
that's
an
overview.
It's
a
pretty
tricky
to
look
at
so
I
hope
that
after
the
next
few
slides,
you
want
to
thank
more
much
more
in
this
picture.
A
So
what's
important
right
now
that
we
have
two
moles
of
observations
here
and
that's
the
most
important
thing
that
you
should
learn
from
it,
and
so
these
two
modes-
they
actually,
if
you
go
into
the
status
up
in
the
in
the
UI,
the
only
difference
between
these
two
modes
is
actually
the
Subic.
So
you
might
have
okay,
we
have
main
net
with
our
pc
or
just
main
it
over
like
drops
down
with
our
pc
or
just
drops
down.
So
that's
how
the
most
look-
and
there
are
two
of
them.
A
So
one
is
our
PC
with
upstream
and
another.
One
is
why
this
new
mode
and
I
will
start
with
this,
because
it
can
be
to
purchase
plain
how
it
works.
So
what
areas
stands
for.
So
actually,
your
theory
on
provides
two
implementations
of
ignorance,
nodes
of
the
blockchain
service
and
one
is
called
the
funan
implementation
and
copies
and
another
one
is
the
lightest
ethereal
service
and
it's
called
less
and
that's
the
one
we
use
the
main
difference
between
these
two
is
the
this
one.
A
A
A
A
Latos
react:
it
calls
it
falsi
method
that
we
know
so
here
we
just
implement
some
override
with
a
sign
request,
few
signals
and
some
approve
decline,
API
and
then
this
will
structure
than
old
already.
So
how
does
this
work
in
detail
more
or
less
so
one,
for
instance
the
clients
and
some
some
method
for
instant
reduction?
A
It
goes
to
our
code,
and
here
we
just
so
quickly
we
don't
respond
back.
We
don't
do
anything.
We
freeze
the
code
in
here
then
we
add
a
sign
request
to
to
the
queue
and
then
when,
whenever
the
sign
request
is
added,
we
send
them
signal
to
the
UI.
So,
okay,
someone
tried
to
send
transaction
with
this
data.
There
is
like
dy
and
then
the
UI,
like
all
the
coins
of
status,
go,
can
show
from
dialog
that
Delta
K
from
this
address
to
this
address.
A
Somebody
tries
to
send
this
much
money
like
money
and
then,
if
there
is
everything
is
fine
user
supreme
see,
then,
is
called
the
special
like
a
poop
sign,
request,
API
and
then
it
returns
back
to
sign,
quizzes
got
approved,
and
then
we
actually
signed
transaction
and
call
the
blockchain
node
or
grab
symbol,
chinos
and
then
take
each
result
and
already
returned
here.
So
this
method,
it's
sort
of
wait
all
this
process.
It
doesn't
know
that
anything
happens
here,
and
this
is
like
a
side
channel
into
into
our
UI
application.
A
So
that's
how
we
override
RPC
and
that's
essentially
our
area-
note
that
one
that
is
without
RPC,
so
that's
how
it
works.
So
we
also
run
some
convenient
services
like
damage
whisper
that
we're
all
around
so
then
releasing
them
on
you,
so
they
are
also
available
right
inside
this
namespace.
So
but
that's
how
our
let's
move
watch
what
about
the
upstream
mode?
What
about
the
RPC
mode,
so
the
RPC
mode
is
a
bit
different
again,
let's
start
with
a
super
simple
approach.
A
We
already
have
this
client
of
a
rights
right,
so
we
already
have
it
from
the
array
as
well.
We
obviously
have
to
put
the
whole
point
on
having
like
RPC
is
not
to
run
anything
local.
So,
let's
not
run
like
anything.
So
let's
not
run
it
at
all
and
just
use
this
client
to
just
redirect
everything
to
ensure
our
end
or
other
upstream
or
casino
and
then
get
their
response
back,
which
is
like
a
very
simple
approach.
A
Like
I
said,
it
won't
work
because
not
every
RPC
admiration
it
should
be
forwarded
somewhere,
because,
first
of
all,
you
probably
don't
want
your
private
keys
to
be
sent
anywhere
and
in
fewer
doesn't
support.
Anything
like
it
supports
very
limited
set
of
API
and
it
doesn't
support
whisper,
for
instance,
so
for
both
security
and
some
reasons
like
limit
each
setting
to
limitations
and
some
convenience
reasons.
We
don't
want
to
send
everything
forward
because
again
for
convenience,
for
instance,
if
you
just
need
to
calculate
hash
like
there
is
this
method.
What.
A
A
It
just
basically
took
the
the
list
of
methods
that
it
supports
and
pick
something
that
we
wanted
and
put
it
right
into
the
remote,
allow
it
method
and
everything
else
should
be
still
local,
like
every
every
other
poll
should
be
your
logo,
but
and
obviously,
which
is
not
supported
by
in
fira
and
our
own
extension.
Oh,
it's
not
supported
by
pure,
so
this
would
have
to
run.
This
is
like
the
fine,
but
we
don't
want
to
run
why
the
theorem
and
all,
because
we
don't
want
that
exactly
what
we
want.
A
Everyone
don't
want
to
process
blockchain
ourselves,
because
that's
that
energy
drink
and
the
relative
to
have
iteration
and
it
work,
except
why
it
doesn't
because
some
of
the
DF
they
use.
Some
special
sign
like
this
is
very,
very
common
operation.
That
needs
to
be
done
because
Franklin
cryptic
it
is
used
to
signing
to
that
service.
So
and
unfortunately,
this
method
is
basing
into
light.
Is
your
own
service,
and
so,
if
we
don't
want
run
it,
then
we
don't
have
this
one,
which
is
pretty
bad.
A
So
when
we
still
don't
really
wanna
round,
why
the
see
I'm
service,
because
the
whole
point
of
RPC
otherwise
won't
be
satisfied.
So
what
we
did?
We
actually
made
a
patch
to
like
the
theorem
to
pick
like
it's
Travis
API
somewhere,
certainly
and
create
a
superlight
service
on
our
own
that
actually
uses
the
same
sign
API.
So
that
way
we
also
have
the
personal
mainstays
exposed,
even
though
Elias
is
not
trying
and
there
we
also
have
this
client
override
and
then
essentially
how
our
RPC
mode
is
working
right.
A
So
it's
a
little
bit
more
complicated
but
yeah.
It
has
its
own
ups
and
downs
so
and
yeah.
That's
basically
the
picture
that
I
showed
you
it'll,
be
you
know
the
presentation.
It
should
be
a
bit
more
clear
right
now,
so
we
have
two
modes:
one
is
running
the
blockchain
service
itself
and
other
is
not
and
have
to
deal
with
the
fact
that
it
doesn't
run.
Also
it
has
this
RPC
or
garage
for
UI
notifications
for
transaction
contains
R
and,
of
course,
they
all
run
with
an
extension
to
this.
A
But
we
use
a
lot,
and
the
conclusion
from
here
are
that
RPC
and
Elias
this
little
RPC
prefix
means
a
lot
of
consequences.
So
these
are
two
different
modes,
especially
everything.
That's
related
to
the
blockchain
itself.
It's
totally
different
in
both
Elias
and
upstream
mode,
like
a
CC
mode,
and
we
also
have
like
is
which
we
never
ever
implement,
because
it's
a
funnel.
A
So
this
is
not
equal
to
Elias
and
it's
not
equal
to
RPC,
and
that
means
that
some
methods
might
be
accessible
or
not
accessible
somewhere,
and
it's
very
important
that
we
need
to
test
both
modes
very
early
because
something
might
work
in
one
more
than
that
moving
in
another
mode.
Something
might
most
work
in
one
mode
because
of
one
reason
and
work
in
another
mode
because
of
another
reason.
So
that's.
A
A
B
A
How
it
determines
when
production
is
included
in
all
ITC
room
service?
Well,
I
mean
so.
If
I
understand
you
correctly,
we
just
I
mean
user,
just
peep
it
without
whether
he
wants
to
use
any
s,
because
we
have
the
settings
screen
and
there
you
can
choose
if
you
use
like
our
pcs
mode
or
the
normal
mode,
and
when
you
pick
our
PC
them.
A
A
A
C
A
The
problem
that
we
probably
need
to
seek
somehow
because
we
already
have
some
fixes,
for
we
only
have
some
pictures
for
our
PC
mo
because
some
API,
but
may
doing
it,
also
had
some
success
to
LA
a
small
to
have
something
like
working
because
well
right
now,
yeah
I
think
the
transaction
receipt
is
always
empty.
We
came
through
the
deploy
contract
with
an
earlier
right.
Yes,.
A
A
A
B
A
So
the
question
was
about
how
that
acknowledges
to
sign
messages
you
use
JSF.
No,
we
actually,
we
use
local
features,
because
cryptography
is
still
available
because,
as
I
thought
note
is
like
it
still
has
some
basic
services
running
noise
in
any
insane
mode.
So
we
as
I,
showed
before
a
little
bit,
try
to
find
it.
So
here
that's
where
we
find
transactions,
so
somebody
sends
a
transaction.
It
goes
dark
and
blah
blah
blah.
Well,
then,
virtually
sign
it
and
cold
Sandro
transactions.
B
B
A
Kampai
included,
if
you
have
more
questions,
obviously
just
being
me
on
flagons
I
can
tell
me
more
and
if
you
want
to
know
something
specific,
because
I
didn't
cover
a
lot
of
things
here
like
how
what
like
private
RPC
versus
public
rpgs,
how
the
security
works
there
or
other
stuff.
So
I
can
make
another
short
presentation
about
how
that
was
specifically.
But.