►
From YouTube: CasperLabs Community Update & Rust Node Demo
Description
Development Update & Rust node demo. High level overview of the Rust architecture and how it differs from the Scala architecture
A
A
We
will
be
going
through
daylight
savings
on
november
1st,
so
there'll
be
a
slight
shift
to
the
time,
but
you
can
always
catch
the
the
status
updates
via
youtube
and
everything
is
recorded
and
og
goes
ahead
and
puts
out
a
written
summary.
So
you
can
always
catch
his
written
summary.
If
you
really
want
to
take
a
you
know
the
short
short
view
in
terms
of
time.
You
know
time
investment
in
here
and
learning
on
this.
A
So
today's
today's
agenda,
I
will
be
going
over
the
update
and
then
I
believe,
there's
a
request
for
product
demo
from
the
community.
So
what
I'll
do
is
I'll
just
show
my
node
on
the
rust
network
and
I'll
show
you
guys
how
you
can
take
a
look
at
the
status
endpoints
and
the
metrics
endpoints
and
the
deploy
endpoints
we'll
be
cutting
a
new
release
which
I'll
go
into
later.
You
know
later
today.
So,
let's
get
started
with
the
update,
so
we
are
in
the
second
sprint
of
the
20.11
release
cycle.
That's
sprint.
A
7.2.
Today
we
will
be
cutting
the
20.10
release
and
it's
going
to
be
deployed
to
the
charlie
testnet.
As
soon
as
the
code
is
ready
to
go,
the
beta
test
net
did
experience
a
critical
failure
and
we're
going
to
be
restarting
it
today.
Genesis
will
start
in
about
three
hours
from
now.
It's
approximately
1600
utc
and
we
have
not
been
making
any
code
updates
to
the
scala
test
net.
A
Sometime
later
this
week,
I've
got
the
preliminary
awards
set
up
and
I
will
be
sending
those
to
renault
for
approval
and
we're
going
to
go
to
the
kyc
aml
process
and
then
award
make
those
make
those
awards
to
the
validators
so
very
excited
about
that,
and
let's
move
down
here
so
we're
starting
charlie.
The
charlie
network
is
still
up
and
running
where
deploy
count
is
15,
038
height
43.72.
A
That
means
there's
4
372
blocks
in
the
linear
blockchain,
and
we
are
an
era
396..
As
of
this
writing,
it's
probably
gone
up
since
then
our
current
focus.
So
let's
talk
a
little
bit
about
the
release
that
we
are
cutting
today.
The
release
that
we're
cutting
today
is
the
release.
That's
going
to
provide
validator
set
rotation,
so
finally,
we
will
have
bonding
and
unbonding.
A
So
that's
the
release.
We're
cutting
today
we're
going
to
drop
that
into
the
charlie
test
net
and
bang
on
it
for
a
few
weeks,
and
then
we're
going
to
launch
delta
test
net
with
that
code
on
october
31st
and
we'll
probably
bounce
delta.
Shortly
thereafter,
as
soon
as
the
november
release
is
ready,
we're
going
to
upgrade
delta
testnet
with
that
november
release.
So,
let's
talk
about
what's
in
the
november
release,
we
will
be
building
an
adaptive
round
length
strategy.
So
what
is
this?
A
An
adaptive
round
lead
strategy
means
each
validator
can
decide
how
frequently
they
want
to
send
consensus
messages
and
they
can
adjust
the
frequency
by
which
they
send
consensus
messages
based
on
how
the
network
is
performing.
Ideally,
it's
based
on
how
the
network
is
performing
right,
so,
for
example,
if
if
the
network
is
finalizing
blocks
pretty
rapidly,
you
would
want
to
keep
up
with
how
quickly
the
network
is
finalizing
blocks.
A
So,
for
example,
if
in
the
last
round
the
network
finalized
the
blocks
in
15
seconds,
you
would
want
to
make
sure
that
you
set
your
round
length
to.
You
know
be
around
exponent
of
about
14
and
that
will
set
you
at
about
a
16
second
round
length,
and
that
means
every
16
seconds.
Your
node
will
send
a
ballot.
A
So
that's
what
the
basic
adaptive
round
lead
strategy
we're
setting
up
is
going
to
be
is
based
on
the
last
final,
when
I
received
the
last
finalized
block
or
the
last
n
finalized
blocks,
get
an
average
of
that
and
set
my
round
length
to
match
that.
So
then,
I'm
keeping
up
with
what
the
network
is
doing.
A
A
Right
basic
yeah,
so
there's
basic
slashing,
but
we're
going
to
be
we're
adding
additional,
slashing
there's
a
lot
of
different
edge
cases
and
we're
going
to
enhance
highway
security
with
endorsements
and
fork
bomb
protection.
This
is
a
very
specific
type
of
attack
called
a
span.
It's
basically
spam
protection,
and
this
is
advanced
security
for
highway
for
in
the
node
we're
building
up
more
metrics.
So
we
can
do
a
better
job
of
monitoring
how
the
node
is
performing.
A
We're
also
evaluating
off
the
production.
You
know
off-the-shelf
options
for
networking.
We
know
that
we
needed
some.
We
needed
some
basic
networking
so
what's
in
there
is
currently
a
stub.
It's
been
doing
a
great
job,
but
it's
not
production
grade.
So
we're
going
to
be
looking
at
a
variety
of
production-grade
rust-based.
A
A
Additionally
features
around
deploy
dependencies
right
so,
if
deploy
a
has
to
be
executed
before
deploy
b,
the
deploy
buffer
needs
to
be
able
to
support
all
of
those
strategies
and
then
a
basic
count
of
unprocessed
deploys
this
basic
count.
We
found
that
in
the
scala
network,
the
count
of
unprocessed
deploys
was
really
a
great
leading
edge,
leading
indicator
of
network
health.
A
We're
also
focused
on
automating
the
release
process.
We
know
we're
going
to
have
to
get
into
a
rapid
fix,
find
rapid,
deploy,
upgrade
model
here,
and
so
we
want
to
make
sure
our
releases
are
automated
ecosystem,
there's
a
very
heavy
lift
on
the
ecosystem
front
to
support
the
new
rust
network.
So
in
preparation
for
delta
test
net,
we
need
to
have
clarity,
so
clarity
needs
to
be
upgraded
to
work
with
the
rust
network.
A
The
rust
network
architecture
is
different
enough
from
scala
that
there's
a
significant
lift
that
needs
to
happen
so
a
couple
of
things
that
are
obvious:
there's
no
graphql
interface
and
the
rust
network,
because
we
don't
want
non-deterministic
load
hitting
the
validators,
and
so
what
we're
doing
is
supporting
an
event
stream.
So
we
have
to
move
to
the
event
stream
in
clarity
to
get
as
a
data
source.
A
We
also
want
to
split
the
rust
client
into
a
library
and
a
binary
eventually
we'll
be
able
to
do
builds
of
the
rust
client
on
different
operating
systems,
so
we'll
be
able
to
have
a
windows.
You
know
rust
client
as
well
as
mac
and
a
variety
of
different
flavors.
Here.
We're
very
excited
about
that.
There's,
a
lot
of
documentation
updates.
A
I've
actually
started
a
couple
of
pull
requests
already
on
doc
updates
and,
of
course,
we've
got
to
build
that
event
store,
so
lots
of
work
on
the
ecosystem
front,
getting
ready
to
support
the
rust
node
economics,
research,
we're
winding
down
on
the
economics
front.
So
now
we're
really
looking
at
getting
a
formalized
economics
paper
and
just
working
at
some
of
the
semantic
languaging
language
in
the
tech
spec
on
the
contract.
Runtime
lots
of
work
in
the
contract
runtime
the
contract
runtime
was
pretty
quiet
for
a
while.
A
We
did
a
big
lift
in
the
run
time
for
contract
headers
in
june.
For
those
of
you
that
remember
now
we're
looking
at
doing
transaction
fees
right
so
now
we
want
validators
to
receive
payments
for
transaction
fees,
we're
also
going
to
charge
very
rudimentary
one-time
charge
for
storage.
This
is
primarily
a
dos
vector
against
somebody.
Uploading,
megs
and
megs
of
data
to
the
global
state,
so
it'll
be
very
expensive
to
to
store
data
in
the
global
state,
as
it
is
in
all
the
blockchains
right.
A
You
really
want
to
use
ipfs
or
storage
io
for
storing
data
in
a
decentralized
manner.
You
don't
want
to
store
it
to
our
blockchain,
we're
going
to
be
making
updates
to
support
transaction
proofs
right.
So
this
basically
gives
the
same
kind
of
data
you
see
in
ethereum
when
you
send
a
transaction,
how
much
of
it
was
spent
on
the
transaction
itself.
What
was
transferred?
What
was
the
address
it
was
transferred
to?
This
is
really
important
for
basic
accounting.
A
Right
accounting
of
the
chain-
and
this
is
updated-
was
a
mob
code,
like
I
said,
we're
going
to
include
the
cost
for
storing
and
bandwidth
into
the
execution
and
just
so
it'll
cost
right.
So
if
you
deploy
some
really
big
wasm,
that's
going
to
cost
you
right,
so
we
want
to
disincentivize
developers
to
be
just
sending
wasm
with
every
deploy.
Rather,
you
want
to
store
your
contract
in
a
package
and
then
invoke
your
contract.
A
Like
I
indicated
before,
we're
not
doing
any
additional
work
on
the
scala
node
with
the
delta
test
net,
we
will
be
de-provisioning
the
current
test
net
and
all
the
validators
will
be
moving
away
from
scala
to
rust.
The
new
network
will
be
a
rust
only
network.
The
scala
node
is
not
compatible
with
the
rust
node.
If
the
community
wants
to
pick
up
the
scala
architecture
and
continue
improving
it
by
in
all
means,
they're.
Most
welcome
to
do
so.
A
We're
looking
for
talented
sres
to
join
our
team.
So
if
you
are
a
traditional
sre
and
you're
looking
for
new
work,
please
do
apply
at
careers.
Casper
labs
go
to
the
website.
You
can
apply
there,
we're
also
looking
for
someone
to
run
weekly
workshops
and
developer
engagement
and
do
tech
writing.
So
if
you're
interested
you've
done
this
with
blockchain
before
you
have
some
experience
with
smart
contracts
and
you
love
instructing
developers
on
how
to
build
smart
contracts
go
ahead
and
apply,
we
would
love
to
hear
from
you.
A
B
Well,
no
because
we
are
currently
working
on
sort
of
small
finicky
things
right,
so
current
focus
is
basically
on.
You
know,
introducing
the
final
enhancements
to
auctions
so
that
you
know
they're
ready
for
mainnet,
and
after
that
you
know,
as
you
said,
if
you're
going
to
be
mostly
working
on
documentation
and
finally,
after
all
of
that
is
done,
we
will
switch
back.
You
know
to
deal
in
this.
B
A
A
A
What
oh,
I
know
what
I
did
wrong:
it's
not
https,
it
emits
some
information
about
the
network
and
it
just
basic
information
at
this
point
right.
So
last
linear
block.
So,
as
we
indicated,
I
think
we
reported
error
396
in
our
status,
and
here
you
can
see
we're
at
error,
398
and
the
height.
The
linear
block
chain
is
43.92.
A
B
A
Are
presently
set
to
30
minutes
in
the
delta
test
net?
I'm
sorry,
the
charlie
testament-
and
this
is
the
hash
of
the
last
of
this-
of
this
linear
block
the
last
linear
block,
and
you
can
run
this
at
some
increment
and
see
if
the
last
linear
block
has
moved
so
it's
still,
it
hasn't
moved
yet
right.
So
this
system
is
presently
attempting
to
to
finalize
a
block.
We
can
also
look
at
if
we
want
to
look
at
status.
A
A
A
A
A
A
The
nodes
vote
on
the
block,
without
even
knowing,
what's
in
the
deploys
and
come
to
consensus
on
the
block
first,
once
the
block
is
finalized,
so
this
is
called
a
protoblock
once
the
block
is
finalized,
then
the
nodes
execute
the
protoblock
and
commit
the
effects
to
the
global
state,
and
so
this
is
a
significantly
more
efficient
way
for
a
couple
of
reasons.
One
in
the
scala
system
you
were
incrementally
like
within
the
global
state.
You
were
incrementally
updating
the
global
state
for
each
deploy,
so
I
would
run
a
deploy.
A
We
package
them
up
into
the
block
and
then
we
basically
run
all
the
deploys,
take
all
the
effects
of
the
deploy
and
then
commit
them
at
once,
and
so
what
you
see
here
is
this
contract
runtime
commit
count
is
at
631.,
so
for
those
15
000
transactions
that
were
run,
we
actually
did
631
commits,
I'm
pretty
sure.
That's
right.
A
I'd
have
to
ask
henry
to
be
absolutely
crisp
on
it,
but
I'm
pretty
sure
that
that's
correct-
and
so
here
you
can
see
that
these
are
low
level
contract
runtime
commit
metrics
that
you're
taking
a
look
at
if
we
scroll
down
a
little
bit
more
here.
We
see
this
runner
events,
so
the
runner
events
number
is
really
high,
and
this
is
the
runner.
These
are
the
events
that
are
happening
inside
the.
What
we
call
the
reactor
model.
The
reactor
model
is
completely
new
to
rust.
A
It
doesn't
exist
at
all
in
scala
right,
so
a
couple
things
that
we
did
when
we
re-architected
the
node
in
rust.
We
did
a
very
hard
separation
of
concerns,
so
we
have
this
notion
of
a
reactor
model
which,
basically
all
it
does,
is
it
process.
Events
and
it
compartmentalizes
concerns,
for
example,
you
have
deploy
events,
you
have
gossiper
events,
you
have
consensus,
events
and
they're
all
completely
separate
right,
so
it's
very
compartmentalized,
so
a
deploy
event
may
have
its
own.
What
we
call
event
queue
right
so
remember.
A
I
said
for
those
who
have
been
following
these
calls
for
a
long
time.
I
said
the
desire
is
for
the
casper
labs
node
to
be
an
event,
bus
right,
basically,
an
enterprise,
business
bus
and
what
this
means
is
from
from
a
business
architecture.
You
have
this
queuing
logic
right.
You
have
this
notion
of
events
that
are
queued
up
and
that's
basically
any
any
kind
of
server
architecture
you
see
today
they
just
process
a
lot
of
events
right
and
you
have
different
types
of
events.
You
may
have
like
a
create
a
new
account
event.
A
You
may
have
a
process,
you
know
a
send,
a
transfer
money
event.
You
may
have
right.
So
all
of
these
types
of
business
processes
they
all
process
what
we
call
events,
there's
different
types
of
events,
and
then
you
have
business
logic
associated
with
each
event,
and
so
the
reactor
model
is
a
model
where
it
reacts
to
events
right.
That's
what
it
does.
You
get
an
event
and
you
react
to
it.
You
do
something,
and
so
this
runner
events
basically
is
this
notion
of
the
react.
A
This
is
basically
a
very
basic
event
coming
up
basic
counter
of
events
being
processed
in
the
reactor
model,
and
so,
for
example,
like
we
have
this
notice
notion
of
a
joiner
reactor
right.
So
when
a
a
node
is
in
joining
mode,
it
spins
up
a
joiner
reactor
and
the
joiner
reactor
base
like
it
reacts
to
all
the
events
that
the
system
processes,
while
the
node
is
catching
up
and
once
the
node
is
caught
up,
it
will
spin
up
a
a
consensus
reactor
right
or
a
validator
reactor
as
we
refer
to
it.
A
So
once
a
node
is
successfully
bonded
in,
it
starts
behaving
like
a
validator,
it'll
spin
up
this
validator
reactor
and
then
now
it
starts
responding
to
consensus
events,
but
it
doesn't
need
a
validator
reactor
if
it's,
if
it's
not
going
to
bond
in
so
until
it's
bonding
in
it's
just
keeping,
it's
keep
playing
catch-up
mode
right.
A
validator
reactor
responds
to
consensus
events
as
a
validator,
and
so
we're
able
to
really
separate
concerns
by
using
this
reactor
model.
This
is
a
brand
new
architecture
we
implemented.
A
This
is
another
reason
why
the
rust
node
is
not
going
to
be
compatible
with
the
scala
node,
because
the
way
they
process
consensus
messages
is
very,
very
different.
It's
completely
different,
so
that's
a
little
bit
about
the
product
and
how
it's
working
now,
with
our
new
version
that
we're
cutting
we're
actually
in
the
process
of
cutting
the
release.
Today,
there
will
be
significantly
a
lot
more
metrics
in
here.
A
A
This
architecture
enables
us
to
drop
in
another
four
choice:
type
model,
the
era
supervisor.
You
know
it
will
need
to
be
epoch
and
era
based
for
the
true
plugability,
but
it
will
enable
us
if
we
discover
that
there's
new
research
around
a
different
type
of
protocol
that
gives
us
better
performance,
we're
not
necessarily
you
know
strictly
tied
to
highway.
A
We
want
to
be
you
know
we
want
to
be
able
to
evolve
the
consensus
protocol
fairly
easily,
so
this
architecture
does
enable
us
to
drop
in
something
different
besides
highway
into
the
highway
core
component.
As
long
as
it's
using
like
you
know,
eras
and-
and
you
know,
eras
and
and
those
kinds
of
things,
the
bonding
auction
is
fairly
agnostic
right
to
to
the
type
of
actual
in
protocol
consensus
that
being
used.
So
that's
like
the
round
length
you
know
and
and
the
ballots
that
piece.
A
A
C
More
more
of
a
kudos,
because
I
remember
we
were
having
a
conversation
about
some
of
this
architecture,
probably
in
february
last
year,
and
it's
really
exciting
to
see
it
all
come
to
life
on
a
live
test
net.
And
I
remember
we
were
talking
a
lot
about
separation
of
concerns
and
and
to
see
you
run
through
how
it's
all
compartmentalized
is
just
really
exciting.
So
I'm
proud
of
the
team
and
and
proud
of
you.
So
so
thanks
for
sharing.
A
Oh
my
pleasure,
I'm
I'm
very
proud
of
the
team
too.
They
have
been
working
exceptionally
hard.
The
velocity
of
like
for
folks
who
aren't
aware
we
kicked
off
rewriting
this
architecture
in
april
right.
So
that's
when
we
made
the
decision
to
move
fully
to
rust.
The
team,
really
you
know,
bore
down
on
the
work
starting
in
the
first
week
of
may,
and
you
know
it
took
them.
A
You
know,
may
you
know
all
may
june
july
august
september
a
scan
five
months
to
rewrite
the
entire
thing
and
come
out
with
the
test
net,
and
that
includes
a
very
heavy
lift
in
june
with
con.
You
know,
with
the
contract,
runtime
and
building
out
contract
headers
and
the
dsl
work,
which
was
a
big
big
piece
and
dropping
that
into
the
beta
test
net,
and
so
then
they
really
went
full
bore
after
june.
A
So
if
you
think
about
it,
the
first
two
months,
a
lot
of
the
a
lot
of
the
rust
team
was
really
focused
on
contract
run
time,
and
then
they
really
kind
of
spun
off
and
started
started
this
work
fully.
So
we
still
have
a
couple
of
months
of
work
ahead
of
us.
The
november
release
is
going
to
be
a
big
release.
There's
a
lot
to
be
done
around
security,
we're
doing
our
security
audit
with
trail
of
bits
in
mid-november.
A
So
we
have
to
be
ready
for
that,
as
well
as
all
of
the
requirements
around
exchange
integration
right.
So
there's
a
lot
of
work
around
payments
and
contracts
that
still
needs
to
be
done.
So
the
team
is
like
really
like
it's
just.
We
have
to
bear
down
for
a
few
more
months
to
really
get
this
all
done,
but
we're
very
excited.
A
Yeah
mainnet
live
is
looking
in
january.
We
we
have,
we
have
partnered,
we
have
come
to
terms
we're
working
on
coming
to
terms
with
a
custody
provider.
That's
v,
I'm
very,
very
excited
about
the
custody
provider
that
we
are
working
with,
that
custody
provider
has
given
us
tentative
dates
in
mid-january
to
be
ready.
So
we
cannot
do
any
kind
of
you
know
mainnet
launch
until
we
have
a
solid
custody
provider
in
place
for
our
invent.
You
know
for
folks
that
are
going
to
be.
A
Yeah
very
much
so
all
right.
I
think
this
is
it.
Thank
you
very
much
for
attending
and
listening
and
I
hope
to
hear
from
everyone
next
week
and
feel
free
to
hit
us
up
on
telegram.
Hopefully
I
can
share
some
more
interesting
product
features
and
you
know,
follow
us
and
join
the
join
the
meeting.
The
meeting
is
open,
so
the
information
is
available
on
github
and
on
our
telegram
thanks.
So
much
cheers
bye.