Sunlit strategy table with pale stone, greenery, and a calm abstract digital asset risk dashboard.
Protocols

Starknet Mainnet Upgrade History

A chronological, versioned index of every mainnet network upgrade with activation dates, block numbers, core SNIPs included, and breaking changes. Serves as the primary reference for operators to check the sequence and timing of state transitions, and for risk teams to audit the protocol's upgrade cadence and stability.
introduction
CHRONOLOGICAL NETWORK FORK INDEX

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.

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 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.

STARKNET MAINNET UPGRADE HISTORY

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.

AreaWhat changesWho is affectedAction

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

technical-context
TRUST AND COORDINATION

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.

WHO MUST ACT ON A STARKNET UPGRADE

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.

implementation-impact
STARKNET MAINNET UPGRADE HISTORY

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.

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.

STARKNET MAINNET UPGRADE HISTORY

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.

AreaWhat changesWho is affectedAction

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

STARKNET MAINNET UPGRADE HISTORY

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.

Chains We Build On

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 logo
    Ethereum
  • Arbitrum logo
    Arbitrum
  • Optimism logo
    Optimism
  • Polygon logo
    Polygon
  • Avalanche logo
    Avalanche
  • Cronos logo
    Cronos

Non-EVM ecosystems

  • Solana logo
    Solana
  • Sui logo
    Sui
  • Aptos logo
    Aptos
  • Hedera logo
    Hedera
  • Stellar logo
    Stellar
  • NEAR logo
    NEAR

Additional ecosystems

  • Polkadot logo
    Polkadot
  • Cosmos logo
    Cosmos
  • TON logo
    TON
  • Cardano logo
    Cardano
  • Algorand logo
    Algorand
  • Tempo logo
    Tempo

Also available for Base, appchains, custom EVM networks, and cross-chain product architecture.

STARKNET MAINNET UPGRADE HISTORY

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_syncing status: Call the JSON-RPC method starknet_syncing. A false result confirms the node is fully synced. A true result with a starting_block_hash and current_block_hash indicates 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.

Trusted by Industry Leaders

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

ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
ChainVote logo
Reax logo
Sokail logo
Swapsicle logo
SyntheX logo
Tekika logo
Telos logo
Zexe logo
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.
L
Lee Erswell
CEO, Telos Foundation
how to get started

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.

01

Exploration & Strategy

Define your product goals and choose the right blockchain architecture for your use case.

02

Architecture & Design

Design the smart contracts, tokenomics, and security parameters of your system.

03

Development & Integration

Build and integrate with wallets, oracles, and front-end dApps for a seamless experience.

04

Security & Launch

Comprehensive audits followed by a risk-managed mainnet deployment to protect your users.

Start a build

Need a blockchain engineering team?

Send the project context and we will respond with next steps, scope questions, and a practical path to delivery.