►
Description
Our Co-Founder Alex Skidanov (https://twitter.com/AlexSkidanov) spoke on the topic - 'The frontier of sharding research' at Graph Day on January 25th, 2019.
In this video, Alex covered Sharding, Validators, and how the protocols are looking at scaling Blockchains. He also spoke about how Near Protocol is building a public sharded blockchain with the focus on usability.
Graph Day (https://thegraph.com/graphday) was an event hosted by Graph Protocol (https://thegraph.com/) to discuss the future of Web3 with the dedicated developers, investors, and community members.
More about NEAR: https://nearprotocol.com/
Follow the latest from NEAR Protocol on,
Discord: https://near.ai/discord
Medium: https://near.ai/medium
Twitter: https://near.ai/twitter
GitHub: https://near.ai/github
A
Hi
everyone
and
let's
talk
about
shorting
before
we
start.
Let
me
quickly
introduce
myself.
I
was
I'm
a
co-founder
of
near
protocol,
which
held
briefly
introduced
in
a
second
before
near
protocol.
I
was
working
for
a
company
called
MEMC
pole
and
mem
sequel
was
a
short
database.
I
was
employee
number
one
at
home,
sequel
and
I
built
most
of
the
early
sharding,
and
then
I
was
driving
charging
when
it
became
more
mature
and
the
for
mom
sequel.
I
was
at
Microsoft
that
was
a
decade
ago
and
we
started
near
protocol
around
August
last
year.
A
It's
one
of
the
younger
protocols
and
as
a
shorter
blockchain,
we
have
a
huge
emphasis
on
usability.
We
invest
heavily
into
developer
experience
into
user
experience
with
the
blockchain.
How
they
can
onboard
easier
and
near
protocol
is
one
of
the
few
teams
that
has
a
very
strong
team
with
specifically
with
the
industry
backgrounds.
We
have
three
people:
four,
we
have
four
people
from
home
Seco.
We
have
many
eggs
Googlers.
We
have
many
people
who
have
gold
medals
from
ACM
ICPs,
which
is
a
competitive
programming
and
one
of
the.
A
One
of
the
key
things
about
near
protocol
is
that
we
are
very
open
with
the
community
and
so
we're
not
when
we're
not
behind.
Like
a
walled
garden,
we
work
closely
with
other
protocols.
We
work
closely
with
the
theory
on
foundation
with
cosmos
and
others,
and
so
the
everything
that
happens
in
the
sharding
research.
We
share
a
lot
of
that
bit
between
us
and
so
in
this
presentation.
I
will
I
will
show
you
what
charting
is
how
charting
works
and
what
sort
of
problems
still
exist
in
charting.
A
So,
first
of
all,
what
charting
is
right.
So
let's
say
we
have
a
blockchain,
so
that
could
be
a
theorem
or
block
chain
or
Bitcoin
or
or
any
blockchain,
and
that
and
that
blockchain
has
some
number
of
transactions
per.
Second,
it
can
process.
So
let's
say
it's
12
and
let's
say
12
is
not
enough.
Let's
say
we
want
more.
Maybe
we
want,
let's
say
136,
so
one
thing
we
can
do
is
we
can
run
three
blockchains
if
each
of
them
can
process
twelve
transactions.
That
gives
us
36.
A
If
we
want
to
have
thousand
transactions
per
second,
we
can
run
hundred
blockchains
and
if
we
want
to
have
ten
thousand
transactions
per
second,
we
can.
We
can
run
1,000
chip
block
chains
and
that's
it.
We
thought
with
all
the
scalability
soft
there's
a
small
problem,
the
slight
problem,
which
is
when
we
have
one
blockchain
and
there's
some
population
of
people
who
who
are
willing
to
validate
that
blockchain
and
produced
blocks.
If
you
want
to
compromise
the
blockchain,
you
need
to
corrupt
or
control
51%
of
them.
A
Once
you
have
multiple
block
chains,
those
people
they
were
when
this
blockchain
had
12
transactions
per
second,
there
was
some
limitation.
There
was
some
reason
why
the
blockchain
couldn't
have
processed
more.
Maybe
maybe
the
network
was
at
capacity.
Maybe
processing
was
of
capacity,
maybe
storage,
but
there
was
some
reason
why
the
equipment
process
more.
So
when
we
have
you
know
ten,
ten,
ten
block
chains,
we
cannot
expect
all
validators
validate
all
the
block
chains
because
they
once
they
start
validating
one.
A
They
are
at
capacity,
and
that
means
that
validators
are
split
between
them
and
now,
if
you
want
to
corrupt
one
blockchain,
you
only
need
to
corrupt
sufficient
number
51
percent
of
the
people
who
validated,
which
is,
but
if
you
have
ten
block
chains
that
becomes
five
percent
of
people.
If
you
have
thousand
block
chains,
you
need
to
corrupt
point,
zero
five
percent
of
all
the
validators,
which
is
that
doesn't
sound
very
hard,
but
that
would
only
work
if
you
can
actually
control.
A
So,
if
you,
let's
say
let's
say
it's
a
half
power
that
is,
that
is
deciding
the
transaction
or
at
stake
for
you
to
be
able
to
corrupt
one
one
of
the
chains.
You
either
have
to
be
able
to
control
where
your
hash
power
goes
to
which
shirt
or
where
your
state
goes,
or
you
have
to
be
able
to
to
identify
people
in
a
particular
shirt
and
some
somehow
corrupt
them,
you'd
either
bribe
them
or
hack
them
in
some
way,
and
so
the
most
common
solution
to
this
problem
is
to
rotate
the
validators.
A
We
will
assign
validators
to
shards.
So
let's
say
every
short
has
100
validators.
They
will
produce
some
few
blocks
and
then
we'll
completely
you
shuffle
them,
and
so
now,
first
of
all,
I
don't
have
control
where
my
validation
power
goes,
but
also
I
cannot
really
corrupt
someone
unless
I
can
corrupt,
very
fast
right,
so
unless
I
can
corrupt
them
during
during
that
time
frame,
well
the
validating
the
shard.
By
the
time
we
corrupt
them.
A
They
already
got
you
shuffled
and
at
that
point
they
belong
to
different
shirts,
and
so
the
idea
here
is
that
if
we
believe
that
the
total
population
has
less
than
25%-
let's
say
malicious
actors,
then
once
we
sample-
let's
say
100
of
them,
we
can.
We
can
do
some
mathematical
modeling
and
show
that
the
number
of
malicious
actors,
the
probability
of
having
let's
say,
I,
take
a
3%
of
malicious
actors
in
the
chart
is
very
low
right.
So
you
know
like
let's
say
the
full
population
is
10,000
and
your
sample
100.
A
If
you
know
there's
25%
here
at
most,
then
the
probability
that
you
have
33
malicious
actors-
33
percent
militias
like
there's
here-
is
very
low.
It
can
be
considered
to
be
zero,
and
so
once
that
is
the
case,
let's
say
this.
Is
you
and
you
want
to
know
what
is
the
latest
look
in
the
blockchain?
You
go
to
the
current
validators
and
you
ask
them
what
is
the
current?
A
What
is
the
latest
block
and
if
you
hear
the
response
from
two-thirds
of
them
and
you
use
some
sort
of
DFT
consensus
and
that
response
is
the
same?
You
know
that
block
is
correct,
because
you
know
that
only
that
2/3
of
them
are
actually
honest
and
when
those
validates
were
producing
a
block,
they
asked
for
it
from
the
previous
validators
and
by
similar
reasoning.
A
That
is,
that
should
be
secure
computation.
That
computation
should
happen
on
chain,
but
we
don't
have
a
chain.
We
have
multiple
chains
which
which
chain
is
responsible
for
actually
rotating
the
validators
and
the
most
common
solution
to
that
problem
is
to
have
the
chain
have
one
blockchain
to
rule
them
all
and
in
the
theorem
it
is
called
the
beacon
chain
in
polka
dotted
cultural,
a
chain
we
will
be
referring
to
this
main
chain
throughout
the
presentation
and
so
their
chain,
everybody
validated
right.
A
But
it's
working
the
only
malicious
behavior
that
can
be
exercised
as
a
matter
of
fact,
not
if
you
corrupt
a
shark
in
some
way
you
can
fork,
but
you
can
also
do
another
attack
called
invalid
state
transition.
What
invalid
state
transition
is
is,
let's
say
we
have
a
transaction
in
which
Alice
sends
Bob
ten
tokens
and
we
have
the
state
in
which
Alice
has
don't
ten
tokens
and
Bob
has
zero
tokens.
A
If
you
get
that
state
and
apply
this
transaction,
the
state
you're
supposed
to
get
is
the
state
in
which
Alice
has
zero
tokens
and
walk.
Has
ten,
and
so
any
block
which
apply
state
in
this
way
is
valid.
What
can
happen?
Is
there
could
be
a
block
produced
in
which
you
know
in
initial
state
Alice
had
ten
plugins,
the
transaction
was
applied
and
now
Bocas
thousand.
That
is
an
invalid
state
transition,
and
you
probably
often
heard
about
forking
it
is.
He
recently
had
a
fork,
but
you're
unlikely
to
have
heard
about
invalid
state
transition
attacks.
A
That
is
because
in
non
Charlotte,
blockchains
invalid
state
transition
is
impossible.
The
reason
for
that
is
imagine
that
we
actually
have
majority
of
health
power
or
majority
of
stake
belonging
to
malicious
actors
and
at
some
point
they
produced
an
invalid
block.
So
this
block
a
prime
contains
some
transaction
which
was
applied
appropriately
in
any
modern
block
chain
like
a
theorem
or
a
Bitcoin.
All
the
validators
are
validating
all
the
blocks
and
all
the
users
are
validating
on
the
block.
A
If
we
have
three
different
sharks,
three
different
block
chains-
and
let's
just
say
for
now
that
the
only
kind
of
transactions
that
exist
is
payment
transactions.
The
let's
say,
I
have
an
account
in
the
first
shark
and
the
person
I'm
sending
money
to
has
account
on
the
second
shirt.
There
is
nobody
who
validates
both
chains,
and
so
the
transaction
cannot
be
in
the
first
block,
because
nobody,
because
because
then
the
validators
can
I
change
the
state
of
the
second
of
the
destination
account
and
the
transactions
can.
A
The
transaction
cannot
really
be
on
the
second
chain,
because
then
the
validator
cannot
change
the
state
of
the
of
the
sender,
and
so
what
needs
to
happen
is
this.
There's
got
to
be
some
way
of
change
to
communicate
and
the
way
it's
usually
done
is
through
this
concept
of
receipt.
Where,
with
the
transaction
that
touches
multiple
shirts,
it
originates
in
one
of
the
shirts,
for
example,
in
a
Chardon
which,
let's
say
Elias
is
sending
money
to
Bob.
A
The
transaction
will
originate
and
the
Alice's
chart
it
will
debit
her
account
and
then
the
validators
of
this
chart
will
send
some
sort
of
receipt
to
the
second
shirt
with
signatures
confirming
that
the
transaction
was
correct
and
then,
in
the
second
chart
the
validators
will
verify
the
signatures
and
apply
the
transaction
to
Bob.
Now
with
crusher
transactions
in
place.
A
In
Block
C
no
transition
is
applied
improperly
and
from
that
block
with
sending
those
tokens
which
were
minted
to
another
shirt.
The
second
chart
has
no
way
to
validate
the
entirety
of
the
first
shirt
right.
They
maybe
are
able
to
validate
Block
C,
but
they
cannot
validate
the
entire
history,
because
you
know
if
there's
thousand
shards
and
everybody
is
sending
cross
card
transactions,
sure
sure
cannot
validate
all
the
shirts
and
so
sure
sure
has
no
way
to
to
know
that
the
that
the
block
wasn't
correct.
A
So
one
way
to
solve
that
was
offered
is:
let's
have
let's
not
allow
cross-court
communication
between
English
arts.
Let's
say
that
only
sound
shirts
can
communicate
between
each
other
and
the
chard.
Every
shirt
validates
all
the
shirts
that
let
this
neighboring
all
its
neighbors
right.
This
way,
if
there's
a
cross
heart
communication-
and
let's
say
Block
B
was
invalid,
then
chart
two
because
third,
one
is
its
neighbour
validated
all
the
blocks
and
the
short
one
and
it
knows
block
D
is
invalid.
A
So
this
attack
is
no
longer
possible,
and
if
someone
wants
to
send
money
from
one
star
to
another,
which
is
not
a
neighbor,
they
will
just
send
through
multiple
shirts,
and
this
is
what
the
problem
occurs
again
right
because
well
like
corrupting
short,
one
is
not
sufficient
anymore,
but
now
corrupting
just
two
shirts,
which
is
still
significantly
less
than
full
system
is
sufficient.
Who
will
corrupt
corrupt
child?
One
produced
invalid
block
sent
across
drug
transaction
sure,
which
is
also
owned
by
us?
A
So
we
will
accept
the
cross
card
transaction
and
we
will
send
it
to
chart
3
chart.
3
can
only
valid
a
chart
which
are
is
completely
valid.
There
is
no.
There
is
no
invalid
state
transition
in
the
shark,
so
how
it
is
solved
today,
well
one
way
or
how
it
can
be
solved
in
the
future.
One
way
is
you
can
pretend
the
does
not
exist
you
can
you
can
try
to
build
your
security
in
such
a
way
that
you
believe
you
convinced
that
at
no
point
the
validator
set
in
any
shard
will
be
corrupted.
A
Alternatively,
you
can
you
can
try
to
have
some
cryptographic
proof
that
the
entire
blockchain
is
correct
when
you're
sending
a
crosshair
transaction.
There
is
such
cryptographic
primitives,
they
called
snarks,
but
today
they
not
quite
usable,
they
were
very
slow
right,
they're
usable
for
private
transactions,
so
zeeky
zeeky
zeeky
caches
using
them,
but
to
valid
to
prove
that
the
entire
blockchain
is
correct.
That
is
not.
That
is
not
quite
there
yet,
the
long
term
that
will
be
the
best
solution
possible.
A
So.
Actually,
the
scenario
will
be
the
charges
completely
overtaken,
there's
more
than
two-thirds
of
malicious
actors.
They
produce
an
invalid
blog.
They
never
show
this
blog
to
the
owners
validator.
They
produce
a
valid
block
on
top
of
it
otherwise
valid.
Besides
the
fact
to
disapproving
an
invalid
block
initiate
crash
or
transaction,
the
owners
validator
will
notice
that
this
is
happening.
A
Download
the
blocks
identify
that
this
block
is
invalid
and
create
some
proof,
some
some
small
proof
that
that
this
is
happening
and
send
this
proof
to
the
short
torso
now
at
this
point
sure
to
will
quickly
verify
the
proof.
The
proof
is
very
lightweight
and
know
that
the
cross
card
transaction
that
was
initiated
is
incorrect.
The
problem
is
that
monitoring
the
shard
identifying
this.
This
problem
happened
done
loading
the
block
validating
it.
A
It
takes
a
lot
of
time
and
so
the
challenge
period,
the
period
during
which
the
period
that
far
to
will
be
waiting
after
crucial
transaction
was
initiated
before
they
shorten
that
no
challenge
will
arrive,
should
be
pretty
long
right.
So
so,
let's
say
both
shards
of
producing
blocks
every
three
seconds
so
cross.
Our
transaction
can
really
without
fishermen,
be
finished
in
like
six
seconds
with
the
fisherman.
It
needs
to
be
on
the
order
of
minutes,
so
the
system
becomes
significantly
slower,
but
the
bigger
problem
is
that
this
blog
be
the
own.
A
It
Valley
that
actually
wouldn't
load.
The
blog
be
the
problem
is
that
the
dishonest
validator
might
have
never
even
published
it,
because
in
the
short
they
they
cannot
be
done,
loading
all
the
blog's
from
all
the
shirts.
If
these
thousand
shirts
and
there's
1
megabyte
blog
produced
every
few
seconds
in
every
shirt,
you
would
have
to
download
one
gigabyte
of
data
every
few
seconds
that
is
infeasible,
so
char.
Cannot
you
11
10
loading,
this
block
to
verify
the
transaction,
and
so
this
block
might
not
even
exist
anywhere.
Nobody,
nobody!
A
Nobody,
besides,
the
dishonest
validators,
might
have
seen
that
block,
and
so,
in
this
case
the
onus
validator
cannot
download.
It
cannot
validate.
It
cannot
craft
the
challenge
that
problem
is
called
data
availability
problem.
Very
few
protocols
actually
really
work
on
this
problem
right.
The
only
protocols
that
that
that
publicly
say
that
they
work
on
this
problem
that
they
believe
it
exists,
is
polka
dot
and
the
etherium
most
of
the
other
protocols.
A
They
there's
nothing
in
their
technology
which
actually
tries
to
to
go
to
work
with
data
availability
to
work
around
the
data,
availability
problem
and
yeah,
and
the
problem
is
that
it's
not
only
cross
hard
communication
that
is
broken
is
also
snapshotting
to
the
beacon
chain.
You
only
snapchatting
to
the
beacon
chain,
the
half
of
the
latest
block.
You
never
reveal
the
actual
block
right,
so
the
onus
validators
might
not
be
able
to
download
the
block
of
the
shard
was
corrupted
and
they
cannot
so.
The
short
can
completely
stalled,
and
so
there
are
some
proposals.
A
The
usual.
They
mostly
work
around
this
idea
of
using
erasure
codes
and
providing
some
extra
redundancy
in
the
data
that
is
available,
and
then
data
is
sample.
Split.
Most
of
those
are
the
very
early
stages,
and
so,
if
you
interested
in
this
particular
topic,
you
can
you
can
search
for
a
paper
by
the
italic
called
route
proofs,
and
let
me
finish
my
presentation
with
quick
overview
of
how
people
actually
build
sharding
today.
Right
so
cosmos
is
one
example
of
something
which
is
very
similar
to
Chardon
right.
A
Few
things
about
coordinates
is
that
first
validators
do
not
rotate
around
zones
validators
assigned
to
the
zone,
and
it
reduces
the
security
a
little
bit
and
they
the
way
cause
most
positions.
It
is
that
the
users
of
the
zone
have
for
themselves
their
responsibility
to
identify
how
many
validators
exist
there,
how
much
they
trust
them
and
how
much
they
trust
the
zone
and
then
cosmos.
A
The
cross,
shard
communication
cross
down
communication
is
carried
out
through
a
protocol
called
IBC
inter
blockchain
communication,
which
allows
you
to
move
assets
around
between
the
designs,
but
it
doesn't
really
allow
you
to
do
any
more
complex
code.
Execution
polka-dot
is
somewhat
similar
to
to
cosmos.
A
A
You
don't
need
to
trust
that
two-thirds
of
the
validator
disk
is
our
honest.
It
doesn't
have
to
trust
that
ninety-nine
per
se
it's
enough
to
try
that
is
atleast
one,
honest
validator,
/,
/,
shard
I
silica.
Is
you
probably
heard
of
silicon.
The
concept
of
sharding
silica
only
delivered
state
the
only
short
processing,
meaning
that
every
node
to
have
to
store
the
entire
state,
which
is
a
huge
limitation
and
also
they
for
cross
card
transactions.
A
They
completely
shut
down
the
entire,
the
completely
shot,
shutdown,
sharding
and
process
them
serially
and
the
theorem
serenity
near
they
very
similar,
unfortunately
running
out
of
time,
but
they
effectively
everything
I
I
described
today.
This
is
effectively
how
etherium
serenity
and
near
work
and
cool.
So
let
me
finish
here.
A
Quick
thing
is
that
we
have
whiteboard
series
where
we
talk
to
two
founders
of
different
protocols.
We
talk
to
cosmos
to
solana
where
we
talk
a
lot
about
technology,
so
check
it
out
near
yes,
this
YouTube
and
also
next
Tuesday
we're
revealing
our
deaf
net.
If
you
in
the
city,
google,
it
it's
or
the
link,
is
near
a
guys,
there's
definite
unfortunate,
don't
have
it
on
the
slide.
Thank
you.