The SKALE Network is an Ethereum Native multichain network supporting high-throughput, low-latency, configurable byzantine fault-tolerant sidechains for Ethereum.
The SKALE Network has a set of validators securing the network. Validators provide computation power to the SKALE Network via deploying nodes. The collection of validators and the node(s) they spin up represent the entire validator network that performs work for SKALE Chains (an elastic sidechain or SKALE Chain). SKALE Chains in the network are operated by a group of virtualized sub-nodes selected from a subset of nodes (validators) in the network and are run on all or a subset (multi-tenancy) of each node’s computation and storage resources.
As each node in the network continues to participate in their assigned SKALE Chains, they’re awarded bounties based upon their performance at the end of each network epoch. Each node will be monitored by their peer nodes. When a SKALE Chain has reached the end of its lifetime, the resources (computation, storage) of its virtualized sub-nodes will be freed so that validator nodes may participate in newly created SKALE Chains.
Interested in helping the SKALE Network grow? Apply to become a SKALE Validator
Reliable connection to SKALE Network (low latency, high uptime)
Robust security practices and network architecture
Running latest SKALE Node software releases
Participation in governance (when applicable)
To encourage proper behavior amongst network participants, SKALE follows a Proof of Stake (POS) system whereby each node must stake a predetermined amount of SKALE tokens to be slashed at the citation of any activity not condoned by the network.
Activities not approved by the network include those which denote a failure to properly participate in each assigned SKALE Chain’s consensus, and maintain uptime and latency standards enforced by the Service Level Agreement (SLA).
Network SLAs are enforced through an algorithmic peer review system whereby each node is appointed 24 node peers to monitor and log their network participation, uptime, and latency. These metrics will be collected and averaged on the Ethereum mainnet to reward or slash nodes according to their respective performance.
To be added as a node to the SKALE Network, a prospective node must run the SKALE Admin, which manages all operations in the node and is installed with the [skale-node-cli](/validators/validator-cli). SKALE Admin evaluates the prospective node to ensure that it’s upholding network hardware requirements. If the prospective node passes this verification step, the SKALE Admin permits the node to submit a request to SKALE Manager to join the network. This request contains both the required network deposit as well as node metadata collected by the SKALE Daemon (for example IP address, port, public key, etc.).
Once the request has been submitted to SKALE Manager on Ethereum, SKALE Manager randomly defines the prospective node as a 'full node' or a 'fractional node' by assigning different sizes of SKALE Chains to the prospective node. Full nodes have all their resources utilized for a single sidechain, while fractional nodes participate in multiple sidechains (multi-tenancy).
If you have any issues you can save the logs using
skale logs dump command. It’s also useful to check logs from node-cli
skale cli logs from docker plugin
/var/log/docker-lvmpy/lvmpy.log if there are any issues.
Docker has an easy way of limiting other machine resources such as CPU, memory, and volume. These resources are configurable through the docker set up. Configuring machine resources such as CPU and memory are easy to complete via the docker set up; however, configuring volume requires a few more steps.
To assist with configuring volume, SKALE Labs introduced docker-lvmpy, a simple volume driver for Logical Volume Manager (LVM) volumes written in python to format and partition disk space per SKALE Chain. When a validator sets up a node through the CLI, SKALE Admin calls docker-lvmpy to format the external and unmounted volume. Each validator in the SKALE Network must provide a non-boot external disk space, which will be used to partition the volume by the SKALE Admin.
SKALE Admin calls docker-lvmpy to limit disk space per container (for example 20GB) and splits the volume in 1/128 size partitions. Once LVM splits the container and allocates the new space to the SKALE Chain, docker-lvmpy informs SKALE Admin that the disk is limited based on the configured SKALE Chain size.
Software Guard Extension (SGX) is an Intel® technology coprocessor ledger used for memory encryption and increasing the security of application code by storing encrypted data in the processor.
A SKALE sub-node connects to the SGX wallet server, and then the SGX wallet connects to the wallet enclave (BLS signatures and ETH keys). Keys stored in the processor can’t be taken out, and it can only be encrypted or decrypted through enclave. The key within the processor is secure in enclave, and hackers can’t hack the enclave and receive the key. Without SGX, human confirmation is necessary for transactions made in the SKALE Network. SKALE uses SGX for securing cryptographic keys by allowing nodes to connect hardware wallets without human interaction. SKALE uses BLS to sign blocks in consensus, and ECDSA is needed to validate regular Ethereum’s transactions. SKALE will have a separate wallet integration for ECDSA. SKALE will use Intel® SGX technology to store BLS signatures in the coprocessor level and let users automatically authorize transactions. Currently other than bare-metal servers, SGX is supported for these cloud providers.
(HSMs) Ledger Nano, or Trezor, can support ECDSA signatures but not BLS signatures, which are used by SKALE Consensus. We estimate that it will take a couple of years for these hardware devices to support BLS signatures at the throughput required on SKALE Network.
Advantages of SGX Wallet:
Helps developers protect sensitive data
Programmable for advanced crypto, such as BLS signatures
Doesn’t require validators to continually confirm transactions
All SKALE crypto (BLS/DKG) can be done through SGX wallet
SKALE will have two types of SGX operations:
Local (Secure): Wallet running on the same server as sub-node
Network: Sub-node talks to SGX wallet over the SKALE Network. The validator is responsible for securing the connection.