Blockchain Mainnet since 2020 · Open source
Everscale Owned by no one. Built by everyone.
best user experience, speed and scalability, and near-free transfers
- Block time
- ~2 s
- Average transaction fee
- <$0.001
- Threads per workchain, on demand
- 256
- Workchains the protocol can address
- 232
Why Everscale
Capacity that follows demand
Everscale splits the work across more shards as activity grows and merges them back when it calms down. Users get the same fast, cheap experience at any load.
-
Dynamic sharding
Workchains split into up to 256 threads as activity grows and merge back when it drops.
-
Near-free, fixed fees
Fees are fixed by the network config, not by demand. A transfer costs a fraction of a cent.
-
Extra currencies, built in
Up to 232 native currencies next to EVER, with no token contracts needed.
-
BFT finality
Catchain BFT consensus with staked validators. Once two-thirds agree, a block is final.
-
Paid storage
Contracts pay rent for their state, so abandoned data doesn't bloat the chain.
-
Asynchronous by design
Contracts are actors that talk through messages, so transactions run in parallel.
Architecture
One masterchain. Many workchains. Threads on demand.
Everscale shards both data and execution.
-
01
Masterchain
Consensus and finality. It holds the latest block hashes of every other chain, so the whole network agrees on a single state.
-
02
Workchains
Data shards. Each can have its own rules, virtual machine and native currency. The protocol can address up to 232 of them.
-
03
Threads
Execution shards inside a workchain, from 1 to 256, scaled up and down automatically with network activity.
The EVER coin
EVER powers every transaction
EVER is Everscale's native coin. It pays for everything the network does and secures the network through validator staking.
-
Gas
Pays for computation. A contract can accept the cost of an incoming external message itself, so apps can cover fees for their users.
-
Storage and messages
Pays rent for on-chain state and forwarding fees for messages sent between contracts.
-
Staking
Validators stake EVER to win seats in validator elections and earn rewards for producing blocks.
1 EVER = 1,000,000,000 nanoevers
Explore the chainFor developers
Solidity you know. A VM built for scale.
Write contracts in T-Sol, the EverVM dialect of Solidity, deploy and test them with a Hardhat-like framework. Calls contracts are messages, your code scales from day one.
pragma tvm-solidity >= 0.72.0;
contract Oracle {
mapping(uint32 => coins) public prices;
function getPrice(uint32 asset) public responsible returns (coins) {
return prices[asset];
}
}
contract Shop {
coins public lastPrice;
function quote(address oracle, uint32 asset) public {
Oracle(oracle).getPrice{callback: Shop.onPrice}(asset);
}
function onPrice(coins price) public {
lastPrice = price;
}
}
getPrice runs in its own transaction, maybe
on another thread, and replies through the invocation of onPrice callback.
Built in the open
The whole stack, on GitHub
The openever community maintains Everscale's core: the node, the virtual machine, the compiler and the networking layer. Read it, run it, improve it.
- ever-node Rust node and validator Rust
- ever-system-smcs System smart contracts EverVM
- ever-vm EverVM, the contract VM Rust
- ever-executor Executes transactions Rust
- tvm-solidity-compiler The T-Sol compiler C++
- ever-block Block and message types Rust
- ever-abi ABI encoding and decoding Rust
- ever-adnl Node-to-node networking Rust
$ git clone --recurse-submodules https://github.com/open-ever/ever-node.git
$ cd ever-node
$ cargo build --release
Supported by the open-source community
Everscale launched in 2020 as a network run by an open community of developers and validators, and it's still built that way. Pick your way in.