SKALE Network — crash course

Elastic Blockchain Network

I have recently came across The SKALE Network — and among projects trying to become the next Ethereum killer, SKALE is actually very different, being a friend of Ethereum, building on its strength and addressing Ethereum’s pain-points. SKALE is an Elastic Blockchain Network, designed to be an environment to easily build your own dApp-specific blockchain or sidechain, adjusted to the volume of your users, and customised to best suite a specific business-case, which your dApp is trying address.

With this article we will dig into several topics — lets call it a crash course of The SKALE Network:

• The problem SKALE is trying to solve.
• SKALE Network — in depth review.
• Elastic Sidechains.
• SKALE Validators.
• Advantages of SKALE.
• History, Funding and Token behind SKALE.
• Start Building.

The problem SKALE is trying to solve.

At this point we all are probably aware of the scaling issues which Ethereum is facing. Currently processing 20 transactions per second, which is probably not good enough to address future needs of the decentralized applications. Because of the challenges to scale, another problem that arises for Ethereum is the high cost of transactions on the Ethereum mainnet.

While Ethereum is preparing for the more robust version of the platform, Ethereum 2.0, there is a project (the SKALE Network) that is actually helping Ethereum 1.0 to become scalable, less expensive, as well as providing improved user experience. Users in case of SKALE are for example developers, so to scale the user experience is to solve scalability issues, as well as problems with latency, connectivity with wallets, cost efficiency and seamless communication between chains.

The SKALE network is a configurable network of flexible side chains that supports high bandwidth, low latency transactionswithout the high transaction costs associated with other known public networks. The network also offers advanced storage capabilities, as well as interoperability and cross-chain messaging with the Ethereum public network. All of this is done using a bulk transaction validation model and security model that is efficient, scalable, and collusion-proof. We will explore details in the latter parts of this crash course.

Before we start — just to list a few benefits of SCALE:

• near zero gas fees
• faster finality of transactions
• much higher speed of transactions (high thoughput).
• Interoperability with other chains in SKALE Network
• overall better user experience (low latency in transactions, easier deployment for developers).
• Less expensive Storage costs.

Because in SKALE Network we can have thousands of Elastic Sidechains, they will also provide a significant amount of additional on-chain capacity for decentralised applications. Thanks to such approach, storing data on public networks is made possible. Today storying on-chain data on Ethereum network is very expensive, what makes developers to seek for other decentralized solutions, to store the data. With SKALE, they can use elastic side chains as a part of their architecture for decentralized apps.

This opens up gates for Ethereum and Solidity developers for all the use cases and applications, which were much harder before, if not impossible, due to limitations of Ethereum.

Just to name a few possible use cases of SKALE:

• Advanced DeFi apps
• Gaming apps
• Social Media platforms
• Decentralized Commerce apps
• IoT applications
• Healthcare, Real Estates tokenisation, DID, and many more.

Please read this Primerdocument to find general intro to SKALE.

SKALE Network — in depth review

SKALE was create to run dApps in a decentralized, modular cloud that are talking into account needs and requirements of real world applications. SKALE is built in a way that you can deploy your dApp with just a few lines of code.

Lets review in more details how it all works.

Sidechains (aka Elastic Sidechains) in the SKALE Network are run by a group of random subnodes, which are selected from the biggger group of nodes in the network. Sidechain will use the storage, computation resources and other capacity, provided by the nodes (via sub-nodes) — adjusted to the size of the sidechain (defined while chain is being created as small/medium/large- and adjustable later on, if needed).

Sidechains are achieving consensus via Asynchronous Binary Byzantine Agreement protocol (ABBA), and can communicate with other chains via interchain messaging protocol.

The SKALE Network is using a pooled validation model. This model leverages the security offered by a larger number nodes, combining random node assignments and node rotation among the validators. Thanks to such design, independent sidechains are protected with the nodes/security of the entire network.

Validator must stake a significant amount of SKALE tokens ($SKL) into the network to be in the game (more on staking in latter part of the article)

Whole SKALE Network, including Governance, Staking, Configuration and Deployment is done on Etheruem side, and controlled by smart contracts there (SKALE Manager — read full details in the WhitePaper).

SKALE Manager

Validators are encouraged to join the network by the rewards offered to them in SKL tokens (token inflations and the monthly payouts to validators are also part of Ethereum mainnet contracts). These Ethereum smart contracts also handle the monitoring of node performance, and potential penalties, if nodes are misbehaving or are not performant — The SKALE Manager serves as the controller and entry-point to all other smart contracts in the SKALE ecosystem,including deployment of smart contracts,onboarding and monitoring of Validators, fees, Elastic Sidechains creation process.

Lets have a look on the architecture of SKALE Virtualized Subnodes first, to then discuss the role of such subdones in the SKALE Network and creation of Elastic Sidechains.

SKALE & Virutalized Subdones

We already learned that sidechains are comprised of a randomly appointed virtualized subnodes, and the whole process is managed by SKALE Manager. The Subnode to be part of the network must run the SKALE daemon and participate in the SKALE consensus.

Unique Feature of virtualized subnodes is that they are not restricted to be part of just one sidechains, but they can be included in multiple sidechains, depending on the configuration (1:N mapping). This is possible thanks to the virtualized subnode architecture (see picture above for illustration) deployed on each node in the SKALE Network, which allows each node to part of multiple Elastic Sidechains at the same time.

Each Node in the SKALE Network is architected with the following components:

• Virtualized Subnode
• Subnode Orchestration Service
• Node Monitoring
• SKALE Admin

Virtualized Subnode

Resources of each node in the SKALE Network are divided into up to 128 Virtualized capacities = subnodes, which are orchestrated by the Node and SKALE Manager, and are then assigned to create elastic sidechains in SKALE Network . Depending on the size of the Sidechain, the node could contribute 1/128 or even all its resource to particular elastic sidechain. For the time being we have 3 types of sidechain sizes available:

• small
• medium
• large

I will describe how it work in a later parts of this course.

Subnode Orchestration Service

The Subnode Orchestration Service plays a major role ensuring that particular node, Virualized Subdones and its resourcs are working as a well oiled machine within the SKALE Network. This Orchestration service oversees activities like:

• management of the computation process done by the node,
• assignment of storage resources to instantiate virtualized subnodes,
• syncing an Elastic Sidechain via catch-up agent,
• interchain messaging via transfer agent,
• respawning of failed virtualized subnodes,
• deallocation of resources from avirtualized subnode who have been decommissioned.

Node Monitoring

Particular nodes could do better or worse job in terms of efficiency, contribution, and usefulness for the entire SKALE ecosystem. This is where Node Monitroing Serice (NMS) comes into play.

NMS is run on each Node and manages the performance measurement of peer Nodes in the network. What is being measured for performance is uptime and latency, and this is done through an ongoing process, pinging each peer node and logging measures to a database.

This metrics will be averaged out, submitted and leveraged by the SKALE Manager, at the end of each epoch, to determine the payout to each node.

The more available and performant the node and its virualized subnodes overall have been, the bigger the potential payout.

SKALE Admin

There is also something like a human-facing interface for virtualized subnodes with the SKALE Manager (located on the Ethereum Mainnet) — this role is played by SKALE Admin functionality.

Features of SKALE Admin include:

• view which Elastic Sidechains are being supported by the Node.
• ability to deposit, withdraw, stake and claim SKALE tokens.

Elastic sidechains are equipped with virtulized subnodes on a radome basis, this is done for security reasons, hence there is no functionality to join / leave Elastic Sidechains on request — this process is being managed by the SKALE Network.

I encourage you you digest it further in the SKALE Network Whitepaper.

Elastic Sidechains

Now once, we have covered the design of Nodes in the SKALE Network and Virtualized SubNodes, it should be easy to understand one of the Key Concepts behind Skale Network — namely — Elastic Sidechains.

SKALE Network is an Ethereum Interoperable Elastic Blockchain Network, what basically mean that out of Virtualized SubNodes provided as a part of SKALE Network, you can easily create your own side chains (small/medium/large) which will be compatible with Ethereum (thanks to Ethereum Virtual Machine, EVM) and interoperable with other elastic sidechain in the Network, thanks to architecture and messaging protocols provided by SKALE.

The implementation of the SKALE Network offers Elastic Sidechains comprised of virtualized subnodes which engage with the network via asynchronous, leaderless, and secure protocol. This a protocol is designed to provide robust performance. In case the virtualized subnode is down or underperforming will be marked as a slow link.

For the network to be working at least 2⁄3 of the virtualized subnode validators need to be online. As long as this is true, they will continue creating and new blocks and adding them to the chain.

Elastic sidechains within the SKALE Network are called Elastic for a few reasons. Not only users can request size of the side chains chosing from small to large, but are also highly configurable. Developers are able to choose also the consensus protocol, compativle virtual machine, and one day parent blockchain as well as other security features..

How does the requesting process work?

FIRST, when requesting a sidechain, the developer will configure the chain via an interface and then submits payment to the network in the form of SKALE tokens (payment will depend on the size of the network, duration of the request).

There are several sizes of side chains possible (S, M, L) as well as duration options vary from 3 months to 1 year). Required storage within the network is also a subject to configuration.

SECOND, once the request is submitted the elastic sidechain is assigned with a random validators. The default number of validators is 16 validator nodes (number of nodes can configured according to the forumla = 3n+1)

Most important characterstic of the chains is the size though. This determines how much of a virtualized subnode a chain will use.

• For a small chain this is = 1/128 of virualized subnode and it’s resources.
• For a medium chain this is = 1/16 of virualized subnode and it’s resources.
• For a large chain this is = full virualized subnode and it’s resources.

What is a huge advantaged of SKALE Network that the size is not fixed once and for good. Of course the needs can chanage as the dApps becomes more and more popular, you can move from small to medium or from medium to large.

Also, as the SKALE Network evolves, more customization for users will be possible, for example to specify the exact number of virtualized subnodes or number of signers.

The coversion of SKELE Network Validator Virtual Node Pool into individual SKALE chians can be illustrated as follows.

What is great about SKALE network is that it is not trying to reinvent the wheel, at least not completely. It is supposed to add steroids to Ethereum and here is where EVM-compatibility comes into play. Developers are able to use the same language (Solidity) and tools, exactly as they would’ve been working on the Ethereum mainnet. These include programming but also using tools such as Truffle and Remix. I will cover that later when describing Ethereum Interopearbility.

Another major breakthrough is that the SKALE Network provides interchain messaging as a native capability of SKALE. Communication between chains is enabled by the virtualized subnodes, able to validate if a transaction was signed and committed by the subnodes in another chain. This is achive with BLS signatures (Boneh-Lynn-Shacham).

Expand the Chain to a Larger one!

Lets say you started with a small chain but your base of your users grew and the capacity of this chains is not sufficient anymore. SKALE Network has been built to be expandable and hight performance once in production, even if your requirements changed.

When requesting the chain, developers select chain parameters and then stake tokens to get access to one or more elastic sidechains, but the resource configurations for such chain can also be modified anytime, accommodating increased transaction loads, storage requirements or security requirements, or increased load of users. So you can start small for rapid development, and as your business evolves you can adjust your sidechains to be optimal solution for larger production needs.

Small SKALE chains are good for

• quick development, PoCs
• low-buget apps, non-critical solutions
• easy to use and setup chains

Large SKALE chains are better for

• High throughput dapps, high trx/sec volume
• Large User Base
• Decentralizing computing
• Mission Critical apps

Since the elastic sidechain in the Network can be easily upgraded, it allows sidechains to move from a small size and slower to a large sidechain with even up to 2k transactions per secondand advanced storage capabilities.

Changes take place in real-time without any additional operational efforts or manual management actions by a user.

Either you are developing a defi, gaming or social media application — SKALE will probably be easily able to accommodate your requirements. Single developer or consortiums can use of the SKALE Network for one or more sidechains to provide fast, safe, and secure transaction processing for dApps.

In a latter part of this crash course we will review SKALE’s interoperability with Ethereum, and why a developer might consider to chose SKALE Network, but first a short review of how SKALE achieves efficiency and scale in computation and storage costs thanks to BLS rolloups.

BLS Rollups

One of the unique features of SKALE Network is the scalable approach to Storage and Computation. Each sidechain in the network supports BLS Rollups, what opens the gates for new possibilities as far as scalting is concenred.

BSL Rollups provide an efficient and secure way to use the SKALE Network to improve throughput and lower gas costs on the Ethereum mainnet. Rollups are solution where transactions are published on chain, but more detailed and demading computation and storage of transaction results is done differently, providing a better economical value. BLS Rollups works thanks to cryptographic algorithms called aggregated BLS signatures, shrinking ETH transactions.

The work to integrate BLS Rollups into SKALE encompasses three phases of development with Phase 1 providing up to fifty transactions per second for ERC-20 token transfers, with next phases expanding further to improve even up to 2k transaction per second.

Above illustration outlines hight level concept behind bls-rollups, and these might be used to not only increase performance but also provide Storage capabilites in more cost effective way.

SKALE Validators

As described before, the SKALE Network is secured by validators who are randomly assigned to Elastic Sidechains. These Validators run Nodes, providing computation power to the SKALE Network by deploying their Nodes, and these are becoming Virtualized Sub-Nodes which building blocks of Elastic Sidechains in SKALE Network.

Let’s briefly review what is the process to become a node operator:

1. To be added as a node to the SKALE Network, the node must run the SKALE Admin, which manages all operations in the node and is installed with the skale-node-cli.
2. SKALE Admin will evaluate the prospective node to check if it is fullfiling network hardware requirements.
3. If the candidate node passes the verification process, the SKALE Admin will permit the node to submit a request to SKALE Manager (asking to join the network). Such request contains both the required SKL deposit as well as metadata collected by the SKALE Daemon (like IP address, port).
4. The SKALE Manager (running on Ethereum side) if the node is accepted, will randomly mark the candidate node as either a “full node”or a “fractional node”. Full nodes will have all of their resources utilized for a single Elastic Sidechain, while fractional nodes will participate in multiple Elastic Sidechains (concept called multi-tenancy).
5. Once the node registration process is completed, the node will be also assigned group of random peer-nodes to monitor. As described before, the peer nodes regularly audit several metrics on regular basis, to monitor if the network and nodes are performant and will submit the batched metrics to the SKALE Manager once per epoch.
6. Basing on the batched metrics the reward for particular node are derived. The better performance of the node, the higher the bounty.

It is not extremtly difficut to become a Validator for the SKALE Network :)

Here are the Node Hardware Requirements:

• A Linux x86_64 machine
• SGX-enabled Intel processor
• 2 TB min of attached/block storage
• Ports 22, 8080, 9100, and 10000–11000 and ICMP IPv4 open for all
• Ubuntu 16.04 or later LTS
• 32GB RAM

You can apply to join as the validator here, and become part of the early SKALE Validators, like:

Advantages of SKALE

One may think of why to chose SKALE vs other Networks, so let me sum-up some unique features the SKALE Network provides:

Fast x Secure x Decentralized

This is known as blockchain trillemma, that if you want to have more scalability you will probably compromise security, decentralization or both. On the other hand, when you are making your network more secure you speed suffers or you are compromising decentralization.

Looks that SKALE tackles this triangle pretty well.

With The SKALE Network developers are able to quickly and easily set up cost-effective and performant sidechains, for running full-state smart contracts.

How is this possible that Scale does not compromise security nor decentralization?

The SKALE network uses a pooled validator concept, which is designed in a way that leverages the security of the entire network on behalf of each independent chain. Nodes are ranomly assigned on periodic basis to particular chain, hece it is impossible to attack a smaller chain — you would rather need to try attacting the bigger network, what is much harder. At the same time smaller chains in the SKALE network can expand to adopt growing capacity needs, hence performance always stays top-notch(if developer has a budget to increase the size of the chain). At the same time smart contracts executing on the Ethereum mainnet as a SKALE Manager are in place to ensure that the entire network operates in a fully decentralized way.

Leaderless Network = No Collusions

The SKALE Network operates like a decentralized cloud, providing high-throughput and low-latency elastic sidechain environment. Elastic sidechains in the SKALE Network are operated by a group of virtualized subnodes, randomly selected from the larger set of nodes in the networ — no leader.

Using a pooled validation model that is efficient, scalable, and collusion-resistant, SKALE technology does not have the drawbacks of traditional sidechains (like security risk of small validator sets).

Security Model in SKALE Network is leveraging the security advantages offered by a large networks (many validator nodes) and thanks to combining random node assignments to each chain and frequent node rotationamong the validator set no leader is in charge to mange the process, hence no single point to attack neither a risk of collusion. The approach is called Random Rotation Incentive Scaling.

Independent sidechains are protected with the resources of the entire network.

Innovative Tech ( Containerization, Virtualization, BLS)

SKALE uses pretty innovative architecture to provide high performance decentralized platform, with flexibility of choice for application developers of different needs. SKALE architecture is leveraging the virtualization tech to contrcut its network of nodes .

One node can contain even up to 128 virtualized subnodes. In result we achieve flexibility and performance which you would typically get from centralized could provider.

The node virtualization is boosted by advanced cryptography, namely the use of BLS threshold signatures(other projects like Dfinity are also leveraging this concept BTW). Elastic sidechains are supporting this protocol, what expands the possibilities of SKALE Network in many different ways. Just to give a few examples :

• virtualised subnodes are able to validate that a transaction was signed and committed by the subnodes in another chain.
• Storage capabilities can we spread across multiple sub-nodes, hence being less expeinsive and competitive comapring to other decentralized platforms

Secure ABBA-based Consensus Protocol

ABBA = Asynchronous Binary Byzantine Agreement (ABBA) protocol is the consensus model used for block creation and commitment for each elastic sidechain within the SKALE Network.

ABBA protocol was designed to provide robustness in the case of subnode downtime — thanks to being Asynchonous — where each subnode that is latent or down is regarded as a slow link (as described in previous part of this article)

Frictionless UX for Both the Developer and the End User

The ease of deployment, and transaction performance of the SKALE Network will result in the next wave of innovative applications in the Ethereum ecosystem. What we know from Etherum as a high gas fees, multi-confirmation sequences, and long time to finalize the transactions, will be replaced with seamless interactions that are in line with demanding user expectations — all we need for mass adoption.

And last point as far as key and unique advantages of SKALE are concerned is Ethereum interoperability — so lets spend a bit more time to discuss why is it so important.

Ethereum Compatibility and Interoperability

The SKALE Network is designed to be asecurity and execution layer that anchors to the Ethereum network.All the smart contracts to maintain the node and SKALE Manager are executed on the Ethereum mainnet. The validator stakes, user subscriptions, the token economics and inflation, are also managed by the smart contracts on Ethereum side.

The development process is basically the same as developing on Ethereum. We know that Ethereum has the largest global blockchain developer community right now as well as suite of working tools and other developer resources, what is a huge advantage, and some Eth developers will probably decide to move their work to SKALE, and take the befit of speed, flexibility and lower costs, while still maintating the security and familiarity they know from Ethereum.

There is at least 5 ways these to are interoperable — lets digest:

1-Solidity language

SKALE Network is using Solidity as a language to program smart contracts, so developers dont have to learn new lanuge. Solidity, being an object-oriented, high-level language for implementing smart contracts, with strong influence from C++ or Python, and JavaScript is actually easy way even for non-blockchains developers to get started.

2-Ethereum Virtual Machine (EVM)

Smart contracts that run on the Ethereum can also run on the SKALE Network because SKALE execution model is fully compatible with EVM. There is no need to rewrite or port smart contracts — simply all your contrats written for the EVM will by-defult execute on SKALE. Developers are able to migrate to elastic sidechains in a very easy way (more on this in the latter part of this article).

3-Ethereum Developer Tools

Support for Solidity and the EVM is a nice thing, but fact that developer tools from Ethereum can be used with SKALE, makes it even more attractive. Devs can use exactly the same tools, which they use when working on the Ethereum. These includes web3.js or web3.py, but also using tools like Truffle and Remix.

4-Ethereum Token Standards

SKL is ERC-777 token, but the SKALE Network supports all major Ethereum token standards like ETH, ERC20, ERC721, ERC777 or even Dai. You can create ERCxx tokens on SKALE network and use them in other ecosysmes where you would normally use Ethereum mainnet tokens.

5-Ethereum Wallet Support

Same with wallets, where SKALE Network supports a many known crypto wallets or browser plugins like Metamas, Portis, Fortmatic or Torus.

The SKALE Network uses Solidity as its contract language sparing developers from having to learn a new language or protocol. Solidity is an object-oriented, high-level language for implementing smart contracts and is used by the Ethereum Virtual Machine (EVM). The SKALE execution model is fully compatible with the EVM making it so that smart contracts that run on the Ethereum mainnet can also run on the SKALE Network.

Developers are also able to use the same tools they use when working on the Ethereum mainnet. These include connecting to the network via web3.js and web3.py as well as using tools such as Truffle and Remix. Additionally, the SKALE Network supports all major Ethereum token standards including ETH, ERC20, ERC721, ERC777, and Day. Interchain messaging, as well as deposit boxes and token clones, ensures the integrity and fidelity of token operations with the SKALE Network.

History, Funding, and Token behind SKALE

well.. history is important. Maybe not the most important when talking tech, but I still think it makes sense to understand where the project is coming from, to have a better view on the whole picture and how the project eventually got launched, so lets review the key facts.

History

Stan Kladko and Jack O’Holleran are both co-founders of the SKALE Network. All started with both of them (separately) looking to build decentralized application on Ethereum and both of them stuck with similar issues, scaling and creating an outstanding user experience that would not discourage user to onboard to decentralized platforms. Stan came up with the initial SKALE architecture and designed a new way to scale the various applications. During the initial collaborations with Jack, both realized there was a huge market potential to create a high-throughput layer that could work on top of Ethereum and enable scaling of dApps on top of Ethereum, something what was not possible before. We are in 2017, already back then the existing blockchains were in a desperate need of a scaling capabilities, because we also seen uptrend on the market with new decentralized applications like decentralized exchanges (DEXs), e-commerce or even beginning of Defi apps.

That’s when SKALE was born = Jan 01, 2018,

In January, Jack and Stand launched the SKALE Project, receiving support and seed funding from Signia Ventures and Floodgate.

Later on SKALE received support also from other major investors in the crypto space, like Winkelvoss Ventures, Hashed or Multicoin Capital.

You can review current list of supporters on the main page of the SKALE Network.

Intensive development and testing took nearly two years when SKALE announced the phased mainnet rollout plan.

Part of the plan was to hold a public SKL token sale via ConsenSys Activate platform. SKALE is the first project which has used Activate platform for utility token (platform that requires sale participants who purchase tokens to actively “prove their use” of the token for example via staking) before they will be allowed to transfer or redeem them.

Mainnet Phase 1

SKALE launched the 1st phase of its mainnet on Jun 30, 2020. This was an initial and restricted version (no support for staking or transferring tokens). Next we had a token sale via ConsenSys Activate in September 2020. Almost 4,000 participants from 90 countries took part in this sale and eventually mainnet Phase 2 got launched!

This 1st phase was limited to validators who have already participated in SKALE’s testnet and have gone through an onboarding process before.

Mainnet Phase 2

Phase 2 provided support for delegation and staking with over 46 validator organizations on Oct. 1, 2020.

Phase 2 launched with 135 active nodes on the network, managed by professional validators. At the time of launch, there were about 3,500 unique accounts staking across the network.

Mainnet Phase 3

After the 60-day Proof-of-Use period, the network turned into an open state and unlocked token transfers and exchanges.

The SKALE Network Phase 3, the final phase of mainnet launch, occurred on December 1, 2020, unlocking the tokens that completed the Proof-of-Use period via Consensys Activate.

It enabled any developers and validators to join the network and allowed exchanges to begin listing SKL.This was the moment tokens were listed on several major exchanges, including Binance, Huobi, and Uniswap.

Funding.

During the early rounds (Seed Round, SAFT1, SAFT2) The SKALE Network project raised a total of nearly $17 million from private investors to fund its early development. The funding includes a $9 million contribution from SKALE Labs.

Combined, about 25.5% of the max SKL supply were sold during this rounds, and are subject to investor lockup periods (ranging from 0.5year to 3 years) based on the individual SAFT agreements.

Consensys Activate’s Proof of Use for The SKALE token (SKL) was the first to launch on Activate, and that provided a platform for public distribution of tokens (X/2020) and participation in SKALE’s network.

This was also a major event not only for SKALE but also for ConsenSys, who has pioneered a new feature,Proof-of-Use:

• Proof of Use requires users who claim or purchase tokens during the launch to actively “prove use” before they’re allowed to transfer or redeem them for alternative purposes
• The participants may be required to delegate their purchased tokens for N days before being able to transfer them to other wallets, outside the network.
• Proof-of-Use is distributing tokens amongst stakeholders with aligned incentives, what is critical to minimize speculationand at the same time ensuring networks are effectively secured at launch.

regarding the public sale = 4k people from 90 different countries purchased168,553,209 SKL at $0.03 USD/SKL, all of them also helped secure the network ahead of SKALE’s Phase 2 mainnet launch on Oct. 1, 2020.

You can learn more details via Messari Crypto.

Remaining allocations SKALE has also allocated 10% of the max supply to the SKALE Foundation, the non-profit entity that was created to support the future development of the network. These tokens will vest over a 7-year period, after SKALE’s mainnet launch.

The team dedicated the remaining tokens to SKALE Labs, with the majority going to the founding team. The team’s tokens will remain locked for the first year and will then vest over the following three years.

Overview of SKL Token

SKL token is a utility token leverage to support application deployment as well as provide the security to the network.

With SKL tokens the developers can purchase independent blockchains,and run their dApps.

SKL tokens are also used for delegating and staking to secure the network. The will earn rewards for locking their tokens on the network.

SKL is Ethereum token following ERC777 token standard that is backward compatible with most popular ERC20 (all Ethereum apps with ERC20 support can also support ERC777 tokens because of ERC777 compatibility).

The SKALE token is a multi functional token, giving the right to

• work in the network as a validator or delegator
• access a share of the resources by deploying and renting an Elastic Sidechain or Elastic Blockchain
• For user SKL is used to play (a subscription-based) while rent these resources (computation, storage, bandwidth) for period of time
• Validators can stake SKL into the network to get the right to run nodes and earn fees and tokens via inflation.

Interesting difference for ERC777 vs ERC20 is that using SKL does not need to send tokens to a separate smart contract.They can share their secure delegation key with a staking provider and store the tokens in a cold or hot wallet.

Please study Token Economics paper for further details.

YES! Start Building!

ok, so we have talked a lot about how SKALE works, about its unique advantages, and how it fits into Ethereum ecosystem, so if you are interested here is the next step how to start building!

Just to encourage you => over 60 dApps are already running their smart contracts on SKALE’s elastic sidechains. These include games, content streaming services and other.

You will start easily if you are familiar with tools and libraries like Truffle, Web3.js or Remix, and overall EVM and Solidity environment

Truffle

Truffle the most popular way to deploy your smart contracts in Ethereum, but what is interesting now it can be also used to deploy your smart contracts into SKALE. Easily update your truffle configuration file (truffle.js) and deploy your smart contracts to SKALE.

Please see for more details = Truffle’s Configuration Documentation.

NodeJS

Familiar with NodeJS script? Your Smart contracts can be deployed with the use of web3.js as well.

On the SKALE Dev Website — you will find a simple script for using NodeJS and web3.

Please see for more details = Web3.js Getting Started Documentation.

Remix

Another familiar tools — smart contracts can be deployed with Remix and MetaMask. Check the Dev docs for details.

Please see for more details = Remix Documentation.

HOW TO STARTBUILDING?

1. Request a chain

If you do not have a SKALE Chain yet,request one by using the link.

2. Prepare your SKALE Chain

SKALE Chains on the DevNet will already be configured for you, and will not require any updates to get started with deploying your Smart Contracts.

In order to use your SKALE Chain, you will need to fund your wallet with the SKALE DevNet ETH tokens(use the SKALE Faucet to receive 0.5 test ETH)

3. Migrate Smart Contracts

As described above — the SKALE Network is able to process smart contracts in Solidity. Thanks to that migrating smart contracts from Ethereum is pretty easy and fast.

(minor smart contract updates may be needed to enable certain features in SKALE such as transferring money).

Here you will find Code Samples.

4. Send a Transaction

Once your smart contracts are deployed to your SKALE Chain, you should now test sending a new transaction with your existing connectors to Ethereum.

You will need to send the transactions directly to SKALE by connecting MetaMask or API Based Walletto your SKALE Chain.

Conclusions

The SKALE Network is just warming up. In my view that is one of these projects, that has been doing massive development work (both platform, protocol and ecosystem) with relatively little marketing around that fact, over the past 3 years, but now when the product is ready I think many people (both developers, validators, stakers, ecosystem partners) will get attracted to this ecosystem, and 2021 and beyond we will see massive growth within this platform.

You can do with SKALE all things which are offered by platforms like Polakdot (think scalability, security, eth-compatibility, interchain interoperability, low fees) so for many developers and builders the SKALE platform will be an attractive alternative.

Obviously the SKALE journey is just starting. As the SKALE Network matures, the project plans to introduce an on-chain governance with token-weighted voting on code changes and upgrade proposals (to allow active network participants, validators and delegators, to vote on protocol changes), so a lot of exciting things ahead of us.

Power to the people! => start building or at least join the movement to stay in the loop, and see what coming!

Andrzej