bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 4쪽 중 2쪽
ner
has
flagged
their
SKALE
Chain
for
deletion.
If
chain
payments
are
not
paid
as
per
SKALE
Chain
Pricing,
the
chain
owner
will
be
notified
of
their
chain’s
pending
deletion
and
given
the
opportunity
to
pay
the
debt
owed
to
the
network
and
pre-pay
for
additional
time.
The
destruction
process
will
transfer
any
crypto
assets
originating
from
Ethereum
to
their
owners
on
the
mainnet,
remove
all
nodes
from
the
SKALE
Chain,
hard
reset
their
storage
and
memory,
and
remove
the
SKALE
Chain
from
the
SKALE
Manager
before
rewarding
the
submitter
who
commissioned
the
destruction
of
the
chain.
SKALE
Network
Whitepaper
7
Note:
The
reward
earned
by
the
submitter
for
destroying
a
chain
is
slightly
greater
than
the
cost
of
the
transaction
and
serves
as
an
incentivized
garbage-collection
mechanism
for
network
resources.
Validator
Rewards
and
Bounty
Issuance
Proposed:
The
creation
of
SKALE
Chains
is
independent
from
the
network's
core
delegations.
This
enables
greater
profitability
for
validators
while
also
ensuring
that
delegations
are
not
being
reduced
for
validator
incentivization.
The
network
has
a
rent
system
that
every
chain
must
follow
in
order
to
keep
their
chain
active.
The
benefit
of
such
a
system
is
that
validators
are
paid
the
chain
fees
monthly
and
can
claim
it
as
part
of
their
incentivization
package.
An
inflation
(issuance)
event
also
takes
place
each
month
whereby
new
SKALE
tokens
are
created
via
a
contract
on
the
Ethereum
mainnet,
the
result
of
which
gets
pushed
into
the
bounty
pool
for
payout
to
validators.
By
way
of
example,
if
there
are
a
thousand
validator
nodes
in
the
network
and
they
all
perform
well,
they
will
each
participate
in
the
monthly
proceeds
from
the
bounty
pool
–
this
bounty
pool
consists
of
a
portion
of
the
chain
token
stakes
plus
the
inflation
amount.
SKALE
Chain
Operations
SKALE
Consensus
The
SKALE
Network
uses
a
variant
of
the
Asynchronous
Binary
Byzantine
Agreement
(ABBA)
protocol
as
its
consensus
model.
The
fundamental
benefit
of
the
ABBA
protocol
is
that
it
is
designed
to
exhibit
robustness
in
the
case
of
node
downtime
where
each
latent
and/or
down
node
is
regarded
as
a
slow
link.
The
ABBA-based
consensus
layer
replaces
the
default
consensus
model
in
the
EVM
(Ethereum
Virtual
Machine)
that
is
included
as
a
container
within
each
node.
It
is
this
EVM
that
gets
instantiated
within
each
node
that
manages
and
maintains
each
SKALE
chain.
SKALE
Chains
are
validated
via
a
set
of
nodes
which
engage
in
block
creation
and
commitment
through
the
use
of
this
asynchronous,
leaderless,
and
provably
secure
variant
of
the
ABBA
protocol.
The
SKALE
Network
consensus
algorithm
relies
heavily
on
academic
research
so
as
to
make
the
case
for
a
mathematically
provable
approach
to
consensus-based
chain
validation
and
creation.
Even
at
this
evolved
state
of
the
industry,
there
is
a
split
in
the
blockchain
world
between
production-first
systems
and
academic
research.
In
the
former
category
are
Proof
of
Work
networks
like
Bitcoin
and
Ethereum
1.0
and
Proof
of
Stake
systems
like
Cosmos
and
Tendermint.
In
the
academic
world,
one
finds
ABBA-based
approaches
and
a
number
of
other
mathematically
provable
algorithms.
The
design
of
the
SKALE
Network
bridges
this
gap
between
real
world
trail
and
mathematical
research.
SKALE
is
the
first
network
to
make
use
of
binary
consensus
in
a
large-scale
commercially
available
production
system.
This
is
not
to
imply
or
infer
that
other
production
algorithms
are
flawed,
but
rather
to
make
the
point
that
the
design
of
SKALE
Consensus
is
guided
by
the
rigor
to
make
use
of
algorithms
that
are
mathematically
provable.
So
long
as
>
⅔
of
the
total
node
validator
set
are
online,
they
will
continue
creating
and
committing
new
blocks
to
the
chain.
This
protocol
is
a
multi-phase
process
illustrated
by
the
diagram
below
and
detailed
in
the
following
sections.
Threshold
Signatures
Our
protocol
uses
threshold
signatures
for
supermajority
voting.
Upon
creation
of
a
SKALE
Chain,
Boneh
Lynn
Shacham
(BLS)
private
key
shares
PKS[I]
are
created
using
joint-Feldman
Distributed
Key
Generation
(DKG)
SKALE
Network
Whitepaper
8
and
issued
to
each
node.
For
each
PKS[I],
there
exists
a
verifiable
public
key
PK[I]
which
is
stored
and
made
publicly
available
on
the
SKALE
Manager
for
signature
verification
purposes.
BLS
threshold
signatures
are
implemented
as
described
in
Boldyreva
with
elliptic
curve
(altBN256)
and
group
pairing
(optimal-Ate)
implemented
in
Ethereum
Constantinople
release.
Threshold
Encrypted
Messaging
Network
Security
Assumptions
The
protocol
assumes
that
the
network
is
asynchronous
with
eventual
delivery
guarantee,
meaning
that
all
nodes
are
assumed
to
be
connected
by
a
reliable
communications
link
–
links
can
be
arbitrarily
slow,
but
will
eventually
deliver
messages.
This
asynchronous
model
is
similar
to
Bitcoin
and
Ethereum
blockchains
and
reflects
the
state
of
the
modern
Internet,
where
temporary
network
splits
are
normal
but
eventually
resolve.
The
eventual
delivery
guarantee
is
achieved
in
practice
by
the
sending
node
making
multiple
attempts
with
exponential
backoff
to
transfer
the
message
to
the
receiving
node,
until
the
transfer
is
successful.
Pending
Transactions
Queue
Each
node
maintains
pending
transactions
5
queue.
The
first
node
to
receive
a
transaction
into
that
queue
will
attempt
to
propagate
it
to
its
peers
via
dedicated
outgoing
message
queues
for
each.
To
schedule
a
message
for
delivery
to
a
particular
peer,
it
is
placed
into
the
corresponding
outgoing
queue.
Each
of
these
outgoing
queues
is
serviced
by
a
separate
thread,
allowing
messages
to
be
delivered
in
parallel
so
that
failure
of
a
particular
peer
to
accept
messages
will
not
affect
receipt
of
messages
by
other
peers.
Block
Proposal
After
the
previous
consensus
round
has
been
completed,
each
node’s
TIP_ID
will
increment
by
1
and
immediately
cause
them
to
create
a
block
proposal.
To
create
a
block
proposal,
a
node
will:
1.
Examine
its
pending
transaction
queue.
2.
If
the
total
size
of
transactions
in
the
pending
queue
is
less
than
or
equal
to
the
MAX_BLOCK_SIZE,
the
node
will
fill
in
a
block
proposal
by
taking
all
transactions
from
the
queue.
3.
In
the
case
that
the
total
size
of
transactions
in
the
pending
queue
exceeds
MAX_BLOCK_SIZE,
the
node
will
fill
in
a
block
proposal
of
MAX_BLOCK_SIZE
by
taking
pending
transactions
from
the
queue
in
order
of
oldest
to
newest
received.
4.
The
node
will
assemble
block
proposals
with
transactions
which
are
ordered
by
SHA-256
Merkle
root
from
smallest
value
to
largest
value.
5.
In
the
case
that
the
pending
queue
is
empty,
the
node
will
wait
for
BEACON_TIME,
and
then,
if
the
queue
is
still
empty,
make
an
empty
block
proposal
containing
no
transactions.
Note:
nodes
do
not
remove
transactions
from
the
pending
queue
at
the
time
of
proposal.
The
reason
for
this
is
that
at
the
proposal
time
there
is
no
guarantee
that
the
proposal
will
be
accepted.
5
Each
user
transaction
is
assumed
to
be
an
Ethereum-compatible
transaction,
represented
as
a
sequence
of
bytes.
SKALE
Network
Whitepaper
9
Data
Availability
Once
a
node
creates
a
block
proposal
it
will
communicate
it
to
other
nodes
using
the
data
availability
protocol
described
below.
The
data
availability
protocol
guarantees
that
the
message
is
transferred
to
the
supermajority
of
nodes.
The
five-step
protocol
is
described
below:
1.
The
sending
node
A
sends
both
the
block
proposal
and
the
hashes
of
the
transactions
which
compose
the
proposal
P
to
all
of
its
peers.
2.
Upon
receipt,
each
peer
will
reconstruct
P
from
hashes
by
matching
hashes
to
transactions
in
its
pending
queue.
For
transactions
not
found
in
the
pending
queue,
the
peer
will
send
a
request
to
the
sending
node
A.
The
sending
node
A
will
then
send
the
bodies
of
these
transactions
to
the
receiving
node,
allowing
for
the
peer
to
reconstruct
the
block
proposal
and
add
the
proposal
to
its
proposal
storage
database
PD.
3.
The
peer
then
sends
a
receipt
back
to
A
that
contains
a
threshold
signature
share
for
P.
4.
Node
A
will
wait
until
it
collects
signature
shares
from
a
supermajority
(>
⅔
)
of
nodes
(including
itself).
A
will
then
create
a
supermajority
signature
S.
This
signature
serves
as
a
receipt
that
a
supermajority
of
nodes
are
in
possession
of
P.
5.
A
will
then
broadcast
this
supermajority
signature
S
to
each
of
the
other
nodes
in
the
network.
Note:
Each
node
is
in
possession
of
BLS
private
key
share
PKS[I].
Initial
generation
of
key
shares
is
performed
using
Joint-Feldman
Distributed
Key
Generation
(DKG)
algorithm
which
occurs
at
the
creation
of
the
SKALE
Chain
and
whenever
nodes
are
shuffled.
In
further
consensus
steps,
a
data
availability
receipt
is
required
by
all
nodes
voting
for
proposal
P
whereby
they
must
include
supermajority
signature
S
in
their
vote;
honest
nodes
will
ignore
all
votes
that
do
not
include
the
supermajority
signature
S.
This
protocol
guarantees
data
availability,
meaning
that
any
proposal
P
which
wins
consensus
will
be
available
to
any
honest
nodes.
Pluggable
Binary
Byzantine
Agreement
The
consensus
described
below
uses
an
Asynchronous
Binary
Byzantine
Agreement
(ABBA)
protocol.
SKALE
currently
uses
a
variant
of
ABBA
derived
from
Mostefaoui
et
al.
Any
other
ABBA
protocol
P
can
be
used,
as
long
as
it
satisfies
the
following
properties:
●
Network
model:
P
assumes
asynchronous
network
messaging
model
described
above.
●
Byzantine
nodes:
P
assumes
less
than
one
third
of
Byzantine
nodes.
●
Initial
vote:
P
assumes
that
each
node
makes
an
initial
vote
yes(1)
or
no(0)
●
Consensus
vote:
P
terminates
with
a
consensus
vote
of
either
yes
or
no,
where
if
the
consensus
vote
is
yes,
it
is
guaranteed
that
at
least
one
honest
node
voted
yes.
Note:
An
ABBA
protocol
typically
outputs
a
random
number
COMMON_COIN
as
a
byproduct
of
its
operation.
We
use
this
COMMON_COIN
as
a
random
number
source.
Consensus
Round
Immediately
after
the
proposal
phase
completes,
each
node
A
who
has
received
supermajority
signature
S
for
their
proposal
P
will
vote
for
Asynchronous
Byzantine
Binary
Agreements
(ABBAs)
in
a
consensus
round
R.
The
protocol
is
as
follows:
1.
For
each
R,
nodes
will
execute
N
instances
of
ABBA.
2.
Each
ABBA[i]
corresponds
to
a
vote
on
block
proposal
from
the
node
i.
3.
Each
ABBA[i]
completes
with
a
consensus
vote
of
yes
or
no.
SKALE
Network
Whitepaper
10
4.
Once
all
ABBA[i]
complete,
there
is
a
vote
vector
v[i],
which
includes
yes
or
no
for
each
proposal.
5.
If
there
is
only
one
yes
vote,
the
corresponding
block
proposal
P
is
committed
to
the
SKALE
Chain.
6.
If
there
are
multiple
yes
votes,
P
is
pseudo
randomly
picked
from
the
yes-voted
proposals
using
pseudo
random
number
R.
The
winning
proposal
indexes
the
remainder
of
division
of
R
by
N_WIN,
where
N_WIN
is
the
total
number
of
yes
proposals.
7.
The
random
number
R
is
the
sum
of
all
ABBA
COMMON_COINs.
8.
In
the
rare
case
where
all
votes
are
no,
an
empty
block
is
committed
to
the
blockchain.
The
probability
of
an
all-no
vote
is
very
small
and
decreases
as
N
increases.
Finalizing
Winning
Block
Proposal
Once
consensus
completes
with
winning
block
proposal
P
on
any
node
A,
the
node
will
execute
the
following
algorithm
to
finalize
the
proposal
and
commit
it
to
the
chain:
1.
Node
A
will
check
if
it
has
received
the
winning
proposal
P.
2.
If
node
A
has
not
received
the
proposal,
it
will
request
it
from
its
peer
nodes
for
download.
3.
Node
A
will
then
sign
a
signature
share
S
for
P
and
send
it
to
all
other
nodes.
4.
Node
A
will
then
wait
to
receive
signature
shares
from
a
supermajority
of
nodes,
including
itself.
5.
Once
node
A
has
received
a
supermajority
of
signature
shares,
it
will
combine
them
into
a
threshold
signature.
6.
Node
A
will
then
commit
the
P
to
the
blockchain
together
with
the
threshold
signature
S.
Blocks
which
are
committed
to
the
SKALE
Chain
contain
a
block
header
and
block
body.
The
block
body
is
a
concatenated
transactions
array
of
all
transactions
in
the
block
and
the
block
header
is
a
JSON
object
which
includes
the
following:
Name
Data
Type
Description
BLOCK_ID
integer
ID
of
the
current
block,
starting
from
0
and
incremented
by
1.
BLOCK_PROPOSER
integer
ID
of
the
node
that
proposed
the
block.
PREVIOUS_BLOCK_HASH
string
SHA-256
Merkle
root
of
the
previous
block.
CURRENT_BLOCK_HASH
string
SHA-256
Merkle
root
of
the
current
block.
TRANSACTION_COUNT
integer
Count
of
transactions
in
the
current
block.
TRANSACTION_SIZES
integer[]
An
array
of
transaction
sizes
in
the
current
block.
CURRENT_BLOCK_PROPOSER_SIG
string
ECDSA
signature
of
the
proposer
of
the
current
block.
CURRENT_BLOCK_TSIG
integer
BLS
supermajority
threshold
signature
of
the
current
block.
Table
1.
SKALE
Block
Header
Format
SKALE
Network
Whitepaper
11
SKALE
Super
Nodes
and
Nodes
Each
SKALE
Chain
is
composed
of
a
collective
of
randomly
appointed
nodes
which
run
the
SKALE
daemon
and
run
SKALE
consensus.
Unlike
other
protocols,
SKALE
nodes
are
not
restricted
to
a
one-to-one
mapping
between
participating
nodes
in
the
network.
This
is
made
possible
through
the
containerized
node
architecture
deployed
on
each
node
in
the
SKALE
Network
which
allows
each
node
to
run
multiple
SKALE
Chains
simultaneously.
Nodes
within
a
SKALE
Node
are
referred
to
either
as
super
nodes
or
nodes.
Each
node
participates
in
independent
SKALE
Chains.
Below
is
a
diagram
of
a
container
running
on
a
SKALE
node.
This
containerized
architecture
was
selected
as
a
means
to
bring
enterprise
grade
performance
and
optionality
to
decentralized
application
developers
on
par
with
centralized
systems,
which
offer
elasticity,
configurability,
and
modularity.
Containers
are
divided
into
five
main
components
that
ship
with
a
dockerized
Linux
OS
-
allowing
for
each
node
to
be
hosted
in
an
OS-agnostic
manner.
Each
container
is
encapsulated
within
one
of
the
following
services.
SKALE
Admin
Service
The
SKALE
Admin
Service
serves
as
the
human-facing
interface
for
nodes
with
the
SKALE
Manager
(located
on
the
Ethereum
Mainnet).
Functionality
shipping
with
this
interface
includes
the
ability
for
nodes
to
see
which
SKALE
Chains
they
are
participating
in
as
well
as
the
ability
to
deposit,
withdraw,
stake,
and
claim
6
SKALE
tokens.
Because
nodes
within
Super
Nodess
are
appointed
randomly
to
participate
in
SKALE
Chains,
there
is
no
interface
for
being
able
to
join
/
leave
SKALE
Chains
within
the
network.
Node
Monitoring
Service
The
NMS
(Node
Monitoring
Service)
is
run
on
each
SKALE
Node
and
facilitates
the
performance
tracking
of
each
of
that
node’s
peer
nodes.
Performance
tracking
is
measured
in
both
uptime
and
latency
through
a
regular
process
which
pings
each
peer
node
and
logs
these
measurements
to
a
local
database.
At
the
end
of
each
SKALE
Chain
epoch,
these
metrics
will
be
averaged
and
submitted
to
the
SKALE
Manager
which
will
use
them
to
determine
the
payout
to
each
node.
Node
Orchestration
Service
The
NOS
(Node
Orchestration
Service)
orchestrates
node
computation
and
storage
resources
to
instantiate
nodes
using
a
dynamically
created
node
image
consisting
of
the
SKALE
daemon
(skaled),
the
catchup
agent
for
syncing
a
SKALE
Chain,
and
the
transfer
agent
for
interchain
messaging.
This
service
also
performs
respawning
of
failed
nodes
as
well
as
deallocation
of
resources
to
nodes
who
have
been
decommissioned.
SKALE
Chain
Pricing
SKALE
has
a
sustainable
decentralized
economic
model
in
place
to
ensure
validator
incentives
are
both
sustainable
and
attractive
while
also
balancing
the
price
of
resources
compared
to
pay-per-transaction
blockchains.
Chain
pricing
is
the
equivalent
of
DSaaS
–
or
Decentralized
Software
as
a
Service
–
program
where
network
resources
are
available
for
rent
with
a
stable
and
consistent
payment.
6
SKALE
tokens
available
to
be
claimed
are
those
which
are
regularly
issued
to
nodes
based
upon
their
average
uptime
/
latency
for
a
network
epoch.
SKALE
Network
Whitepaper
12
Chain
pricing
operates
as
follows:
-
SKALE
Chains
have
a
flat
rate
rental
fee
that
is
dependent
on
the
network
utilization.
Network
utilization
is
calculated
based
on
the
Number
of
SKALE
Chains
/
(Total
Number
of
Nodes
in
the
Network
/
2)
-
SKALE
Chain
fees
and
distribution
ratios
may
be
modified
through
on-chain
voting
as
described
in
the
governance
section
of
the
whitepaper
-
SKALE
Chains
may
be
prepaid
for
up
to
24
months
at
the
current
price
which
protects
chain
owners
from
short-term
price
fluctuations
-
SKALE
Chains
may
run
up
to
three
(3)
months
in-debt
before
their
chain
and
all
associated
state
and
information
is
eligible
for
removal
from
the
network
Validators
benefit
from
SKALE
Chain
pricing
by:
-
Being
able
to
withdraw
monthly
rent
each
epoch
after
payment
is
due
-
Being
able
to
withdraw
SKL
tokens
directly
on
the
SKALE
Europa
Hub,
allowing
them
to
save
on
gas
fees
that
would
otherwise
cut
into
their
profit
margin
SKALE
Chain
pricing
enables
a
sophisticated
economic
model
for
a
decentralized
network
that
allows
all
the
constituents
to
fairly
balance
operational
costs
and
resource
usage.
To
learn
more
about
SKALE
Chain
pricing,
visit
the
SKALE
Forum
post
.
Attacks
and
Faults
To
account
for
network
downtime,
SKALE
has
integrated
a
series
of
contingency
strategies
for
performing
fault
recovery
on
both
the
node
and
chain
level.
These
range
from
an
automated
agent
for
performing
recovery
프로젝트로 돌아가기