About the SKALE Network and Why It’s Important

SKALE is building a layer of infrastructure on top of Ethereum that will allow developers to build their projects faster and with better performance. We do this by building an elastic blockchain network that can have thousands of independent blockchains, sidechains, storage chains, and other types of subchains – all tied to the Ethereum public mainnet. This network will be comprised of thousands of independent nodes in combination with security guarantees of a Layer 1 but architected to use resources in a more efficient and versatile way. A thousand validators in the SKALE Network, for example, can support 8,000 independent chains. These chains could range from the smallest of sidechains to very large public or private blockchains.

This approach does not mean we are trying to invent a new chain. We are focused on helping Ethereum developers scale their smart contracts and develop dApps more quickly – all via a secure Layer 2 solution that features a security model that’s closely tied into the Ethereum mainnet.

With a SKALE elastic blockchain or sidechain, dApps will be able run with sub-second block times and with throughputs of up to 2000 transactions per second. They will be able to execute full-state smart contracts, make use of sophisticated storage and machine learning algorithms, and drastically reduce or eliminate gas fees and other user-facing transaction costs. The SKALE Network also offers interchain messaging which lets dApps perform state updates in coordination with the mainnet. All with high-grade security and safety. Lastly each SKALE chain provides File Storage functionality to dApps letting them run end-to-end decentralized apps, website, games, etc.

Most sidechain protocols are insecure. The reason is that most solutions tend to have a small set of nodes validating each chain which are usually fixed and do not change. With this type of arrangement, app developers can encounter some serious risks at the consensus layer – risks that include collusion, bribery, and other bad behavior that can impact the validity of your transactions.

Mitigating Security Risks in Layer 2 Solutions

Security and validity of transactions in a sidechain or subchain in a second layer primarily rests with the performance and behavior of the validator nodes. To make sure the validation layer is operating properly, a network first has to have a large number of validator nodes. A small number of nodes in a network is inherently risky and fragile.

In addition and as a requirement for a secure and robust network, it must provide for a) the random selection of chain validator sets and b) the rotation of nodes in and out of chains on a frequent basis. Without randomness and rotation, there is a far greater risk of bribery of and/or collusion between validators, vastly reducing the security and integrity of the chains within a network.

The SKALE Network Uses a Pooled Validation Model

A final requirement at this layer is a proper incentive structure that addresses both penalties and rewards. With respect to the former, every validator node should have significant value staked into a network. Staking is an enforcer of good behavior in that if a validator decides to collude or go byzantine and gets caught, it will lose its stake and be removed from the network. With SKALE, the validator stake will be on the order of 100,000USD equivalent (or higher based on token appreciation).

To coerce or bribe the validators of a sidechain with this type of a pooled validation model – one that employs random selection and frequent node rotation – a bad actor would have to effectively bribe two thirds of the larger network. To do this with a large number of nodes in the overall network would be exceedingly difficult. SKALE’s network design is based on these core principles and is directly aligned with stopping – if not eliminating – attacks and preserving the integrity of transactions within each chain in the network.

How a Pooled Validation Model Works

Decentralized network design is still in its infancy and so it is not surprising to see confusion as to how a pooled validation model works. Also overlooked is how this SKALE innovation guards against collusion and bribery, and how connections and tie ins with the Ethereum mainnet form the core of its security model.

As mentioned above, the SKALE Network is a network of nodes, all running concurrently and independently, validating transactions within the blockchains and sidechains they are overseeing. These nodes all make use of a unique set of SKALE contracts that run on the Ethereum mainnet. These smart contracts are where the SKALE token lives, where inflation happens, and where rewards get disbursed to the node validators. These smart contracts are also where the analysis of the network takes place and where corrective actions are taken if there is bad behavior by one or more nodes.

Creating a chain within the SKALE Network is a relatively simple process. A developer first needs to get SKALE tokens. (It is very easy to convert from ETH to SKALE via a decentralized widget in the SKALE Deployment Interface.) They then select the size of the chain they want, the amount of storage, and the initial duration of the chain (3mo, 6mo, 12mo, for example). The developer then submits the right amount of tokens to the network. These tokens get staked into the Ethereum mainnet via one of the SKALE contracts that reside there. Each month, a certain number of tokens from this developer stake gets moved into a bounty pool which is then used to pay the validators within the network. Each month, an inflation event happens whereby new SKALE tokens are created, again via a contract on the mainnet (see note below). These new tokens also get pushed into the bounty pool for payout to the validators.

It’s important to emphasize that whereas custody may be taking place in a SKALE sidechain, the security for the SKALE Network is rooted in the Ethereum mainnet. The stake from the validators, the payments from developers, and the token inflation – all of it lives in the Ethereum mainnet and all of it is controlled by the smart contracts that run there that work in unison with each SKALE Node.

This approach is different from other Layer 2 models that attempt to use mainnet interactions to run verification and/or fraud proofs. SKALE uses the Ethereum mainnet for staking and for other mechanistic operations in a way that is better attuned for the creation of a robust and trustworthy Layer 2 network. SKALE will also support BLS Rollups for use cases that require full reliance on MainNet custody.

More on Token Inflation
A smart contract on the Ethereum mainnet controls the inflation of the SKALE token. New tokens are created each month at a certain schedule and rate in a manner that is predetermined within the contract. The transparency of contracts on the mainnet makes the inflation schedule and rate visible for everyone to see. Also contained in the contract, there is logic that has initial halving at year four with another halving at year seven. Note that with on-chain voting, the community can elect to change the inflation rate and make it higher or lower if they so determine.

How the Network Operates and is Organized

The validator nodes in the network operate and organize themselves in an independent manner. There is no central node controller that chooses which chains a node should work on. Instead the nodes are collaboratively working on algorithms among themselves to figure out the randomness and rotation and what chains to work on. Each node acts similarly to a drone. What they are doing is communicating with the mainnet contracts along with other nodes in the network in a decentralized but coordinated manner.

A large amount of the network operation is vested in a node core which is an embedded part of each SKALE validator node. This core is where network auditing, orchestration, and administration takes place. The node core also serves to gather metrics from other nodes, perform independent processing on these metrics, and then upload this data to a smart contract running on the mainnet.

Validator Nodes Consist of Virtualized Subnodes and a Node Core

In terms of starting up a chain, a developer will choose the parameters of the chain (size, storage capacity, and duration in particular) and then stake tokens onto the mainnet. They do this via a web interface that connects to the SKALE Network through Web3 APIs. The request for a new chain will get passed to a node at random. Its node core will connect with the mainnet where a smart contract will randomly allocate a set of nodes from the available pool. Upon check-in with the mainnet, these nodes will then begin working together in support of this new chain.

Nodes will be removed from one or more chains every so often and different ones will be added. This rotation again takes place via the concurrent activity of the node cores which are continually checking in with the mainnet to get their assignments. Rotations happen on a particular schedule as determined by the mainnet contracts. Nodes monitor and pick up these rotation events – exiting current chains and connecting with and working on new chains as so determined.

Nodes within SKALE Chains are Regularly and Randomly Rotated Thereby ‌‌Leveraging the Security Pool of the Entire Network on Behalf of Each Chain

Note that developers can modify chain parameters at any time. These changes will get reflected during the next scheduled network rotation in much the same process. (The change request will be relayed to a node core which will then propagate it to the mainnet whereby a smart contract will relay the resource modifications to the nodes that are currently managing and operating the chain.)

This post is the first of a two-part series. The second and final portion of the article addresses the role of the validator node, the importance of staking, the network effect of the token, and more. Part two can be found here.