StarkNet

StarkNet is a Validity Rollup (ZK-Rollup) that batches thousands of transactions off-chain into a single cryptographic proof. This STARK proof is then posted to Ethereum L1, where it is verified. This architecture provides:

• Scalability: Massive throughput by moving computation off-chain.
• Security: Inherits Ethereum's security via cryptographic verification.
• Data Availability: Transaction data is posted on-chain, allowing anyone to reconstruct state.

Scalable Transparent Argument of Knowledge (STARK) proofs are the core cryptographic primitive. They are:

• Scalable: Proving time grows quasi-linearly with computation size; verification is extremely fast.
• Transparent: Do not require a trusted setup, relying on publicly verifiable randomness.
• Post-Quantum Secure: Based on hash functions, believed to be resistant to quantum computer attacks.
• High Throughput: Enable proving the validity of large batches of transactions efficiently.

StarkNet's network roles are separated for efficiency and decentralization:

• Sequencer: Orders transactions, executes them, and produces a state diff. Currently operated by StarkWare, with a path to decentralization.
• Prover: Generates the STARK proof for the state transition. This is a computationally intensive task performed by specialized nodes. This separation allows the sequencer to be fast and the prover to work in parallel, optimizing the overall system latency and cost.

StarkNet introduces flexible data availability models, allowing developers to choose security vs. cost trade-offs:

• Rollup Mode (On-Chain Data): Full transaction data is posted to Ethereum L1. Highest security, inheriting Ethereum's data availability.
• Validium Mode (Off-Chain Data): Only proofs are posted to L1; data is held by a Data Availability Committee (DAC) or validators. Lower fees, with different trust assumptions. This hybrid system, sometimes called Volition, lets users or dApps select the appropriate model per transaction.

Account abstraction is built into the protocol's design. Every account on StarkNet is a smart contract account, enabling:

• Sponsored Transactions: A third party can pay fees for a user.
• Custom Security: Multi-signature schemes, social recovery, and transaction rate-limiting.
• Signature Agnosticism: Support for any signature scheme (e.g., secp256k1, EdDSA).
• Atomic Multi-Operations: Bundle multiple actions into a single transaction. This removes the distinction between Externally Owned Accounts (EOAs) and contracts.

The STRK token is central to StarkNet's decentralized governance and fee mechanism. Its primary functions include:

• Transaction Fee Payment: Users can pay network fees in STRK (alongside ETH).
• Protocol Governance: STRK holders govern upgrades via the StarkNet DAO.
• Staking for Provers: Securing the network by staking to become a prover. This economic model aligns incentives for users, developers, and network operators.

StarkNet has native account abstraction, meaning all accounts are smart contract accounts. This eliminates the Externally Owned Account (EOA) model, enabling:

• Social Recovery & Multi-sig wallets by default.
• Sponsored transactions where dApps pay user fees.
• Custom security logic and signature schemes (e.g., passkeys). This feature is a core architectural choice, fostering user experience innovation.

Scalability is driven by STARK proofs generated via SHARP (Shared Prover). This system batches transactions from multiple StarkNet chains and dApps into a single proof, which is then verified on Ethereum L1. Key benefits:

• Massive cost amortization across the ecosystem.
• Proof aggregation for multiple applications.
• Enables Volition and Validium data availability modes for further scaling.

Users have direct recourse to Ethereum L1 if the StarkNet sequencer fails. These are critical liveness guarantees:

• Forced Inclusion: Users can submit transactions directly to an L1 contract, forcing them into the L2 sequence after a delay, bypassing a censoring sequencer.
• Forced Withdrawal: A mechanism to withdraw assets directly via L1 if the L2 is non-functional, though it requires a longer challenge period.

The permissionless prover network is secured by economic incentives:

• Proof Fee Market: Provers compete to generate proofs for sequenced batches, earning fees paid in STRK.
• Censorship Resistance: Since any prover can generate a proof for any batch, it prevents a single entity from censoring state updates by refusing to prove them. The system's security assumes at least one honest prover exists in the network.

StarkNet operates as a ZK-Rollup, a Layer 2 scaling solution that bundles thousands of transactions off-chain, generates a single cryptographic proof (a STARK proof), and posts it to the Ethereum mainnet for verification. This architecture provides:

• Ethereum-level security: Validity is enforced by Ethereum's consensus.
• Massive scalability: Reduces cost per transaction by orders of magnitude.
• Fast finality: Funds can be withdrawn with the security of L1 after the proof is verified.

These are critical off-chain components of the StarkNet network:

• Sequencer: Orders and executes transactions, producing a new state root. It is currently operated by StarkWare but is planned to be decentralized.
• Prover: Generates a STARK proof attesting to the correctness of the state transition performed by the Sequencer. This proof is then posted to Ethereum.

The StarkNet Operating System is a conceptual layer that defines the rules for the network. It is not an OS in the traditional sense but a set of protocols and components that manage:

• Execution: The Cairo VM that runs contract bytecode.
• Proving: The system for generating validity proofs for state updates.
• State & Storage: The structure of the global state and its commitment on L1.
• Messaging: The L1 <-> L2 communication protocol.

These are data availability modes related to StarkEx, the engine powering application-specific StarkNet apps (dYdX, Sorare). They represent a spectrum of trade-offs between cost and security:

• Validium: Data availability is kept off-chain by a committee, offering the lowest fees but introducing a data availability trust assumption.
• Volition: A hybrid mode where users can choose, per transaction, whether their data goes on-chain (ZK-Rollup) or off-chain (Validium).