Starknet is a Layer 2 (L2) scaling solution designed to enhance the scalability of the Ethereum blockchain, addressing one of the most persistent challenges in distributed ledger technology: achieving high transaction throughput with low fees while preserving security and decentralization [1]. Operating as a validity rollup, also known as a zk-rollup, Starknet executes transactions off-chain and submits compact cryptographic proofs of their validity to the Ethereum mainnet, significantly reducing congestion on the base layer [2]. At the core of its technology is the use of zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge), which allow thousands of transactions to be batched into a single verifiable proof, enabling throughput of thousands of transactions per second and slashing gas costs for users [3]. This architecture makes Starknet a powerful platform for deploying complex decentralized applications (dApps) across sectors such as DeFi, NFTs, Web3 gaming, and privacy-preserving financial systems. The network is powered by its native utility token, STRK, which is used for paying transaction fees, participating in decentralized governance, and securing the network through proof-of-stake staking [4]. Starknet’s development stack centers around Cairo, a Turing-complete programming language specifically designed for generating zero-knowledge proofs efficiently, and supported by tools like Starknet.js, Scarb, and Starknet Foundry [5]. The network ensures trustless security through cryptographic validity proofs verified on Ethereum, while maintaining data availability on-chain or via Volition mode. Starknet also supports interoperability through bridges like StarkGate and enables advanced features such as account abstraction and private token transfers via the STRK20 standard [6]. With a rapidly expanding ecosystem—hosting over 190 projects by late 2024—and ongoing technical upgrades like the S-two prover and EIP-4844 integration, Starknet is positioned as a leading ZK-Rollup in the Ethereum scaling landscape [7].

Technology and Architecture

Starknet is a Layer 2 (L2) scaling solution for Ethereum, designed to overcome the limitations of blockchain scalability by enabling high transaction throughput and low fees without compromising security or decentralization [1]. Its architecture is built around the principles of validity rollups, also known as zk-rollups, which process transactions off-chain and submit cryptographic proofs of their validity to the Ethereum mainnet. This approach drastically reduces congestion on Ethereum’s base layer while maintaining trustless security through on-chain verification [2]. At the core of this system are zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge), advanced zero-knowledge proofs that allow thousands of transactions to be batched into a single, succinct proof, enabling throughput of thousands of transactions per second and significantly reducing gas costs for users [3].

Core Mechanism: zk-STARKs and Validity Proofs

The fundamental innovation behind Starknet's architecture lies in its use of zk-STARKs, a form of zero-knowledge proof that provides strong cryptographic guarantees of computation correctness. Unlike other proof systems, zk-STARKs do not require a trusted setup, making them transparent and resistant to potential backdoors or collusion during initialization [11]. This property enhances trustlessness and aligns with Starknet’s goal of full decentralization. Furthermore, zk-STARKs are quantum-resistant, relying on collision-resistant hash functions rather than elliptic curve cryptography, which makes them more future-proof compared to alternatives like zk-SNARKs [12].

Each transaction batch executed off-chain is verified through a validity proof—a compact cryptographic attestation generated by a prover and checked on Ethereum by a smart contract known as the verifier. This process ensures that only valid state transitions are accepted, preserving the integrity of the network. Because the verifier does not re-execute the computations but only checks the mathematical soundness of the proof, the computational burden on Ethereum is minimal, enabling massive scalability [13].

Proof Generation, Aggregation, and Verification Pipeline

The lifecycle of a Starknet transaction involves three key stages: generation, aggregation, and verification of zk-STARK proofs. When a program written in the Cairo programming language is executed on the Cairo Virtual Machine (CairoVM), it produces an execution trace—a detailed record of each computational step. This trace is then transformed into an algebraic problem via Interactive Arithmetic Representation (AIR), which encodes the correctness of the computation as polynomial constraints [14].

A prover then generates a zk-STARK proof demonstrating that these constraints are satisfied. To optimize efficiency, Starknet employs SHARP (Shared Prover), an aggregator that combines multiple individual proofs into a single composite proof. This recursive aggregation reduces the number of on-chain verifications required, significantly lowering gas costs and improving throughput [15]. Future enhancements like STARKPack aim to further compress and accelerate this process [16].

Finally, the aggregated proof is submitted to Ethereum, where a STARK verifier contract confirms its validity. This contract uses the FRI (Fast Reed-Solomon Interactive Oracle Proof) protocol to verify the low-degree nature of the polynomials involved, ensuring the proof is both correct and succinct [17]. Once validated, the new state root is accepted, finalizing the batch of transactions.

Execution Model and Scalability Enhancements

One of Starknet’s distinguishing architectural features is its support for parallel execution of transactions. Unlike Ethereum, where transactions are processed sequentially, Starknet can execute independent operations simultaneously, dramatically increasing throughput. This capability was enhanced with the Bolt upgrade in 2024, which reduced transaction confirmation times to approximately 2 seconds [18]. Combined with efficient block packing and data compression, these optimizations enable Starknet to achieve sustained throughput of over 100 transactions per second, with potential for much higher performance in the future [19].

To further reduce costs, Starknet leverages EIP-4844 (Proto-Danksharding), which introduces cheaper data blobs for storing transaction data on Ethereum. This innovation has slashed Layer 1 data availability costs to around $0.017 per transaction, making Starknet one of the most cost-efficient L2 solutions [20]. Additionally, Volition mode allows users to choose between on-chain and off-chain data availability, offering flexibility in balancing privacy, cost, and transparency [21].

Security and Trustless Guarantees

Starknet ensures the correctness of state transitions through its validity rollup model. Every state update must be accompanied by a zk-STARK proof, which mathematically guarantees that the new state follows from valid transactions. This eliminates the need to trust any single operator or sequencer, as even a malicious actor cannot submit an invalid state without being caught by the verifier [2]. The system also implements hierarchical checkpoints to accelerate finality, allowing faster confirmation of transaction outcomes without sacrificing security [23].

Data availability is ensured by publishing transaction data either directly on Ethereum or through external data availability layers, depending on the mode used. This prevents censorship and ensures that any node can reconstruct the full state of the network. Moreover, Starknet includes an escape hatch mechanism, allowing users to forcibly withdraw funds from L2 to L1 in case of sequencer censorship or failure, reinforcing its censorship resistance [24].

Privacy Architecture and Compliance

Starknet integrates advanced privacy features while maintaining compliance with regulatory requirements. The STRK20 standard enables private transfers of ERC-20 tokens by hiding sender, receiver, and amount within zero-knowledge proofs, while still allowing selective disclosure to auditors or regulators [6]. Similarly, the integration of Nightfall, developed by EY, supports confidential institutional transactions on public blockchains, combining privacy with auditability [26].

These capabilities are underpinned by the inherent privacy properties of zk-STARKs, which reveal only the validity of a computation, not its inputs or intermediate steps. This allows for privacy-preserving smart contracts and enables use cases in regulated finance, healthcare, and identity systems where confidentiality is paramount [27].

Interoperability and Cross-Layer Communication

Starknet supports bidirectional messaging between Layer 1 (Ethereum) and Layer 2 through its asynchronous messaging protocol. Contracts on Ethereum can send messages to Starknet by calling the sendMessageToL2 function on the L1 bridge contract, while Starknet contracts can emit events via send_message_to_l1_syscall to trigger actions on Ethereum [28]. This model requires external watchers or relayers to process outgoing messages, ensuring secure and verifiable cross-chain communication.

The official bridge, StarkGate, facilitates asset transfers between the two layers, with security audits and monitoring in place to prevent exploits such as replay attacks or data manipulation [29]. Developers are encouraged to follow best practices such as nonce validation and formal verification to secure their messaging logic.

Comparison with Other Layer 2 Solutions

Starknet’s architecture differs significantly from Optimistic Rollups like Arbitrum and Optimism, which assume transaction validity by default and rely on fraud proofs to detect and punish invalid behavior. This results in longer withdrawal times—typically up to 7 days—due to the challenge period, whereas Starknet offers near-instant finality since every batch is cryptographically proven [30]. While Optimistic Rollups benefit from EVM compatibility, allowing easy migration of Solidity-based dApps, Starknet uses Cairo, a language specifically designed for provable computation, which offers greater efficiency and security at the cost of a steeper learning curve [31].

Compared to other zk-rollups like zkSync, which uses zk-SNARKs, Starknet’s use of STARKs provides advantages in transparency and quantum resistance, though with larger proof sizes. However, through aggregation techniques like SHARP, Starknet mitigates this overhead, achieving a favorable balance between security, scalability, and cost [32].

Developer Tooling and Deployment Workflow

Developers building on Starknet benefit from a robust and evolving toolchain. The primary development workflow begins with Scarb, the package manager and build system for Cairo, which handles dependencies, compilation, and testing [33]. Contracts are typically deployed using Starkli, a high-performance CLI tool written in Rust that supports account management, contract declaration, and interaction with the network [34].

For full-stack development, frameworks like Starknet Foundry and Scaffold-Stark provide integrated environments for testing, deployment, and frontend integration [35], [36]. Libraries such as Starknet.js enable seamless interaction with smart contracts from JavaScript/TypeScript applications, supporting wallet integration with providers like ArgentX and Braavos Wallet [37]. These tools collectively streamline the developer experience, making it easier to build, test, and deploy secure and scalable dApps.

Cairo Programming Language and Development Tools

The development ecosystem of Starknet is anchored by Cairo, a specialized programming language designed for generating zero-knowledge proofs efficiently, and a robust suite of tools that support the full lifecycle of decentralized application (dApp) development. Cairo enables developers to write secure, verifiable smart contracts that can be executed off-chain while maintaining cryptographic integrity on Ethereum. This section explores the language’s design, its key differences from traditional smart contract languages, and the essential development tools that empower builders on the Starknet platform.

Cairo: A Language for Zero-Knowledge Computation

Cairo is the native programming language for Starknet, specifically engineered to support provable computation—a paradigm where programs are executed off-chain, and their correctness is verified on-chain via cryptographic proofs [38]. Unlike general-purpose languages, Cairo is optimized for generating zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge), which are used to prove the validity of complex computations without revealing their inputs [39].

Cairo is inspired by the syntax and safety features of Rust, making it familiar to developers experienced with systems programming. It includes modern language constructs such as generics, pattern matching, and a strong type system, which enhance code safety and maintainability [40]. A significant milestone was the release of Cairo 1.0 in 2022, which introduced a more stable and secure language model, including an intermediate representation called Sierra that facilitates compilation and formal verification [41].

One of Cairo’s defining characteristics is its write-once memory model, where each memory cell can be written to only once. This constraint ensures deterministic execution and prevents common vulnerabilities such as reentrancy and unintended state modifications, which are prevalent in mutable-memory models like those used in Solidity [42]. Additionally, Cairo 1.0 is Turing-complete, allowing for loops and controlled recursion, but within bounds that ensure proof generation remains computationally feasible [43].

Differences from Traditional Smart Contract Languages

Cairo diverges significantly from traditional smart contract languages like Solidity and Vyper, which are designed for execution on the Ethereum Virtual Machine (EVM) and rely on direct on-chain computation. In contrast, Cairo is built for off-chain execution with on-chain verification, leveraging the efficiency of zk-rollups to reduce gas costs and increase throughput [1].

While Solidity’s execution model is based on a stack machine with mutable state, Cairo’s architecture is tailored for algebraic intermediate representation (AIR), where computational steps are translated into polynomial constraints that can be verified using the FRI (Fast Reed-Solomon Interactive Oracle Proof) protocol [14]. This allows Starknet to batch thousands of transactions into a single succinct proof, drastically reducing the data published to Ethereum [13].

Another key difference is the absence of a trusted setup in Cairo-based systems, unlike some zk-SNARK implementations. This makes Cairo more aligned with principles of decentralization and transparency, as the security of the proofs does not rely on secret parameters that could be compromised [12].

Core Development Tools for Cairo and Starknet

Starknet provides a comprehensive toolkit that streamlines the development, testing, deployment, and interaction with smart contracts. These tools are designed to offer a developer experience comparable to that of Ethereum, while accommodating the unique requirements of zero-knowledge proof systems.

Scarb: The Cairo Package Manager

Scarb is the official package manager and build toolchain for Cairo, analogous to Cargo in Rust [33]. It simplifies dependency management, compilation, and testing of Cairo projects. Scarb allows developers to define project configurations, manage external libraries, and automate build processes, making it a cornerstone of modern Cairo development [49].

Starknet.js: JavaScript Library for dApp Frontends

Starknet.js is a widely used JavaScript/TypeScript library that enables seamless interaction with the Starknet network from both frontend and backend applications [37]. It provides a complete API for deploying contracts, managing transactions, verifying signatures, and integrating with wallets such as ArgentX and Braavos. Starknet.js is essential for building user-facing dApps and is often used in conjunction with frameworks like React and Next.js [51].

Starknet Foundry: Rapid Development Environment

Starknet Foundry is a high-performance development environment inspired by Foundry for Ethereum [52]. It offers a suite of tools for testing, deploying, and debugging Cairo smart contracts. With Starknet Foundry, developers can write unit tests, simulate transactions, and deploy contracts locally or on testnets with minimal configuration, accelerating the development cycle [35].

Starkli: Command-Line Interface for Starknet

Starkli is a fast and secure command-line interface (CLI) tool written in Rust that allows developers to interact directly with Starknet [54]. It supports operations such as contract declaration, deployment, and invocation, and integrates with local keystores for wallet management. Starkli is particularly useful for scripting, automation, and production deployments [34].

Protostar: Cairo Development Framework

Protostar is a full-featured development framework for Cairo that provides a structured workflow for building, testing, and deploying smart contracts [56]. It includes built-in support for the Universal Deployer Contract (UDC), which standardizes contract deployment and enables upgradeable patterns. Protostar also integrates with Starknet’s devnet for local testing and simulation [57].

Supporting Tools and Developer Resources

In addition to the core tools, Starknet offers a range of complementary utilities and learning resources to support developers:

  • Starkweb: An all-in-one toolkit that abstracts the JSON-RPC API of Starknet, providing support for smart contract interaction, ABI management, and integration with frameworks like Hardhat and Anvil [58].
  • Walnut: A debugging and transaction simulation tool that allows developers to test contract behavior in a safe environment before deployment [59].
  • Cairo Playground: An online environment for experimenting with Cairo code, ideal for learning and prototyping [38].
  • The Starknet Book: A comprehensive guide that covers everything from setting up a development environment to writing and deploying smart contracts [61].

Best Practices for Secure and Efficient Development

To ensure robust and secure dApp development on Starknet, developers are encouraged to follow several best practices:

  • Use audited libraries: Leverage well-vetted libraries from sources like OpenZeppelin to minimize the risk of introducing known vulnerabilities [62].
  • Prevent felt overflow/underflow: Cairo uses the felt (field element) type for arithmetic, which can lead to unexpected behavior if not properly validated. Developers should implement range checks and use safe math libraries [63].
  • Implement formal verification: Given the critical nature of zk-proof systems, formal verification is highly recommended to mathematically prove the correctness of contract logic [64].
  • Test thoroughly with Starknet Foundry or Protostar: Comprehensive unit and integration testing helps catch bugs early in the development process [65].

By combining the power of Cairo with a rich set of development tools, Starknet offers a modern, secure, and scalable platform for building the next generation of blockchain applications. The ecosystem continues to evolve, with ongoing improvements in tooling, language features, and developer experience driving broader adoption across DeFi, Web3 gaming, and privacy-preserving applications.

zk-STARKs vs Other Zero-Knowledge Proofs

Starknet's use of zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge) sets it apart from other blockchain scaling solutions that rely on alternative forms of zero-knowledge proofs, such as zk-SNARKs (Succinct Non-Interactive Arguments of Knowledge), or non-ZK technologies like optimistic rollups. These distinctions have significant implications for security, trust assumptions, computational efficiency, and long-term viability in the rapidly evolving landscape of Layer 2 solutions.

Security and Cryptographic Assumptions

One of the most critical advantages of zk-STARKs over zk-SNARKs is their superior cryptographic security, particularly in the context of future threats. zk-STARKs are considered quantum-resistant because they rely on symmetric cryptographic primitives, such as collision-resistant hash functions and algebraic structures, which are not vulnerable to attacks by quantum computers [12]. In contrast, zk-SNARKs depend on complex mathematical assumptions like the hardness of the discrete logarithm problem on elliptic curves—assumptions that could be broken by sufficiently powerful quantum machines.

Furthermore, zk-SNARKs rely on unproven cryptographic assumptions such as the Knowledge of Exponent Assumption (KEA), which lack the broad consensus and rigorous analysis that underpin the hash-based primitives used in zk-STARKs [12]. This makes zk-STARKs a more future-proof choice for securing blockchain systems over the long term.

Transparency and the Absence of Trusted Setup

A defining feature of zk-STARKs is their transparency, meaning they do not require a trusted setup—a critical distinction from zk-SNARKs. In zk-SNARK systems, a trusted setup phase generates cryptographic parameters that must be securely discarded afterward. If these parameters are compromised or not properly destroyed, an attacker could forge proofs and submit invalid state transitions without detection, undermining the entire security model [68].

zk-STARKs eliminate this risk entirely by using publicly verifiable, deterministic parameters for proof generation. This trustless foundation aligns with the core principles of decentralization and permissionless innovation, making Starknet a more secure and censorship-resistant platform compared to systems that rely on zk-SNARKs [12].

Computational Trade-offs: Proof Size, Generation, and Verification

While zk-STARKs offer stronger security and transparency, they come with different performance trade-offs compared to zk-SNARKs:

  • Proof Size and Verification Cost: zk-SNARKs produce extremely compact proofs—often around 192 bytes—which can be verified on-chain with minimal gas consumption (approximately 3 ms). In contrast, zk-STARK proofs are significantly larger, sometimes 100 to 200 times the size of SNARK proofs, leading to higher on-chain verification costs [70][71].

  • Proof Generation Time: Historically, zk-STARKs required longer proof generation times due to their computational complexity. However, Starknet has mitigated this limitation through the introduction of S-two, a next-generation prover that is over 100 times faster than its predecessor [72]. S-two leverages advanced techniques like Circle STARK and optimized use of standard hardware (CPUs and GPUs), enabling rapid proof generation even for complex computations [73].

To address the issue of large proof sizes, Starknet employs recursive proof aggregation via systems like SHARP (Shared Prover) and STARKPack [15][16]. These mechanisms allow multiple STARK proofs to be combined into a single, succinct proof that can be verified efficiently on Ethereum, dramatically reducing the average cost per transaction.

Comparison with Optimistic Rollups

Beyond ZK-based systems, Starknet also differs fundamentally from optimistic rollups like Arbitrum and Optimism. While Starknet uses validity proofs to guarantee transaction correctness before finalization, optimistic rollups assume transactions are valid by default and rely on a fraud proof mechanism where challenges can be submitted during a dispute window (typically up to 7 days) [30].

This results in significantly longer withdrawal times and delayed finality on optimistic rollups, as users must wait for the challenge period to expire before considering funds secure. In contrast, Starknet offers near-instant finality, as transactions are cryptographically proven valid upon inclusion in a batch, enabling faster user experiences and more responsive applications [77].

Verification Architecture and Protocol Design

The verification of zk-STARKs on Starknet involves a multi-step process rooted in advanced cryptographic protocols. After a computation is executed in the Cairo Virtual Machine (CairoVM), it is arithmetized into an Algebraic Intermediate Representation (AIR), transforming computational correctness into a set of polynomial constraints [14]. The prover then uses the FRI (Fast Reed-Solomon Interactive Oracle Proof) protocol to demonstrate that these constraints are satisfied, without revealing the underlying data.

This approach avoids the need for complex cryptographic pairings, which are required in zk-SNARKs and can introduce additional attack vectors. The FRI-based verification enhances both the security and simplicity of the proof system, contributing to Starknet’s robustness [17].

Conclusion: Strategic Advantages of zk-STARKs

In summary, the use of zk-STARKs in Starknet provides a compelling balance of security, transparency, and scalability. While they initially posed challenges in terms of proof size and generation speed, innovations like S-two and SHARP have effectively addressed these limitations. By eliminating the need for a trusted setup and offering resistance to quantum attacks, zk-STARKs position Starknet as a trust-minimized, decentralized, and future-ready Layer 2 solution. This technological foundation supports a wide range of applications—from high-frequency DeFi trading to private transactions via the STRK20 standard—while maintaining the highest standards of cryptographic integrity [80].

Tokenomics and the STRK Token

The tokenomics of Starknet revolve around its native utility token, STRK, which plays a central role in the network’s economic model, security, and governance. Designed to align incentives across users, developers, and validators, STRK is integral to the long-term sustainability and decentralization of the Starknet ecosystem. Its multifaceted utility spans transaction fee payments, participation in proof-of-stake staking, and decentralized governance, making it a cornerstone of the network's economic architecture [81].

Distribution and Initial Airdrop

The initial distribution of STRK was one of the most inclusive in blockchain history, aiming to foster broad community ownership and decentralization. On February 20, 2024, Starknet launched a massive airdrop, distributing approximately 700 million STRK—7% of the total 10 billion token supply—to around 1.3 million eligible wallets [82]. Recipients included early users, active developers, and contributors who had engaged with the Starknet ecosystem prior to the token launch [83].

The remaining tokens are allocated across various stakeholders, including the Starknet Foundation, contributors, investors, and ecosystem development initiatives. The token release follows a structured monthly unlock schedule of approximately 127 million STRK, extending until March 2027, designed to manage inflation and ensure a balanced supply-demand dynamic [84].

Utility of the STRK Token

STRK serves three primary functions within the Starknet ecosystem, each reinforcing network security and user engagement.

Transaction Fee Payments

STRK is used to pay for transaction fees on the Starknet network. Users must hold STRK to interact with smart contracts, execute transactions, or deploy applications. A portion of these fees is permanently burned, creating a deflationary mechanism that counterbalances the inflation from new token emissions and supports long-term value accrual [85].

Staking and Network Security

STRK is the foundation of Starknet’s transition to a decentralized proof-of-stake (PoS) model. With the approval of SNIP-18 in 2024, Starknet introduced staking, allowing users to secure the network and earn rewards. Validators must stake a minimum of 20,000 STRK and operate a full node, while smaller holders can delegate their stake to validators and earn a share of the rewards [86].

This staking mechanism not only enhances network security but also aligns economic incentives with protocol health. As of 2025, over 921.6 million STRK were staked, demonstrating strong community commitment to decentralization [85]. The system includes slashing penalties for malicious or inactive behavior, further reinforcing validator accountability.

Decentralized Governance

STRK is the governance token of Starknet, enabling holders to participate in protocol decisions through a voting system. To vote, users wrap their STRK into vSTRK, a non-transferable token that represents voting power [88]. Proposals can include protocol upgrades, changes to staking parameters, treasury allocations, and ecosystem incentives.

The first major on-chain vote, conducted in September 2024 using Snapshot X, approved the implementation of staking, marking a pivotal moment in Starknet’s decentralization journey [89]. The governance model incorporates a hybrid structure, including direct voting, delegation to trusted experts, and a Builders Council representing key ecosystem participants, ensuring both inclusivity and efficiency in decision-making [90].

Incentive Programs and Ecosystem Growth

To accelerate adoption and innovation, Starknet has launched several targeted incentive programs funded in STRK.

  • DeFi Spring: A $50 million initiative to boost decentralized finance on Starknet, later expanded to DeFi Spring 2.0 with an additional 50 million STRK to support new protocols and user growth [91].
  • Propulsion Program: A $1 million fund offering gas fee rebates to game developers building on Starknet, supporting the rise of Web3 gaming [92].
  • Seed Grant Program: Provides up to 25,000 USDC in funding for early-stage projects with viable MVPs, fostering grassroots innovation [93].
  • BTCFi Season: An initiative allocating 100 million STRK to incentivize Bitcoin integration into Starknet’s DeFi ecosystem, promoting cross-chain financial applications [94].

These programs not only stimulate development but also increase demand for STRK, reinforcing its utility and economic role.

Economic Risks and Mitigation Strategies

Despite its robust design, Starknet’s tokenomics face several economic challenges.

Inflation and Token Unlock Events

The monthly unlock of 127 million STRK poses inflationary pressure, particularly during large unlock events. In 2026, over 52% of the total supply was released in the first half of the year, raising concerns about market sell-offs and price volatility [95]. To mitigate this, Starknet introduced a dynamic staking mechanism that adjusts inflation based on staking participation, with a proposed cap of 4% annual inflation to maintain balance [96].

Concentration of Ownership

A significant portion of STRK is initially held by the Starknet Foundation and early contributors, creating risks of market manipulation and plutocratic governance. The community is actively working to decentralize control through staking, delegation, and transparent governance processes to prevent undue influence by large holders [97].

Sustainability of Incentives

High staking rewards—reaching up to 54% APY in early phases—are effective for bootstrapping participation but may not be sustainable long-term. The network must transition from emission-based incentives to revenue-driven models, where transaction fees and ecosystem activity generate sufficient value to support validator rewards without excessive inflation.

Comparison with Other Layer 2 Ecosystems

Starknet’s tokenomics distinguish it from other major Layer 2 solutions like Arbitrum and Optimism. While these networks rely on optimistic rollup architectures and centralized sequencers, Starknet’s use of zk-Rollup technology enables faster finality and lower fees, especially after the integration of EIP-4844, which reduced transaction costs to around $0.01 [98].

Moreover, Starknet’s integration of staking for security—unlike Arbitrum and Optimism, which lack native staking—positions it as a more autonomous and economically resilient Layer 2. The combination of ZK-proofs, a multifunctional token, and a clear decentralization roadmap gives Starknet a competitive edge in the evolving Ethereum scaling landscape [99].

Decentralized Governance and Security Council

Starknet's transition toward a fully decentralized network is anchored in its dual-pillar framework of decentralized governance and the Security Council, both of which are designed to transfer control of the protocol from centralized entities to the community. This structure ensures that critical decisions about the network’s evolution—ranging from protocol upgrades to emergency responses—are made transparently, securely, and in alignment with the interests of stakeholders, particularly holders of the native STRK token.

Decentralized Governance Model and Token-Based Voting

The governance model of Starknet is built on a token-weighted voting system, where the STRK token serves as the primary mechanism for participation. Holders of STRK can convert their tokens into vSTRK (voting STRK), which grants them voting power in protocol decisions [88]. This conversion occurs through the Governance Hub, the official platform for managing proposals and votes [101].

Voting power is proportional to the amount of vSTRK held, ensuring that stakeholders with greater economic investment in the network have a correspondingly larger influence on its direction. However, to promote inclusivity and expertise-based decision-making, Starknet supports delegation, allowing smaller token holders to assign their voting rights to trusted delegates. Among these, the Builders Council—a group of 17 ecosystem contributors—holds 23% of the delegated voting power and plays a central role in shaping technical and strategic proposals [102].

A landmark moment in Starknet’s governance occurred in September 2024, when the community approved SNIP-18, the proposal to implement staking on the network, via the first onchain vote using Snapshot X [103]. Snapshot X is a gas-free, onchain voting protocol that enhances transparency and censorship resistance, enabling broad participation without transaction fees [104]. This vote marked a pivotal shift from centralized oversight to community-driven governance.

The Starknet Security Council: Emergency Oversight and Upgrade Validation

While day-to-day governance is managed through community voting, the Starknet Security Council, established in November 2024, serves as a specialized body responsible for high-stakes decisions, particularly those involving protocol security and emergency interventions [105]. Composed of 12 members with diverse technical and geographic expertise, the Council acts as a safeguard against critical threats such as bugs, exploits, or network disruptions.

The Council’s responsibilities include:

  • Evaluating and approving protocol upgrades, especially those affecting core contracts.
  • Authorizing emergency actions, such as rollback procedures or patch deployments, in response to incidents.
  • Overseeing the integrity of the upgrade process to prevent malicious or erroneous changes.

For regular upgrades, a 50% majority of Council members is required, while emergency actions demand a 75% supermajority, ensuring robust consensus before any intervention [105]. This structure balances agility with security, preventing unilateral control while enabling rapid response when necessary.

The Council’s authority is not absolute; it operates within a transparent framework and is accountable to the broader community. Its decisions are subject to public scrutiny, and its role is intended to be transitional, evolving as Starknet achieves greater decentralization in its validation and proving layers.

Mitigating Risks of Centralization and Malicious Upgrades

Despite progress, Starknet faces risks related to centralization, particularly in the sequencer and prover layers, which are still operated by StarkWare [107]. This concentration of control could, in theory, enable censorship or manipulation of transaction ordering, undermining the network’s permissionless ethos.

To address these concerns, Starknet has outlined a Decentralization Roadmap aimed at transitioning to a fully permissionless system. Key milestones include:

  • The introduction of multi-sequencer architecture (Grinta), which distributes sequencing responsibilities across independent operators [108].
  • The development of S-two, a high-performance prover designed to support decentralized proving networks [109].
  • The expansion of the validator set through STRK staking, allowing any user who stakes at least 20,000 STRK to participate in network security [110].

These measures aim to eliminate single points of failure and ensure that no single entity can unilaterally alter the protocol or censor transactions.

Community Participation and Future Evolution

Starknet’s governance model is continuously evolving, with ongoing discussions about integrating zero-knowledge (ZK) technologies into the voting process itself. Proposals such as ZK Governance suggest using zkSNARKs to enable private, verifiable voting in decentralized autonomous organizations (DAOs), further enhancing privacy and resistance to collusion [111].

In comparison to other Layer 2 solutions like Arbitrum and Optimism, Starknet distinguishes itself through its advanced integration of ZK proofs into governance, gas-free onchain voting, and a hybrid model that combines direct participation with expert delegation [112]. This approach balances decentralization with efficiency, positioning Starknet as a leader in next-generation blockchain governance.

dApp Ecosystem and Use Cases

Starknet hosts a rapidly expanding and diverse ecosystem of decentralized applications (dApps), leveraging its high-throughput, low-cost architecture to enable complex use cases across multiple sectors. As a validity rollup powered by zk-STARKs, Starknet ensures trustless security while drastically reducing transaction fees and confirmation times, making it an ideal platform for deploying scalable and user-friendly dApps. By November 2024, the network hosted 193 projects, reflecting a 168% year-over-year increase, with significant growth in DeFi, Web3 gaming, NFTs, payments, and real-world asset (RWA) tokenization [7]. The ecosystem is further supported by developer grants, interoperability tools like StarkGate, and advanced features such as account abstraction and the STRK20 privacy standard.

Decentralized Finance (DeFi)

The DeFi sector is one of the most developed on Starknet, benefiting from low gas costs and high transaction throughput. The ecosystem includes lending protocols, decentralized exchanges (DEXs), yield aggregators, and stablecoin platforms. Notable projects include:

  • Vesu, a permissionless lending protocol that allows users to deposit assets like vETH and vUSDC to earn interest or borrow against collateral [114].
  • Re7 Labs, a yield aggregation platform that automates liquidity management and yield farming strategies, simplifying access to complex DeFi opportunities [115].
  • StarkFi, a comprehensive DeFi suite offering lending, trading, stablecoins, and yield farming, with a focus on security through over-collateralization [116].

Starknet also supports high-performance DEXs such as 10KSwap, an automated market maker (AMM) optimized for Layer 2, and Extended, a perpetual DEX designed for high-frequency trading with sub-second confirmation times [117][118]. These platforms demonstrate Starknet’s ability to support sophisticated financial instruments while maintaining low latency and cost.

Web3 Gaming and On-Chain Games

Starknet has emerged as a leading platform for on-chain gaming, where game logic and state are fully executed and stored on the blockchain. This model ensures transparency, fairness, and true ownership of in-game assets. The network supports the Dojo game engine and runs the Propulsion Program, a $1 million funding initiative by the Starknet Foundation to accelerate game development [119].

Prominent gaming projects include:

  • Starknet-Arcade (Arcadino), a multiplayer arena featuring on-chain games like Coin Flip, Roulette, and Rock Paper Scissors, designed for gasless and transparent gameplay [120].
  • Loot Survivor and Influence, strategy games where all gameplay mechanics are executed on-chain, showcasing Starknet’s capacity for complex, real-time interactions [121].
  • Realms World, a decentralized strategy and resource management game built entirely on Starknet [122].
  • StarkFantasy League, a Web3-based fantasy football platform that allows users to create teams and compete for real rewards [123].

In February 2025, Starknet launched its first dedicated gaming app chain, marking a major milestone in its commitment to on-chain gaming and demonstrating the network’s scalability for specialized use cases [124].

NFTs and Digital Marketplaces

Starknet supports the creation, trading, and auctioning of NFTs with reduced costs and enhanced efficiency. The network enables innovative NFT applications such as Dutch auctions and decentralized lotteries. Projects like Starklotto, a decentralized lottery based on NFTs, leverage Starknet’s scalability to handle high volumes of transactions [125]. Developers can also implement NFT marketplaces using auction models, such as the NFT Dutch Auction example provided in Starknet’s official documentation, which allows dynamic pricing based on time and demand [126]. These applications benefit from Starknet’s low fees and fast finality, making NFT interactions more accessible to users.

Payments and Interoperability

Starknet is expanding into global payments and cross-chain interoperability, enabling fast and low-cost financial transactions. Key initiatives include:

  • Due, an international payment solution that uses Starknet to facilitate rapid and inexpensive cross-border transactions [127].
  • Integration with the Lightning Network of Bitcoin, allowing users to pay with the STRK token on Bitcoin’s payment layer for instant, near-zero-cost transactions [128].

These developments position Starknet as a bridge between blockchain ecosystems, enhancing its utility beyond Ethereum-based applications.

Real-World Assets (RWA)

An innovative use case on Starknet is the tokenization of real-world assets (RWA), bringing tangible assets onto the blockchain for transparent and verifiable ownership. Carbonable is a leading example, using Starknet to manage and verify carbon credits, enabling transparent tracking of environmental impact and supporting green finance initiatives [129]. This application highlights Starknet’s potential to serve industries beyond crypto, including sustainability, supply chain, and institutional finance.

Developer and User Infrastructure

Starknet supports a robust suite of infrastructure tools that enhance developer productivity and user experience:

  • Braavos Wallet, one of the most advanced wallets on the network, offers native integration with dApps and advanced security features [130].
  • StarkOverflow, a decentralized Q&A platform inspired by Stack Overflow, incentivizes knowledge sharing within the Starknet community [131].
  • Starkpay, a dApp for generating invoices and interacting with DeFi and NFT services, streamlining financial operations on-chain [132].

These tools contribute to a user-friendly and developer-centric ecosystem, lowering the barrier to entry for new participants.

Conclusion

The dApp ecosystem on Starknet reflects its versatility as a scalable and secure Layer 2 solution for Ethereum. From DeFi and gaming to NFTs, payments, and RWA tokenization, Starknet supports a wide range of applications that benefit from its high throughput, low fees, and cryptographic security. Backed by developer incentives, continuous technical upgrades like the S-two prover, and a growing community of builders, Starknet is establishing itself as a leading platform for next-generation blockchain applications [109].

Scalability, Performance, and Cost Optimization

Starknet achieves exceptional scalability, performance, and cost efficiency by leveraging a combination of advanced cryptographic techniques, parallel execution, and continuous protocol optimizations. As a validity rollup or zk-Rollup, Starknet executes transactions off-chain and submits succinct cryptographic proofs of their validity to the Ethereum mainnet, drastically reducing congestion and gas fees while inheriting Ethereum's security [1]. This architectural foundation enables Starknet to process thousands of transactions per second, positioning it as a leading solution for high-throughput decentralized applications dApp across sectors like DeFi and Web3 gaming.

zk-STARKs and Proof Aggregation for Scalability

The core of Starknet's scalability lies in its use of zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge), a type of zero-knowledge proof that allows for the aggregation of thousands of transactions into a single, verifiable cryptographic proof [3]. Unlike other zero-knowledge proofs such as zk-SNARKs, zk-STARKs do not require a trusted setup, making them more transparent and secure, and they are also resistant to quantum computing attacks, offering long-term security advantages [12]. The process begins with transaction execution on the Cairo Virtual Machine (CairoVM), generating an execution trace. This trace is then arithmetized into an Algebraic Intermediate Representation (AIR), transforming computational correctness into polynomial constraints [137]. A prover generates a STARK proof using the Fast Reed-Solomon Interactive Oracle Proof (FRI) protocol, which is then verified on Ethereum by a smart contract verifier [14].

To further enhance efficiency, Starknet employs SHARP (Shared Prover), a recursive proof aggregation system that combines multiple STARK proofs into a single composite proof [139]. This recursive aggregation significantly reduces the on-chain verification cost, as Ethereum only needs to verify one proof instead of hundreds or thousands. Future developments like STARKPack aim to achieve even greater compression and faster verification, further optimizing the system [16]. This entire process—generation, aggregation, and on-chain verification—ensures that Starknet can handle massive transaction volumes with minimal impact on the Ethereum mainnet, solving the blockchain trilemma of security, decentralization, and scalability [141].

High Performance Through Parallel Execution and Optimized Provers

Starknet delivers high performance through innovations in execution and proving technology. A key advancement is parallel execution of transactions, introduced with the "Bolt" upgrade in 2024 [18]. Unlike Ethereum, where transactions are processed sequentially, Starknet can execute independent transactions simultaneously, dramatically increasing throughput. This optimization, combined with efficient block packing, has reduced transaction confirmation times to approximately 2 seconds [18].

The performance of the proving system is critical to Starknet's overall speed. The primary challenge historically has been the time required to generate STARK proofs. Starknet has addressed this with S-two, a next-generation prover that is over 100 times faster than its predecessor [144]. S-two leverages advanced techniques like Circle STARK to optimize the proving process, enabling it to generate more than 500,000 hashes per second on standard hardware [72]. This speed allows Starknet to handle high transaction volumes without compromising on finality. Furthermore, S-two's client-side capability opens doors for new use cases like private DeFi and verifiable AI, enhancing both privacy and performance [109].

Cost Optimization Strategies and Fee Model

Starknet's cost optimization is a multi-faceted effort focused on reducing both Layer 1 (L1) and Layer 2 (L2) expenses. The majority of transaction costs on Starknet are associated with data availability on Ethereum, which accounts for about 95% of the total fee [147]. To address this, Starknet has integrated EIP-4844 (Proto-Danksharding), which introduces cheaper "blob" data storage on Ethereum. This integration has reduced transaction fees by up to 100 times, bringing the average cost down to around $0.01 per transaction [98]. This makes Starknet highly competitive in terms of cost-efficiency.

Another major cost-saving feature is Volition mode, which allows users to choose whether transaction data is published on-chain (public) or off-chain (private) [21]. By opting for off-chain data availability, users can drastically reduce their fees, trading public verifiability for lower cost, which is ideal for applications prioritizing privacy or budget. The Starknet fee model is designed to reflect actual system resource usage, with costs split between L1 (data publication) and L2 (computation) [150]. Further optimizations, such as the 66% reduction in fixed L1 costs from the "Bolt" upgrade and a 50% reduction in Cairo step costs, have also contributed to lower overall fees [151].

Cairo Code Optimization for Efficiency

Developers can further optimize performance and cost by writing efficient code in Cairo, Starknet's native programming language [5]. Cairo is specifically designed for provable computation, and optimizing its code directly impacts the efficiency of proof generation and gas consumption. Key techniques include bit-packing, which combines multiple values into a single integer to minimize storage costs, and function inlining, which replaces function calls with the function body to eliminate call overhead [153]. The use of modern development tools like Scarb for dependency management and Starknet Foundry for testing and deployment allows developers to profile and optimize their contracts effectively [33]. By following these best practices, developers can create dApps that are not only secure but also highly efficient and cost-effective for end-users.

Security Challenges and Risk Mitigation

Starknet, as a validity rollup leveraging zk-STARKs (Zero-Knowledge Scalable Transparent ARguments of Knowledge), inherits a high degree of security from the Ethereum mainnet through cryptographic validity proofs. However, its complex architecture introduces unique security challenges that extend beyond the underlying cryptography. These risks stem from implementation flaws, centralization in critical components, and vulnerabilities in the broader ecosystem. Effective risk mitigation requires a multi-layered approach combining technical upgrades, robust governance, and community vigilance.

Centralization Risks in Sequencing and Proving

One of the most significant security challenges facing Starknet is the centralization of its sequencer and proving infrastructure. Despite its goal of full decentralization, the network currently relies on a central sequencer operated by StarkWare to order transactions and manage the state. This creates a single point of failure and exposes the network to risks such as censorship and Maximal Extractable Value (MEV) manipulation. A compromised or malicious sequencer could delay or omit transactions, particularly impacting time-sensitive applications like DeFi protocols [155].

Similarly, the generation of STARK proofs is managed by a centralized prover, with the SHARP (Shared Prover) aggregator remaining a closed, proprietary system [107]. This centralization prevents independent verification and introduces operational risk. A bug or downtime in the proving system can halt the entire chain, as seen in past incidents. To mitigate these risks, Starknet has introduced the S-two prover, a high-performance system designed for future decentralization [109]. The long-term roadmap includes a transition to a multi-sequencer architecture (e.g., "Grinta") and an open, permissionless proving network, where validators selected by proof-of-stake staking of the STRK token will participate in the consensus process [158].

Software Bugs and Inconsistencies in the Execution Layer

Another critical vulnerability arises from software bugs in the system's components, particularly the potential for inconsistencies between the execution layer and the proof layer. A major incident on January 5, 2026, highlighted this risk when a bug in the blockifier component caused a state divergence. The blockifier incorrectly preserved a state change within a reverted function, creating a conflict between the executed state and the state expected by the STARK proof. This incompatibility halted block production and forced a rollback of approximately 18 minutes of network activity [159].

Such bugs are not direct attacks but represent a critical failure in the system's internal logic. An attacker could potentially exploit edge cases in the execution layer to trigger similar state conflicts, leading to a denial-of-service (DoS) or a chain rollback. This risk was previously demonstrated during the v0.14.0 upgrade in September 2025, which also caused a network outage [160]. To prevent recurrence, Starknet conducts rigorous testing on testnets, publishes detailed release notes, and has established the Starknet Security Council to oversee and approve critical upgrades, ensuring a more robust and transparent development process [105].

Vulnerabilities in Smart Contracts and the DeFi Ecosystem

While the zk-Rollup architecture guarantees the correctness of state transitions, it does not protect against vulnerabilities in individual smart contracts. The security of applications built on Starknet, especially in the DeFi sector, is the responsibility of their developers. A notable example is the zkLend hack in February 2025, which resulted in a loss of approximately $10 million. The exploit targeted a flaw in the protocol's business logic, likely related to interest rate or collateral management, rather than a weakness in Starknet's core infrastructure [162].

This incident underscores the importance of specialized security practices for the Cairo programming language. Cairo's unique model, including its use of the felt (field element) data type, introduces specific risks like felt overflow/underflow that are distinct from vulnerabilities in Solidity [63]. To mitigate these risks, developers are advised to use audited libraries from OpenZeppelin, implement formal verification, and conduct thorough audits with firms experienced in zero-knowledge proof systems, such as zkSecurity and ChainSecurity [62]. The introduction of the Caracal static analysis framework specifically for Cairo further strengthens the ecosystem's ability to detect vulnerabilities before deployment [165].

Risks Associated with Protocol Upgrades

The process of upgrading the Starknet protocol itself carries inherent risks, including the potential for malicious upgrades that could lead to permissioning (restricting network access) or even a rug-pull at the protocol level. While the governance model is designed to be decentralized, the concentration of voting power among large token holders (whales) could theoretically allow for coordinated attacks on the network's integrity [95].

To mitigate these risks, Starknet employs a multi-faceted governance and security framework. The Security Council, composed of 12 independent members, must approve all critical upgrades, requiring a 75% majority for emergency actions [105]. This council acts as a check against unilateral decisions. Additionally, the community participates through on-chain voting using vSTRK, the voting-locked version of the STRK token, via the Snapshot X protocol, which enables gas-free, on-chain voting [104]. This hybrid model of council oversight and community governance is designed to ensure that upgrades are transparent, well-vetted, and aligned with the network's long-term health.

User-Level Threats and Monitoring Tools

Users and node operators face specific threats like front-running and censorship. Front-running in DeFi applications can be mitigated through techniques like commit-reveal schemes and setting strict slippage limits. To combat censorship, Starknet has implemented an escape hatch mechanism, allowing users to force the withdrawal of their funds directly from the Ethereum Layer 1 if the sequencer fails to process their transactions [169].

For monitoring network health and security, several tools are recommended. Starknet Monitor provides real-time data on block production and RPC latency, while Starkscan serves as a comprehensive block explorer for tracking transactions and contracts [170], [171]. Node operators are encouraged to run full nodes using software like Pathfinder to independently validate the chain and contribute to decentralization [172]. The combination of these tools and active community participation is essential for maintaining a secure and resilient Starknet ecosystem.

References