SKALE 백서

SKALE

원문

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
프로젝트로 돌아가기