June 28, 2021
Why Multichain Networks Matter and Other Advantages of SKALE Chains
The SKALE Network is a highly expandable multichain blockchain network and serves as a highly performant and secure Ethereum scalability solution. Unlike most Layer 1 and Layer 2 networks, the SKALE architecture is built to support an ever expanding set of app-specific and protocol-specific chains. It uses the Ethereum mainnet to enhance security and for management and orchestration of critical network operations.
The way it works is dapp developers, DAOs, consortiums, and others, sponsor SKALE chains which operate using dedicated resources drawn from a large pool of validator nodes. The network supports this highly efficient resource allocation via the use of an innovative virtualized subnode architecture. The current nature of blockchain is one size fits all, one chain fits all. The SKALE Network changes this thinking. Much like Docker and Kubernetes have allowed for easily customizable, but massively scalable cloud services, the same is now true for blockchains.
Blockchains can now be dapp- or protocol-specific, sharing a large pool of validators – and inheriting the same security and transaction fidelity guarantees – as other chains in the network, but doing so using independently allocated resources. A multichain network has a tremendous advantage over single chain networks as well as networks with only a few chains (as in the case of Polkadot which has several para-chains).
Here are just a few of the advantages of a multichain network and, in particular, SKALE Chains:
A network that can provision chains at will is uniquely set up to better support dapp- or protocol-specific chains. Instead of a shared chain – which brings with it throughput contention and other noisy neighbor problems – dapp-specific chains make use of dedicated resources to ensure consistent throughput and settlement times.
Single chain networks can have transaction contention, given that other dapps and protocols can submit transactions to the chain at any time and with any frequency. This results in gated throughput and inconsistent response times, not to mention increased gas costs. Because of these transaction delays and higher fees, single chain networks are not well-suited for most common Web3 interactions. As found with Layer 1s, they work well for asset transfers and other high value or mission critical use cases – where settlement in minutes is an improvement over much longer settlement periods with one or more intermediaries. They do not work well, however, where there is a need for second or sub-second response times. Chains that are provisioned specifically for a dapp or protocol can provide greater response times and greater response assurances.
Proof of Stake Chains
The SKALE Network is a Proof of Stake network. Proof of Stake (PoS) chains are the next form of blockchain consensus – as they are proving to be much faster and much more resource efficient than Proof of Work chains. The excitement over Eth2 and its Proof of Stake chains is but one example of how PoS can increase mainnet throughput while still preserving sufficient security guarantees.
Proof of Stake chains gain performance and low latency by using a smaller number of validator nodes but at a potential risk to the transaction integrity (under the theory that smaller sets of nodes are more susceptible to collusion and bribery).
The SKALE Network employs a number of architectural strategies as part of its PoS consensus model to ensure proper node operation and transaction validity. It uses a pooled validation model, which leverages the security advantages offered by a large number of validator nodes, and combines it with random node assignments with frequent node rotation which chain validator sets. Each independent SKALE Chain is thereby protected with the security overlay of the entire network.
To further secure the network, each validator stakes a significant amount of value into the network via a SKALE token. These stakes are maintained within the Ethereum mainnet. In addition, a significant portion of SKALE’s network operations, management, and administration happens via smart contracts that run on the Ethereum mainnet. These contracts in turn manage and control the virtualized SKALE nodes and subnodes that operate SKALE Chains. Additionally, all staking, chain fees, slashing, and governance happens on the Ethereum mainnet.
SKALE Chains are specifically designed to be high performance in both throughput – the number of transactions they can handle over a period of time – and settlement time – the time it takes for transactions to be accepted via the consensus mechanism and placed into a block. SKALE Chains make use of a custom-designed mathematically provable ABBA-based consensus algorithm that allows for variable block times thereby increasing the speed of block creation.
Most Proof of Stake algorithms such as ETH2, Tendermint, EOS, and Polkadot work similarly in that they use a single block proposal scheme. At any point in time, there is a designated node that is the only one that can propose a block. If their block is deemed by the others to be OK, it gets added to the chain and then another block proposer is selected. This selection can be round-robin, by random selection, or via some other mechanism.
This sequence is time-sliced in that there is a fixed period of time within which the proposer can propose a block. There is also a timeout period whereby if the designated proposer does not propose a block, the option goes to the next proposer. For example, Eth2 has a 10 to15 second timeout period which means that each designated proposer has that much time with which to propose a block. It also means that others cannot propose blocks until that time period is up. (It also means that a proposer may have to propose an empty block – in the event of no transactions – so as not to be deemed non-responsive or, worse, malicious.)
SKALE’s consensus algorithm is different in that it lets every node building the chain propose a block candidate. Which means all 16 nodes in a chain can propose a candidate at the same time. Out of these 16 candidates, one is selected. Based on the mathematics behind the algorithm, a high percentage of the candidates are presumed to be valid candidates which means there should never be a timeout which, in turn, means no fixed time period is needed. It also makes for fast chain creation in that after a block is added, each node is able to immediately submit a new candidate.
SKALE Chains are resource efficient in that they make use of virtualized subnodes and compressed block proposals.
The SKALE Network makes use of containerization and virtualization to partition nodes into subnodes thereby leveraging node resources across multiple chains. Nodes can be segmented into up to 128 subnodes and, with various configurations, support multiple small and medium chains and/or one large chain. By way of example, a small chain will be allocated 1/128 of the node resources, a medium chain will receive 1/8, and a large chain will get the full node (not including the node core). This subnode architecture allows rationalization and distribution of CPU cycles, memory, I/O, storage, and other node resources.
For more details on how SKALE uses containerization and virtualization, see these posts here and here.
Compressed Block Proposals
Another way SKALE Chains improve resource and energy efficiency is by employing lightweight block proposals. Each of the 16 nodes or subnodes that manage a chain can submit a block proposal. Normally, having 16 block proposals would be expensive in terms of network traffic because every node would need to send their proposal to every other node.
SKALE addresses this inefficiency in a simple but novel way by using transaction fingerprints. Each node in a blockchain has a pending queue of transactions. Although these queues typically have slight differences due to network and propagation delays and other transmission issues, they tend to be approximately equal. As a result of this high similarity, nodes can avoid sending the actual transactions and instead send hashes or fingerprints of the transactions.
When the nodes receive these fingerprints, they can look into their pending queue, find the transactions, and then reconstruct the proposals. (Any missing transactions can be requested but sending a few transactions in their entirety are much less expensive than sending hundreds or a thousand.) Because of this fingerprinting approach, SKALE block proposals are extremely lightweight, efficient, and fast.
Variable Chain Sizes
As highlighted above, SKALE is a multichain network that uses virtualization to segment nodes into subnodes. A primary benefit of this innovative approach is that it lets SKALE support variable-sized chains – small, medium, and large. This variable choice lets chain sponsors tailor the cost and resource allocation to their needs of their protocol or application. Developers that are prototyping or just starting out can use a small chain and utilize only a fraction of a node’s resources whereas commercially active dapps or protocols would use medium or large chains thereby making greater use of node resources.
This variability is unique to blockchain but is a standard part of Web2 and modern cloud computing. Virtualized resourcing is proven as a way to provide efficient resource utilization and improve network management. This fundamental shift in how blockchains are provisioned and deployed and the multichain nature of the SKALE Network is one of the reasons SKALE is confident in its mission to grow Ethereum to support a billion users and trillions of transactions.
SKALE Chains are provisioned and paid for by chain sponsors. This resourcing approach thereby eliminates the need for transaction fees which is one of the main gating factors in broader Ethereum and Web3 adoption. The past year or more has seen prolonged periods with significant Ethereum mainnet gas fees, putting many apps and protocols at risk of being uneconomical to operate. Eliminating fees opens up entire categories of transactions that can take advantage of decentralized processing and storage – ones that are currently unreachable on the mainnet.
Dapps may still incorporate some form of transaction fee as part of their revenue model or for other reasons but only by choice and not by necessity. Gas-free chains, in combination with much improved transaction processing speed and finality, make almost every in-app action eligible for processing within a smart contract and/or for storage within a chain.
Proof of Stake chains are more complex than Proof of Work chains and so by nature they need greater resiliency and added fail-safe measures. SKALE addresses potential outages in multiple ways. Because of the algorithmic rigor of the SKALE consensus algorithm, up to five nodes out of sixteen nodes in a chain can stop working and the chain will still continue operating as usual.
If a node does die, there are two mechanisms to sync it back to the chain. If the node has been down for a few hours, it can use a cache of blocks kept on other nodes to sync and catch up. If a node has been down for a longer period of time, it can get a chain snapshot from another node and then catch up from there, using the cache.
If there is a more catastrophic problem and more than five nodes stop processing, then the system will halt. Nodes will either be brought back online using the cache method or by restarting from a snapshot. (Every node makes a snapshot of itself every 24 hours and stores its own copy. Snapshots can also be downloaded and stored by chain sponsors.)
The containerization and virtualization featured in the SKALE Network also serves to increase the speed at which innovation can be incorporated into SKALE Chains. Instead of relying on the pace of network-wide releases, developers will be able to build specific functionality and new services directly into their own SKALE chains. This flexibility opens up the SKALE Network to an entire ecosystem of tools, strengthening it in specific areas by using existing bridges, file storage, oracles, data querying/analytics, roll ups/centralized verification, and other functions that support a particular application or protocol.
One approach to customization addresses the situation where a feature is fully implementable in Solidity. With an Ethereum package manager, such as ethPM or other community developed efforts, chain sponsors will be able to install it into a SKALE chain similar to how Linux installers work. [https://www.ethpm.com/]
For deeper modifications, pre-compiled contracts can be used. One of the pain points with Ethereum mainnet is they are limited as to which algorithms they can support. With SKALE, chain sponsors will be able to decide what pre-compiled contracts can go into their chains. If they want a particular algorithm or contract, they will be able to create a package for it and then use a traditional package manager for the language they use (Python for example) and insert them into nodes as a pre-compiled Python package.
Multichain networks closely tied into the Ethereum mainnet will be a primary factor in scaling Ethereum and unlocking the full potential of Web3 applications and protocols. The SKALE Network is delivering on this vision with a fully formed and secure network that offers chains of varying sizes and configurations.
Developers no longer have to constrain themselves to a single chain or a handful of chains but can make use of their own chains with dedicated node resources derived from a large validator pool. These chains offer high performance, fast finality, and zero gas fees while benefiting and inheriting from many of the security guarantees of the Ethereum mainnet. The future of Web3 can be found on SKALE.