The Starknet Mainnet Upgrade History provides a canonical, chronological index of every protocol-level state transition on Starknet mainnet. Each entry documents the activation date, block number, core Starknet Improvement Proposals (SNIPs) included, and a technical summary of breaking changes. This record serves as the primary reference for infrastructure operators, exchange security teams, and application developers to audit the network's upgrade cadence, verify the sequence of state transitions, and plan migration work.

Starknet Mainnet Upgrade History
Starknet Mainnet Upgrade History
A versioned, source-aware record of every Starknet mainnet network upgrade, including activation mechanics, core SNIPs, and breaking changes for operators and builders.
Starknet upgrades are currently coordinated by the core development team and activated via sequencer-coordinated forks, a model that will eventually transition to on-chain governance votes with time-locked protocol upgrades. Each fork can introduce changes to the state transition function, Cairo virtual machine behavior, fee market mechanics, or system call interfaces. Operators running full nodes (Pathfinder, Juno, Papyrus) must monitor this history to ensure their client versions are compatible with the canonical fork chain, while bridge validators and light client implementers rely on it to verify state proofs against the correct block hash lineage.
Breaking changes documented here span multiple layers: the JSON-RPC API for RPC providers, the peer-to-peer layer for node operators, the contract execution environment for dApp developers, and the account contract interface for wallet teams like Argent and Braavos. A fork may deprecate older Cairo versions, alter fee estimation logic, or require state re-syncs from genesis or a snapshot. Teams responsible for integration security should cross-reference each upgrade with the corresponding testnet timeline to validate their staging environments before mainnet activation. Chainscore Labs provides upgrade readiness reviews, integration impact assessments, and node operator migration support for teams navigating these state transitions.
Upgrade Index Quick Facts
A chronological reference of Starknet mainnet upgrades, activation mechanisms, and breaking changes for operators, builders, and risk teams to assess upgrade cadence and operational impact.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
Activation mechanism | Sequencer-coordinated upgrade with planned transition to on-chain governance votes | Node operators, governance delegates, risk teams | Monitor sequencer signals; verify against canonical Starknet governance forum for current activation model |
State transition | State root computation, block hash derivation, and underlying data structures evolve per upgrade | Bridge operators, light client implementers, exchange security teams | Audit state transition changes in each upgrade's SNIPs; validate state proofs post-activation |
Cairo and Sierra | Compiler and prover upgrades tied to network forks; may deprecate older Cairo versions | Contract developers, auditors, wallet teams | Check Cairo version compatibility per upgrade; plan contract migration or recompilation if required |
Fee model | Fee market and transaction cost model changes (e.g., Cairo-step-based costing introduced in 0.13.0) | Wallets, exchanges, DeFi protocols, paymaster integrators | Update fee estimation logic and transaction construction per upgrade; test on Sepolia before mainnet activation |
Account abstraction | Account contract interface, mandatory entry points, signature validation, or paymaster integration may change | Wallet teams (Argent, Braavos), custodians, account-contract developers | Review account contract impact per upgrade; validate signature flows and paymaster compatibility |
Full node and RPC | Breaking changes to P2P layer, JSON-RPC API, or data storage format | Infrastructure operators (Infura, Alchemy), exchange node runners, indexers | Apply client software updates before activation; test RPC endpoints and sync from genesis or snapshot |
Sequencer and prover | New software requirements, hardware benchmarks, or proof system changes (SHARP, Stone, Stwo) | Sequencer operators, prover operators, decentralization roadmap participants | Verify hardware and configuration requirements per upgrade; generate required proof types |
State archive | ReGenesis or state-pruning forks may reset state tree, requiring re-sync or storage proof verification | Full node operators, indexers, explorers, data teams | Plan for full re-sync or database rebuild if state reset occurs; validate storage proof mechanisms |
Upgrade Activation and Sequencing Model
How Starknet mainnet upgrades are sequenced, activated, and coordinated between the sequencer, provers, and node operators.
Starknet mainnet upgrades follow a sequencer-coordinated activation model, distinct from the on-chain governance votes or miner-signaled forks common in other L1s. A network upgrade is defined by a new set of protocol rules—typically a combination of a Cairo compiler version, a Sierra-to-Casm verifier, and an OS/state transition program hash. The Starknet sequencer, operated by StarkWare, initiates the fork by producing blocks under the new protocol rules at a pre-announced block height. All full nodes, RPC providers, and provers must have upgraded their software to the declared versions before this activation point to remain in consensus.
This model places a high operational coordination burden on infrastructure operators. There is no on-chain signaling mechanism or automated activation trigger; the fork is effectively a flag-day event. Operators monitor official Starknet communication channels for the announcement of an upgrade's target block number and the required software versions for Pathfinder, Juno, or other node clients. Failure to upgrade results in a node diverging from the canonical chain, requiring a resync. The sequencer's unilateral ability to trigger the fork is a deliberate architectural choice for the current 'Starknet Alpha' era, prioritizing rapid iteration over decentralized activation.
The planned transition to a decentralized sequencing and proving model will fundamentally alter this activation mechanism. Future eras are expected to introduce on-chain governance votes, time-locked upgrade contracts, and potentially a Security Council with emergency intervention powers, similar to the patterns seen in Arbitrum and Optimism. For operators, this means the current operational workflow of monitoring a single sequencer's upgrade schedule will evolve into tracking governance proposal lifecycles, analyzing on-chain timelocks, and preparing for multi-party coordinated activations. Teams running Starknet infrastructure should already be modeling the operational and risk-control changes required for a governance-driven upgrade model.
For exchanges, custodians, and bridge operators who verify Starknet state, the activation model directly impacts their security and reconciliation procedures. A sequencer-coordinated fork requires these entities to trust the sequencer's declaration of the new state transition program hash. In a decentralized future, they will need to independently verify governance outcomes and monitor timelock contracts. Chainscore Labs assists infrastructure teams in building upgrade readiness checklists, verifying state transition integrity across forks, and designing monitoring systems that detect chain divergence events during activation windows.
Impact by Actor
Full Node & RPC Operators
Every mainnet upgrade is a hard deadline for node operators. A new state transition function means old software will diverge from the canonical chain immediately at the activation block.
Pre-upgrade actions:
- Monitor the Starknet Foundation's upgrade announcements for the exact activation block number and the required client version (Pathfinder, Juno).
- Schedule a maintenance window to upgrade the node binary before the activation block. A late upgrade results in a stalled node and requires a full re-sync.
- Verify the new binary's checksum against the official release.
Post-upgrade actions:
- Monitor node logs for the first few hours to confirm the node is producing blocks and the RPC API is serving requests correctly.
- If the upgrade introduces new RPC methods or deprecates old ones, update your internal proxy and load-balancer configurations.
Chainscore Labs can review your node upgrade playbook and RPC failover strategy to minimize downtime during a fork.
Key Upgrade Eras and Their Impact
Starknet's mainnet evolution is defined by distinct upgrade eras, each introducing fundamental changes to the fee market, execution model, and state management. Understanding the operational and integration impact of these eras is critical for infrastructure teams and application developers.
The 0.12.0 Era: Fee Market Restructuring
The 0.12.0 upgrade fundamentally altered Starknet's economic model by transitioning to a new fee market and introducing Volition. This era broke existing transaction fee estimation logic for all wallets and applications. Operators must ensure their fee estimation services use the post-0.12.0 model, while exchanges need to verify that their deposit and withdrawal fee calculation logic is compatible with the new cost architecture to prevent stuck transactions.
The 0.13.0 Era: Cairo-Step Cost Model
The shift to a Cairo-step-based cost model in the 0.13.0 upgrade changed how computation is metered and priced. This was a breaking change for any system constructing or simulating transactions. Wallet teams and custodians must rebuild their transaction simulation and gas estimation logic to align with the new cost model. Failure to update results in inaccurate fee quotes and transaction failures, directly impacting user experience and asset custody operations.
The ReGenesis Era: State Pruning and Storage Proofs
The ReGenesis concept represents a state reset or pruning event designed to manage state bloat. This era has a massive operational impact: all full nodes, indexers, and explorers must re-sync or rebuild their databases from a new genesis state. Infrastructure providers like Infura and Alchemy need a detailed migration plan to avoid prolonged downtime. Applications relying on historical state queries must integrate storage proofs to access pruned data.
Cairo and Sierra Compiler Upgrades
Major Cairo compiler and Sierra intermediate representation upgrades are tied to network forks and can deprecate older contract bytecode. Development teams must audit their deployed contracts against the latest compiler target and plan for redeployment or proxy upgrades if their current version is deprecated. Auditors need to verify that new compiler features do not introduce security vulnerabilities in the updated Sierra-to-Cairo compilation path.
Account Abstraction Interface Changes
Network upgrades can introduce new mandatory entry points or alter signature validation logic for Starknet's native account abstraction. Wallet teams like Argent and Braavos must update their account contract implementations to remain compatible. Custodians and exchanges must test their transaction authorization flows against the new interface to ensure they can still construct valid user operations after the fork activates.
Sequencer and Prover Decentralization Transitions
The roadmap from a single-sequencer model to a decentralized network of sequencers and provers introduces new trust assumptions and operational requirements. Operators planning to run a sequencer or prover must track new proof types like SHARP, Stone, or Stwo and meet evolving hardware benchmarks. Bridge operators must update their verification logic to accept proofs from a decentralized set, a critical security consideration for cross-chain assets.
Upgrade Risk and Compatibility Matrix
A structured assessment of the operational risks, breaking changes, and required actions for key system actors across Starknet's major network upgrades. Use this matrix to evaluate upgrade readiness and identify integration review needs.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
State Transition & Block Hash | State root computation, block hash derivation, or underlying data structures may change | Bridge operators, light client implementers, exchange security teams | Verify state proof verification logic against the new state transition function; test bridge deposit and withdrawal flows on testnet |
Fee Market & Transaction Cost Model | Introduction of new fee market model, Cairo-step-based cost model, or fee-less system call transactions | Wallets, exchanges, dApp frontends, paymaster services | Update fee estimation logic to match the new cost model; validate transaction construction and simulation against the latest Cairo VM rules |
Cairo Compiler & Sierra Upgrade | New compiler features, syntax changes, or Sierra IR upgrades that alter contract execution | Smart contract developers, auditors, application protocols | Recompile contracts with the target compiler version; redeploy or upgrade proxy contracts if breaking changes affect existing bytecode; conduct a full audit of migrated contract logic |
Account Contract Interface | Changes to mandatory entry points, signature validation logic, or paymaster integration requirements | Wallet teams (Argent, Braavos), custodians, account abstraction integrators | Update account contract implementations to comply with the new interface; test signature validation and paymaster flows on testnet before mainnet activation |
Full Node & RPC Provider Data | Breaking changes to the peer-to-peer layer, JSON-RPC API, or data storage format | Infrastructure operators (Infura, Alchemy), exchange node runners, indexers | Upgrade node software to the compatible client release; resync or rebuild databases if state pruning or format changes require it; validate RPC endpoint compatibility |
Sequencer & Prover Operations | New proof types (SHARP, Stone, Stwo) or updated hardware and configuration requirements | Sequencer operators, prover node runners, decentralization participants | Deploy updated prover software; verify hardware benchmarks meet new requirements; test proof generation and submission against the upgraded network |
State Archive & Storage Proofs | State pruning or reset (ReGenesis) that removes historical state while preserving data via storage proofs | Explorers, indexers, data analytics platforms, archive node operators | Rebuild or re-sync databases from the new state root; implement storage proof verification for historical data access; communicate data availability changes to downstream consumers |
Operator Upgrade Readiness Checklist
A structured checklist for infrastructure operators, exchange teams, and RPC providers to validate readiness before a Starknet mainnet network upgrade activates. Each item identifies a critical verification area, explains its operational significance, and specifies the signal or artifact that confirms readiness.
What to check: Confirm that your running node client (Pathfinder, Juno, Papyrus) is updated to a version that explicitly supports the target fork's block number and state transition changes. Review the client's release notes for mandatory configuration changes, new CLI flags, or deprecated APIs.
Why it matters: An incompatible node will stall at the upgrade block, fail to sync, or serve incorrect state. For exchanges and custodians, this can halt deposits and withdrawals. For RPC providers, this causes API outages for downstream applications.
Readiness signal: The node client's GitHub release page includes a tag like 'v0.x.x - Starknet v0.13.x support' and your node logs show successful sync on testnet past the equivalent upgrade block.
Canonical Resources
Use these resources to verify Starknet mainnet upgrade history, activation context, protocol changes, and node compatibility. Treat any secondary timeline as non-authoritative until checked against official Starknet documentation, SNIPs, client releases, and chain data.
Looking to build on a specific blockchain?
We build smart contracts, DeFi applications, wallets, tokenization platforms, and blockchain infrastructure across the major ecosystems teams choose today. That includes Ethereum, Arbitrum, Optimism, Polygon, Avalanche, Solana, Sui, Aptos, Hedera, Stellar, and NEAR, with support for additional EVM and non-EVM networks based on your product requirements.
EVM ecosystems
- Ethereum
- Arbitrum
- Optimism
- Polygon
- Avalanche
- Cronos

Non-EVM ecosystems
- Solana
- Sui
- Aptos
- Hedera
- Stellar
- NEAR
Additional ecosystems
- Polkadot
- Cosmos
- TON
- Cardano
- Algorand
- Tempo
Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.
Frequently Asked Questions
Common operational and technical questions about Starknet's mainnet upgrade history, versioning, and impact on node operators, application developers, and integration teams.
To confirm your node is operating on the correct post-upgrade fork:
- Check block hash at a known height: Query the block hash for a specific block number immediately after the upgrade activation and compare it against a trusted public explorer or a known-good node. A mismatch indicates a consensus failure.
- Verify the
starknet_syncingstatus: Call the JSON-RPC methodstarknet_syncing. Afalseresult confirms the node is fully synced. Atrueresult with astarting_block_hashandcurrent_block_hashindicates it is still catching up. - Inspect the
starknet_chainId: Ensure the chain ID matches the expected mainnet value (0x534e5f4d41494e). An incorrect chain ID suggests a configuration error or connection to the wrong network. - Monitor node logs for upgrade events: During a fork activation, the node software (e.g., Pathfinder, Juno) will log a specific message indicating a state transition. Confirm this log entry appears without subsequent errors.
Why this matters: A node that silently diverges from the canonical chain will serve invalid state data to applications, leading to failed transactions, incorrect balances, and potential financial loss for integrated services.
Delivering blockchain solutions for 5+ years.
We have partnered with 50+ leading DeFi protocols, NFT ecosystems, and fintech innovators to build secure, scalable, and capital-efficient blockchain products.
Selected Partners & Clients
“I've been working with Chainscore Labs for last 3+ years, they've consistently delivered with strong ownership across multiple projects. The team is reliable and detail-oriented.”
How to get started?
If you're looking for blockchain integration, ChainScore Labs has 5+ years of experience helping teams build and integrate exchanges, wallets, smart contracts, tokenization solutions, and protocol-connected products, we can help you choose the right path, integrate securely, and get to production faster. Our team consists of experienced blockchain developers and architects who can help you with your blockchain integration needs.
Exploration & Strategy
Define your product goals and choose the right blockchain architecture for your use case.
Architecture & Design
Design the smart contracts, tokenomics, and security parameters of your system.
Development & Integration
Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.
Security & Launch
Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.
Discover our
blockchain development services.
We build production-grade blockchain solutions for top-tier projects across DeFi and Web3.
Need a blockchain engineering team?
Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.


