Developer reviewing smart contract architecture diagrams on a glass wall in a modern WeWork space, standing desk in background, natural industrial aesthetic, candid engineering moment.
Protocols

Backward-Compatibility and Breaking Change Policy

Defines the protocol's policy on backward compatibility for APIs, transaction formats, and smart contract interactions. A crucial risk-assessment resource for developers to understand the migration window and potential for application breakage during a network upgrade.
introduction
BREAKING CHANGE POLICY

Understanding Compatibility in the ZK Stack

A technical breakdown of the ZK Stack's formal policy on backward compatibility, defining what constitutes a breaking change, the guaranteed migration windows, and the operational impact for teams building on zkSync Era.

The ZK Stack defines a strict policy for backward compatibility to provide a predictable upgrade path for zkSync Era and other ZK Stack hyperchains. This policy distinguishes between the core protocol, which may introduce breaking changes with a mandatory migration window, and the Web3 API, which follows a deprecation-and-sunset cycle. The primary goal is to eliminate the surprise of 'silent' breaking changes, ensuring that wallet teams, bridge operators, and dApp developers have a clear, time-bound signal to adapt their software before an upgrade activates on mainnet.

A breaking change is formally defined as any modification that would cause a previously valid transaction, API call, or smart contract interaction to fail or produce a different result. This includes changes to the IAccount interface, modifications to system contract addresses or their public methods, alterations to the gas metering schema, and the removal of precompiles. Critically, the policy mandates that such changes are communicated with a minimum deprecation period, typically spanning several upgrade epochs, before the breaking logic is activated. This allows developers to deploy new wallet versions, update SDK dependencies, and migrate smart contracts to new interfaces without risking a sudden loss of liveness for their users.

For operators and integration partners, the breaking change policy shifts the risk from the moment of upgrade activation to the preceding migration window. The operational burden is on teams to monitor the protocol's versioning announcements and execute the necessary code updates before the deadline. Failure to do so can result in transaction submission failures from outdated wallets, incorrect fee estimation from unpatched SDKs, and a complete inability for users to interact with dApps that rely on deprecated system contract functions. Chainscore Labs helps teams manage this risk by providing breaking-change impact analysis and migration planning, ensuring that integration logic and smart contract code are updated and verified against the new protocol version before the compatibility window closes.

BREAKING CHANGE RISK ASSESSMENT

Compatibility Policy at a Glance

A structured view of the systems, actors, and integration points affected by zkSync Era's backward-compatibility and breaking change policy during network upgrades.

AreaWhat changesWho is affectedAction

Transaction Format

New EIP-2718-like transaction types or modifications to existing fields

Wallets, SDKs, block explorers, indexers

Update transaction construction and parsing logic before activation

System Contracts

Upgraded bytecode for Bootloader, DefaultAccount, or other precompiled system contracts

Wallet teams, dApp developers, prover operators

Verify new contract hashes and test core transaction flows against the upgraded contracts

Gas Metering

Changes to intrinsic gas costs, new pricing dimensions (e.g., storage, L2->L1 logs), or GasBoundCaller logic

Paymasters, wallets, dApps, fee estimation services

Recalibrate fee estimation models and test transaction success rates under new metering rules

State Tree / Storage Log

Alteration to the L2 state tree or storage log format

Archive node operators, block explorers, data pipeline teams

Plan for re-indexing historical state and update data infrastructure to parse the new format

Pubdata / DA Format

New compression or formatting logic for L2 state diffs posted to L1

Bridge operators, external provers, DA providers

Update L1 data reconstruction logic to ensure correct state derivation from new pubdata format

Node API

Deprecation or breaking change in the main node or external node JSON-RPC API

Infrastructure providers, indexers, scripted tooling

Audit API usage, migrate to new endpoints, and test against the latest node release

Inter-Chain Messaging

New cross-chain message types or changes to the L1Bridge contract interface

Bridge operators, liquidity providers, asset issuers on ZK Stack hyperchains

Review new message formats and test cross-chain settlement and withdrawal flows

technical-context
BREAKING CHANGE VECTORS

The Compatibility Surface: What Can Break

A technical map of the protocol interfaces, APIs, and contract behaviors that a zkSync Era upgrade can alter, and the downstream systems that must be validated for each.

A backward-compatibility policy on zkSync Era is only as strong as the definition of its compatibility surface. This surface includes every stable interface a builder, operator, or downstream system depends on: the JSON-RPC API, the L1 smart contract ABIs, the L2 system contract addresses and their IAccount and IPaymaster interfaces, the block and transaction formats, the gas metering and fee estimation logic, the state tree and storage log layout, and the pubdata compression and posting format. A protocol upgrade that modifies any of these vectors can break wallets, block explorers, indexers, bridges, centralized exchanges, or prover operators, even if the change is semantically backward-compatible at the execution layer.

The most common breakage vectors are not always the most obvious. A change to the bootloader or DefaultAccount implementation can alter how EOAs validate transactions, silently breaking SDKs that simulate eth_estimateGas or paymasters that rely on specific validation flow ordering. A modification to the ContractDeployer system contract can change the address derivation for CREATE2, breaking factory contracts and cross-chain deployment tools. An upgrade to the fee model that introduces a new pricing dimension, such as a storage-access cost, will cause every wallet and dApp that uses eth_gasPrice or eth_feeHistory to misprice transactions until their estimation logic is updated. Even a change to the L2 block structure, such as adding a new field to the block header, can break indexers and block explorers that parse raw block data without a version-aware decoder.

For operators, the compatibility surface extends to the node and prover software. A state tree migration that changes the Merkle tree version or the storage log format will force archive nodes and data pipelines to re-index historical state. A pubdata format change will break any external prover or bridge that independently reconstructs L2 state from L1 calldata or blobs. The Gateway upgrade path itself, which commits new bootloader and default account hashes through the ValidatorTimelock, is a compatibility event: any system that hardcodes these hashes for security verification must be updated in lockstep with the L1 transaction. Chainscore Labs helps teams map their specific dependency surface against each protocol upgrade, providing a breaking-change impact analysis that identifies exactly which components require code changes, configuration updates, or re-indexing before the activation epoch.

BREAKING CHANGE RISK ASSESSMENT

Impact by Stakeholder

Operational Impact

A breaking change in the state transition function or pubdata format requires a mandatory, synchronized client update. Operators must deploy the minimum required main node and prover versions before the activation epoch to avoid falling out of sync or generating invalid proofs.

Action Checklist:

  • Monitor upgrade activation timelines and epoch boundaries.
  • Validate new client versions in a staging environment against testnet data.
  • Plan database migrations if the storage log or state tree format changes.
  • Verify prover compatibility with new circuit logic to ensure uninterrupted proof generation.

Failure to update results in a chain split for the node and economic penalties for prover operators who miss proof submission windows.

implementation-impact
IMPACT CLASSIFICATION

Categories of Breaking Changes

Breaking changes on zkSync Era are not monolithic. They are categorized by the protocol layer they affect, each with distinct activation mechanisms, migration requirements, and operational risks. Understanding these categories is essential for planning upgrade responses.

02

Bootloader and DefaultAccount Changes

Upgrades to the bootloader or DefaultAccount implementation alter the fundamental transaction lifecycle, including validation, gas metering, and EOA behavior. These changes can break SDKs, wallets, and any tool that constructs or simulates transactions. Teams must update their transaction encoding logic and gas estimation models. Chainscore offers state transition verification audits to ensure client compatibility with the new bootloader logic.

03

State Transition and Circuit Modifications

Changes to the ZK circuit logic, precompiles, or the Executor facet alter how validity proofs are generated and verified. This is a critical breaking change for prover operators, who must deploy new prover software, and for any system reconstructing L2 state from L1 data, such as bridges and external nodes. Failure to update results in an inability to prove or verify the canonical chain. Chainscore provides circuit upgrade impact reviews.

04

API and Data Format Changes

Modifications to the node JSON-RPC API, L2 block structure, or pubdata compression format break all downstream indexers, block explorers, and data pipelines. New transaction types or altered log formats require parsers to be rewritten. Infrastructure teams must monitor release notes for format deprecations and plan re-indexing operations. Chainscore can assist with format compatibility testing and data infrastructure update planning.

05

Fee Model and Gas Metering Upgrades

Adjustments to intrinsic gas costs, new pricing dimensions (e.g., storage, L2->L1 logs), or changes to the GasBoundCaller logic directly break transaction cost estimation. Wallets, dApps, and paymasters will display incorrect fees, leading to stuck or overpaying transactions. All fee estimation logic must be updated immediately upon activation. Chainscore can audit fee model changes and help teams plan SDK and frontend updates.

06

Inter-Chain Communication Upgrades

Protocol-level changes to native bridging and messaging between ZK Stack hyperchains, including L1Bridge contract upgrades and new cross-chain message types. These changes can alter trust assumptions, finality guarantees, and the message format for cross-chain assets. Bridge operators and asset issuers must update their relayers and monitoring systems. Chainscore offers bridge security review and cross-chain integration testing for these upgrades.

BREAKING CHANGE IMPACT ASSESSMENT

Compatibility Risk Matrix

Identifies protocol components subject to breaking changes during zkSync Era upgrades and the affected stakeholders who must take action.

AreaWhat changesWho is affectedAction

Bootloader & DefaultAccount

Core transaction validation and gas metering logic is replaced

Wallet teams, SDK maintainers, node operators

Audit new bootloader hash and update transaction simulation logic

System Contracts

Precompile interfaces, ContractDeployer, or L1Messenger behavior is modified

dApp developers, bridge operators

Verify contract interactions against upgraded system contract addresses

Fee Model

Intrinsic gas costs, storage pricing, or L2->L1 log pricing dimensions are added or adjusted

Paymasters, wallets, exchanges

Update fee estimation logic and test against new gas metering rules

L2 Block & Transaction Format

New EIP-2718-like transaction types or block structure fields are introduced

Block explorers, indexers, data pipeline operators

Update parsing logic to handle new transaction type envelopes

Pubdata & DA Format

Compression scheme or state diff format posted to L1 is altered

External provers, bridges, DA providers

Re-validate L2 state reconstruction logic against new pubdata format

State Tree & Storage Log

Merkle tree structure or storage log format is changed

Archive node operators, indexers

Plan for full state re-indexing and verify historical state queries

L1 Gateway & ValidatorTimelock

Upgrade execution flow, timelock delay, or commitment of new hashes is modified

Security auditors, risk teams, bridge operators

Re-assess trust assumptions and verify upgrade execution permissions

Inter-Chain Communication

L1Bridge contracts or cross-chain message types are upgraded

Hyperchain operators, asset issuers, liquidity providers

Test cross-chain message passing and verify bridge asset security

BREAKING CHANGE PREPARATION

Migration Readiness Checklist

A structured checklist for infrastructure operators, wallet teams, and application developers to validate readiness before a breaking protocol upgrade activates on zkSync Era mainnet.

Identify the exact L2 block number or protocol epoch at which the breaking change activates. This is the hard deadline for deploying updated client software, system contract integrations, and compatible application logic.

  • What to check: The canonical upgrade announcement from Matter Labs or the ZKsync governance process, cross-referenced with the ProtocolUpgradeHandler or ValidatorTimelock on L1.
  • Why it matters: Missing the activation epoch means your node will diverge from the canonical chain, your prover will generate invalid proofs, or your application transactions will revert.
  • Readiness signal: Your operations team has a calendarized maintenance window before the activation epoch, and your monitoring system alerts on the approaching block number.
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.

COMPATIBILITY POLICY FAQ

Frequently Asked Questions

Common questions about how zkSync Era defines, communicates, and manages breaking changes across protocol upgrades, system contracts, and APIs.

A breaking change is any protocol modification that requires downstream software to be updated to maintain correct operation. This includes:

  • Transaction format changes: New EIP-2718-like transaction types or modifications to existing fields that alter how wallets and SDKs serialize transactions.
  • System contract interface changes: Modifications to the IAccount, IPaymaster, or IContractDeployer interfaces that require smart contract wallets or paymasters to be redeployed.
  • Gas metering and fee model changes: Adjustments to intrinsic gas costs, new pricing dimensions (storage, L2->L1 logs), or GasBoundCaller logic that break fee estimation in wallets and dApps.
  • Bootloader and DefaultAccount upgrades: Changes to the core transaction validation or execution flow that alter EOA behavior.
  • State tree or storage log format changes: Modifications that require archive nodes, indexers, and block explorers to re-index historical state.
  • L1 bridge or gateway contract upgrades: Changes to the canonical bridge interface that affect asset custody, withdrawal proofs, or cross-chain messaging.

Teams should monitor the Network Upgrades and Forks content group for activation timelines and specific technical details of each breaking change.

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.