NEAR Protocol: Sharded High-Speed L1 with Chain Abstraction
NEAR Protocol is a sharded Proof-of-Stake L1 launched on 2020-04-22, built around Nightshade — a state-sharded execution model that today runs 9 shards in parallel with 600ms block times and 1.2-second deterministic finality. Beyond raw throughput, NEAR is one of the few L1s that has shipped chain abstraction primitives (chain signatures, the 1Click intents API) directly at the protocol layer, letting accounts hold and sign for assets on Bitcoin, Ethereum and other chains from a single human-readable account ID such as alice.near. With $141,467,669 of on-chain TVL concentrated in Rhea Finance, LiNEAR liquid staking and Rhea DEX, NEAR is positioned as the chain-abstraction layer of the high-speed L1 cohort.
If you are evaluating where to deploy a consumer-facing dApp, NEAR offers a combination most peers cannot match: human-readable account IDs (alice.near instead of 0x… hex), sub-second finality (1.2 s), and a native chain-abstraction stack that lets one NEAR account control derived addresses on Bitcoin, Ethereum, Cosmos and beyond via MPC chain signatures. Compared to Solana's Sealevel SVM, NEAR runs a WASM-based NEAR VM (Wasmer engine) with Rust and JS/TS SDKs, making the developer onboarding closer to mainstream backend stacks. Compared to Aptos and Sui — both Move-based and aimed at high throughput — NEAR's differentiator is sharding (Nightshade 2.0 stateless validation, shipped 2024-08-01) and the embedded 1Click intents API that lets wallets and dApps express cross-chain intent without manually wiring bridges. The native token NEAR (CMC ID 6535) secures the network via staking on Doomslug + Nightshade, and is also used to pay storage rent (NEP-145) and gas. The chain is best suited to teams building wallet-abstraction products, intent-based DeFi, AI-agent transaction layers, and cross-chain consumer apps where the friction of seed phrases, hex addresses and manual bridging is the primary user-experience blocker.
About NEAR
NEAR Protocol launched its mainnet on April 22, 2020, after several years of research led by Illia Polosukhin and Alex Skidanov around the question of how to scale a general-purpose blockchain through dynamic state sharding rather than rollups or monolithic high-throughput execution. The genesis design was already sharded in concept, but the network shipped sharding in phases — initially with a unified state, then progressing through Simple Nightshade, Phase 1, Phase 2 and finally Nightshade 2.0 with stateless validation on August 1, 2024. The mainnet today runs 9 production shards in parallel, each processing transactions concurrently, with cross-shard receipts handled asynchronously by the runtime. This makes NEAR architecturally distinct from Solana, Aptos and Sui — all of which scale through faster single-shard execution rather than horizontal state partitioning.
Consensus on NEAR combines Doomslug, a fast block-production protocol that provides practical finality after a single confirmation, with Nightshade for shard-state validation and finalization. Doomslug gives the chain its 600-millisecond block time and 1.2-second finality figure — competitive with Sui's 0.64 s and Aptos's 0.65 s, but achieved through a different architectural path (sharding plus a Doomslug-style two-step block producer rotation, rather than DAG-based BFT). NEAR transitioned to optimistic block processing on May 1, 2025, which is the upgrade that drove block times down to 600 ms while preserving 1.2 s deterministic finality. Validators are selected through staking auctions and must be re-elected each epoch, with stake-weighted seat assignment to shards.
On the execution side, NEAR runs the NEAR VM, a WebAssembly runtime built on Wasmer. Smart contracts compile from Rust, AssemblyScript or JavaScript (via JS-SDK / near-sdk-js) down to WASM bytecode, which gives the chain a meaningfully wider developer pool than chains restricted to a custom language like Move (Aptos, Sui) or Solidity (most EVM peers). The token model is governed by NEP-141 for fungible tokens, NEP-171 for non-fungible tokens, and NEP-145 for storage staking — a distinctive economic primitive where contracts pay an upfront NEAR deposit proportional to the on-chain state they consume, refundable when state is freed. This binds storage cost to actual usage rather than purely to gas-time pricing.
Economically, NEAR uses an inflationary issuance model targeting roughly 5% annual issuance, of which 90% rewards validators and 10% goes to the protocol treasury. A portion of transaction fees is burned, providing a deflationary counter-pressure when network demand is high. The most distinctive economic and product layer, however, is chain abstraction: chain signatures let a NEAR account derive and sign for an address on any external chain (Bitcoin, Ethereum, Cosmos, etc.) via threshold-MPC, while the 1Click intents API lets wallets and applications submit a high-level intent ("swap X on chain A for Y on chain B") that solver networks fulfill. This positions NEAR less as a competitor to Solana on raw TPS, and more as the routing and identity layer for cross-chain consumer applications.
NEAR technical parameters
NEAR's technical identity rests on three pillars: Doomslug + Nightshade 2.0 consensus, WASM-based NEAR VM execution, and chain abstraction primitives built directly into the protocol. The published parameters are 0.6 s block time, 1.2 s finality, ~60 typical TPS today, and a theoretical ceiling of 100,000 TPS as shards are added. These numbers only become meaningful when read against what they enable and what trade-offs they require — which is what the next two sections unpack.
| Consensus | Doomslug + Nightshade 2.0 sharding (PoS) |
|---|---|
| VM | NEAR VM (WASM, Wasmer-based) |
| Block time | 600 ms |
| Finality | 1.2 s |
| TPS | 60 typical / 100k max |
| Gas token | NEAR |
| Launched | 2020-04-22 |
| Token standard | NEP-141 (FT) / NEP-171 (NFT) / NEP-145 (storage) |
| Address | human-readable account IDs (e.g. alice.near) / hex implicit accounts |
Consensus mechanism
Doomslug is best understood as a two-stage block-production protocol: a block producer issues a block, validators sign endorsements, and after the second confirmation the block is considered final under the assumption that at least one honest validator is online — a weaker liveness assumption than classical BFT but one that yields very fast practical finality. Nightshade 2.0, shipped on 2024-08-01, layers stateless validation on top: each shard's state transition is validated by a rotating subset of chunk-only validators who do not need to hold the entire shard state, just the proofs and witnesses for the chunks they validate. This is what lets NEAR keep 9 shards running concurrently without each validator needing the full chain state, and it is the architectural reason NEAR can target horizontal scaling rather than vertical. The optimistic block processing upgrade of 2025-05-01 further pipelined block production, dropping block time to 600 ms and pinning deterministic finality at 1.2 s. The trade-off is complexity — cross-shard transactions are async via receipts rather than atomic — but for application-layer logic that operates within a single shard or tolerates a single-block delay, the effective throughput compounds across shards.
Performance context
60 TPS typical against a 100,000 TPS theoretical ceiling sounds modest in isolation, but the right comparison is per-shard headroom. NEAR's 9-shard configuration means real-world load gets parallelized rather than queued, and shards can be added as demand requires. Against high-speed L1 peers, NEAR's 1.2 s finality sits between Sui (0.64 s) and Solana (12.8 s probabilistic), and ahead of TON (1 s) and Monad (1 s, recently launched 2025-11-24). Compared to EVM L1s, NEAR's finality is 640x faster than Ethereum's 12.8-minute economic finality and 47x faster than Tron's 57 s. For end-user experience this means a NEAR transaction is irreversible roughly a second after submission — fast enough that wallets and dApps can give users an unambiguous "done" state without the multi-block waiting UI that Bitcoin- and Ethereum-class chains require.
NEAR ecosystem map
NEAR's on-chain TVL stands at $141,467,669, concentrated heavily in three Rhea Finance products and the LiNEAR liquid staking protocol — together accounting for over $191M when liquid-staking variants are aggregated (note the apparent overlap reflects how Rhea now hosts both lending and liquid staking, and how LiNEAR's stNEAR also flows into Rhea Lend collateral). The ecosystem is narrower than Solana ($4.71B TVL) or Sui ($434M) but is anchored by a coherent Rhea-Finance-centric DeFi stack and a strong native staking economy.
Lending
Rhea Lend ($85,285,184 TVL) is by a wide margin the largest single protocol on NEAR, providing money-market lending across NEAR, USDC, ETH and stNEAR. Its dominance — roughly 60% of total chain TVL — means lending is the structural anchor of NEAR DeFi today.
Infrastructure
LiNEAR Protocol ($55,771,616 TVL) and Rhea LST ($23,871,139 TVL) together form a liquid-staking layer worth roughly $79.6M. Liquid-staked NEAR derivatives feed directly into Rhea Lend as collateral, creating a tight DeFi loop similar to Lido-Aave on Ethereum.
DEX
Rhea Dex ($26,505,851 TVL) is the primary on-chain DEX, complemented by Jumbo Exchange ($625,765 TVL). Order flow is materially smaller than Solana's Jupiter or Sui's Cetus, reflecting that NEAR's chain-abstraction strategy routes a meaningful share of swap volume through the 1Click intents API and external solver networks rather than purely native DEXs.
Wallet
HERE Wallet ($665,907 staking TVL) is the leading mobile-native NEAR wallet, alongside MyNearWallet, Meteor and Sender. All support the human-readable account ID model (alice.near) and increasingly expose chain-signature features for managing Bitcoin and Ethereum addresses derived from a NEAR account.
Infrastructure
Chain signatures and the 1Click intents API are not standalone protocols but protocol-layer primitives. They let any NEAR account derive ECDSA / Ed25519 keys via threshold MPC and sign for external chains — turning NEAR into a multichain custody layer. This is the differentiator most TVL aggregators do not capture in a single number.
Bridge
Native bridging to NEAR historically went through Rainbow Bridge (Ethereum) and Allbridge / Wormhole for broader connectivity. Today the chain-abstraction stack is increasingly replacing classical lock-and-mint bridging for asset movement, since intent-based cross-chain swap routes can settle without minting a wrapped representation on NEAR.
| # | Protocol | Category | TVL |
|---|---|---|---|
| 1 | Rhea Lend | Lending | $85.29M |
| 2 | LiNEAR Protocol | Liquid Staking | $55.77M |
| 3 | Rhea Dex | Dexs | $26.51M |
| 4 | RHEA LST | Liquid Staking | $23.87M |
| 5 | HERE Wallet staking | Liquid Staking | $665.91K |
| 6 | Jumbo Exchange | Dexs | $625.77K |
| 7 | Phoenix Bonds | Yield Aggregator | $439.48K |
| 8 | DewFinance | Onchain Capital Allocator | $239.75K |
NEAR vs peers
Within the high-speed L1 cohort — Solana, Aptos, Sui, Monad, Berachain, Hyperliquid L1, TON and NEAR — every chain is selling sub-2-second finality, but the architectural strategies and ecosystem footprints diverge sharply. The numbers below are pulled directly from the comparison dataset.
| Chain | Block | Finality | TPS | TVL |
|---|---|---|---|---|
| Solana | 400 ms | 12.8 s | 3k | $4.71B |
| Aptos | 150 ms | 650 ms | 800 | $191.04M |
| Sui | 400 ms | 640 ms | 1.5k | $434.58M |
| Monad | 400 ms | 1 s | — | $348.38M |
| Berachain | 2 s | 2 s | — | $55.48M |
| Hyperliquid L1 | 70 ms | 70 ms | — | $1.51B |
| TON | 400 ms | 1 s | 17 | $67.06M |
| Nearcurrent | 600 ms | 1.2 s | 60 | $141.47M |
Comparison insights
- Finality ranking: Hyperliquid L1 leads at 0.07 s (a HyperBFT trade-off optimized for an internal order book), followed by Sui at 0.64 s, Aptos at 0.65 s, TON at 1 s, Monad at 1 s, NEAR at 1.2 s, Berachain at 2 s, and Solana at 12.8 s. NEAR is in the middle of the pack on raw finality, but is the only entry in this cohort using state sharding rather than monolithic execution.
- TVL ranking: Solana dominates at $4.71B, followed by Hyperliquid L1 at $1.51B and Sui at $434M. NEAR's $141.47M sits ahead of TON ($67M) and Berachain ($55M) but materially behind Aptos ($191M) and Monad ($348M, despite Monad launching only 2025-11-24). The takeaway is that NEAR's TVL/finality ratio is among the lowest in the cohort — capital is choosing Solana, Sui and Monad first for high-throughput DeFi.
- VM diversity: This category is the most VM-heterogeneous in the dataset. Solana runs Sealevel (SVM), Aptos and Sui run Move variants, Monad and Berachain run EVM, TON runs TVM, and NEAR runs WASM via the NEAR VM. NEAR's WASM choice means the developer language pool is the broadest (Rust, AssemblyScript, JS/TS) but the contract migration story from EVM is weaker than Monad's bytecode-compatible EVM.
- Throughput ceiling: Hyperliquid L1 claims 200,000 max TPS, Aptos 160,000, NEAR 100,000, TON 104,715, Solana 65,000, Monad 10,000. Typical TPS is more honest: Solana 3,000, Sui 1,500, Aptos 800, NEAR 60, TON 17, Monad / Berachain not yet publicly benchmarked. NEAR's headroom is in adding shards rather than pushing a single execution lane harder.
- Architectural niche: NEAR is the only chain in the cohort that has shipped a protocol-layer chain-abstraction stack (chain signatures + 1Click intents API). For consumer apps that need to control assets across Bitcoin, Ethereum, Cosmos and others from one account, NEAR is structurally differentiated. Peers compete on raw speed; NEAR competes on cross-chain UX.
NEAR timeline
NEAR's mainnet went live on April 22, 2020, after the NEAR Foundation and the founding team spent nearly three years on sharding research. The 2020 launch deliberately shipped a single-shard configuration first — a pragmatic decision to prove the consensus layer (Doomslug) before activating Nightshade sharding. Over 2021 and 2022 the chain progressed through Simple Nightshade and Phase 1, gradually splitting state into multiple shards. The most consequential upgrade in the chain's history was Nightshade 2.0 on August 1, 2024, which introduced stateless validation — letting chunk-only validators verify shard state transitions without storing the full shard state. This was the architectural unlock that made horizontal scaling practical rather than just theoretical. On May 1, 2025, optimistic block processing went live, dropping block times to 600 ms and pinning deterministic finality at 1.2 seconds — the figures the chain runs today. Unlike Solana, which suffered multiple multi-hour mainnet outages between 2021 and 2023, or BSC, which lost roughly $570M in the October 2022 cross-chain bridge exploit, NEAR has not experienced a comparable headline outage or protocol-level exploit since mainnet launch — though it has had isolated validator-software incidents, and the broader NEAR ecosystem has seen application-layer hacks (notably on early bridge contracts). The Rainbow Bridge to Ethereum operated for years as the canonical asset on-ramp; over 2024-2025 the strategic focus shifted to chain signatures and the 1Click intents API, repositioning NEAR from a sharded execution chain to a chain-abstraction layer. NEAR's history is shorter on drama than Solana's or BSC's, and the trade-off is that on-chain TVL has grown more slowly — $141.47M today versus Solana's $4.71B.
- 2020-04-22launchMainNet Genesis
- 2024-08-01upgradeNightshade 2.0 — stateless validation
- 2025-05-01upgradeOptimistic block processing — 600ms blocks, 1.2s finality
Developer reference
For developers, the operational facts are: official mainnet RPC at https://rpc.mainnet.near.org, primary block explorer at nearblocks.io, full documentation at docs.near.org. Accounts use a dual format — human-readable account IDs like alice.near (top-level accounts are issued under .near or named-account registries) and 64-character hex implicit accounts derived from a public key. NEP-141 governs fungible tokens, NEP-171 non-fungible tokens, NEP-145 storage staking. The contract toolchain centers on Rust (via near-sdk-rs) and JavaScript/TypeScript (via near-sdk-js), both compiling to WASM bytecode executed by the Wasmer-based NEAR VM. Wallet integrations are well-supported across MyNearWallet, Meteor, HERE Wallet, Sender, Ledger and WalletConnect. The most differentiated SDKs are the chain-signatures library and the 1Click intents SDK — both let dApps issue cross-chain transactions and intents without leaving the NEAR runtime, and both are first-class targets if you are building consumer or cross-chain swap UX on top of NEAR.
Assets swappable on NEAR
Grouped by category. Click any asset to open its swap page for a live quote.
DeFi assets
1 assets
Memecoins
4 assets
RWA · Stock tokens
15 assets
NEAR settle-time comparison
Shorter bars mean faster confirmations. Real settle time also depends on network congestion — figures are indicative.
NEAR asset coverage comparison
Longer bars mean more assets are swappable on that chain.
Popular swap routes involving NEAR
Routes below reflect actual user preference. Click to jump straight to the swap page.
NEAR FAQ
01Is NEAR Protocol decentralized?
NEAR runs Proof-of-Stake with permissionless validator participation — anyone meeting the seat-price threshold (set by stake auction each epoch) can become a block producer or chunk producer. Validators are stake-weighted and rotated across the 9 shards via Nightshade 2.0. The validator set is smaller than Ethereum's (hundreds rather than ~1M staking keys), but the chain is non-custodial: no central party controls block production or can freeze accounts.
02What is NEAR's finality time?
1.2 seconds deterministic finality, achieved through Doomslug's two-step confirmation. Block time is 600 milliseconds since the optimistic block processing upgrade of May 1, 2025. This is meaningfully faster than Ethereum (12.8 minutes economic finality) and Solana (12.8 s probabilistic finality), and broadly competitive with Sui (0.64 s) and Aptos (0.65 s).
03What consensus mechanism does NEAR use?
Doomslug for block production and finalization, combined with Nightshade 2.0 for state sharding and stateless validation. Doomslug provides single-confirmation practical finality under standard liveness assumptions; Nightshade 2.0 partitions execution across 9 shards in parallel, with rotating chunk-only validators verifying shard state via succinct witnesses rather than holding full state. It is a Proof-of-Stake design, not Proof-of-Work.
04What is NEAR's typical TPS and what is the ceiling?
Typical throughput today is around 60 TPS in normal conditions, with a theoretical ceiling near 100,000 TPS as shards are added. The 60-TPS figure reflects current 9-shard real-world demand, not an architectural limit — NEAR scales horizontally by adding shards rather than pushing a single execution lane harder, which is the structural difference vs Solana, Aptos and Sui.
05What are chain signatures on NEAR?
Chain signatures are a protocol-layer primitive that lets a single NEAR account derive and sign for addresses on external chains (Bitcoin, Ethereum, Cosmos and others) via threshold-MPC signing run by NEAR validators. In practice, a NEAR account like alice.near can custody a Bitcoin UTXO or an Ethereum ERC-20 address without using a wrapped representation — the signature is produced by NEAR's MPC network. Together with the 1Click intents API, this is NEAR's distinctive bet on chain abstraction.