NEAR Contract Model

NEAR's Bet — Sharded Execution

NEAR Protocol is a sharded blockchain that splits the network into multiple 'shards' that process transactions in parallel. Originally launched with 4 shards (planned to scale to many more), the model lets the network scale horizontally without requiring all validators to process every transaction. Each shard maintains its own state; cross-shard transactions are handled via async message passing. This is a different scaling approach than rollups or single-chain throughput optimisation.

Contracts in Rust or AssemblyScript

NEAR contracts are written primarily in Rust (with some AssemblyScript support, though Rust is dominant). Contracts compile to WebAssembly and run inside a NEAR runtime. The contract model is account-based — each contract has an account, and contracts can call other contracts. Unlike Ethereum's synchronous calls, NEAR contract calls are async: when contract A calls contract B, A's execution finishes; B runs in a subsequent transaction block; A receives a callback with B's result.

Account Names — Human Readable

NEAR uses human-readable account names by default: alice.near, contract.alice.near, etc. The hierarchical structure (subaccounts under accounts) provides namespacing similar to DNS. This is a quality-of-life feature relative to Ethereum's 0x... addresses. Users can use any-account-name they want as long as it's available, similar to claiming an ENS name but native to the protocol rather than bolted on.

• Sharded execution: multiple shards process transactions in parallel
• Contracts written in Rust (primarily), compile to WebAssembly
• Cross-contract calls are async: callbacks rather than synchronous returns
• Human-readable account names baked in (alice.near format)