Bowen Wang, Head of Protocol at Pagoda (a key contributor to NEAR Protocol), likely discussed the transition from a sharded blockchain to sharded smart contracts during his ETHDenver 2025 talk on February 28, titled “From Sharded Blockchain to Sharded Smart Contracts.” As a central figure in NEAR’s development, Wang has deep insight into its Nightshade sharding model, which he’s articulated in talks and white papers.
Sharding is a scalability solution that divides a blockchain into smaller, parallel pieces called “shards.” In an unsharded blockchain (e.g., Bitcoin, early Ethereum), every node processes every transaction and stores the entire state—account balances, smart contracts, and transaction history. This creates a bottleneck as the network grows, capping throughput (e.g., Ethereum’s ~15 transactions per second). Sharding fixes this by splitting the workload.
NEAR’s Nightshade model, launched in 2021 and refined since, shards the network into manageable chunks. Each shard handles its own subset of transactions and state, processed by a subset of validators. Think of it like splitting a library into sections—each librarian (validator) manages only their section (shard), not the whole collection. This parallelism boosts capacity; NEAR aims for thousands of transactions per second versus Ethereum’s dozens.
Wang has emphasized NEAR’s “fully sharded” design, rolled out in August 2023 (version 9.2.0). Here’s how it works at the blockchain level:
Division: The network splits into shards (e.g., six in early 2025, expanding to eight per Wang’s ETHDenver remarks). Each shard has its own state—think accounts A-M on Shard 1, N-Z on Shard 2.
Validators: Validators are randomly assigned to shards each block via an on-chain randomness beacon. This prevents collusion and ensures security. Each validator tracks at most one shard at a time. Parallel Processing: Shards process transactions independently. Chunk producers (a subset of validators) bundle transactions into “chunks” per shard, while validators verify them. These chunks update the shard’s state, and a main chain (the “Beacon” in Ethereum’s terms, or NEAR’s core) coordinates.
By 2025, NEAR’s sharding includes “stateless validation” (highlighted in a January 2024 X post by NEAR Protocol). Traditionally, validators store a shard’s full state in memory, which balloons as usage grows, slowing reads. Stateless validation offloads state storage to chunk producers, who distribute “state witnesses” (proofs of state changes) to validators. Validators check these proofs without holding the full state, slashing hardware demands and enabling more nodes to participate—crucial for decentralization.
From Sharded Blockchain to Sharded Smart Contracts
Sharding the blockchain alone isn’t enough if smart contracts—self-executing programs driving DeFi, NFTs, etc.—can’t leverage it. Wang’s talk likely focused on this leap: sharding smart contracts to match the blockchain’s parallelism. Here’s how NEAR does it, and what Wang probably explained:
State Sharding: In NEAR, each shard owns a slice of the global state (e.g., specific account ranges). Smart contracts live in this state—say, a DeFi contract on Shard 1 controls accounts A-M. When a transaction calls that contract, it’s routed to Shard 1, processed locally, and updates only that shard’s state. This avoids cross-shard chatter for simple calls.
Execution Sharding: Smart contracts execute within their shard. NEAR’s runtime (like Ethereum’s EVM) runs contract code on the assigned shard’s validators. Since shards operate in parallel, multiple contracts across shards execute simultaneously—e.g., a swap on Shard 1 and an NFT mint on Shard 2 happen at once.
Cross-Shard Challenges: Real-world apps often span shards. If a user on Shard 1 swaps tokens with a contract on Shard 2, cross-shard communication kicks in. NEAR uses a “receipt” system: Shard 1 sends a message (receipt) to Shard 2, which processes it in the next block. Wang likely stressed NEAR’s one-block split capability—shards can subdivide in a single block, dynamically balancing load without halting the network.
Scalability Payoff: Sharded contracts unlock massive throughput. A single shard might handle 100 TPS, but with eight shards, NEAR could hit 800 TPS or more, all while keeping smart contracts functional. Wang’s X posts (e.g., February 2024) note latency dropping to 400 milliseconds, a boon for contract-heavy apps.
Wang likely underscored NEAR’s edge over Ethereum, which pivoted from full sharding to rollups (Layer 2s) plus danksharding for data availability. NEAR’s base-layer sharding, he’d argue, aligns incentives better—L2s like Arbitrum have their own tokens, diluting Ethereum’s ETH value, while NEAR’s shards unify under one protocol. Posts on X (e.g., NEAR’s February 2025 ETHDenver recap) suggest he demoed this with real metrics—eight shards live, latency slashed, and smart contracts humming in parallel.
In short, sharding works by splitting the blockchain’s state and workload into parallel shards, then extending that parallelism to smart contracts. NEAR’s Nightshade, per Wang, makes this practical with stateless validation, fast splits, and cross-shard receipts, aiming for a scalable, contract-ready future. Want me to drill into a specific part—like stateless validation or cross-shard mechanics?
Remittix: The Altcoin Set to 10x with Real-World Impact