A Cosmos SDK, IBC-Go, or CometBFT release can contain dozens of changes, but only a small subset are state-breaking and require a coordinated network upgrade. For an appchain operator, the critical question is not "what is new in v0.47.x?" but "which specific changes in this release will cause my node to halt with a consensus failure if I don't execute a migration?" The State-Breaking Change Catalog answers this by isolating the exact pull requests, module refactors, and API removals that trigger the upgrade handler, allowing a team to move from a changelog to a scoped migration plan in minutes.

State-Breaking Change Catalog
Why a Breaking Change Catalog Matters
A structured catalog that maps network upgrades to their specific code-level breaking changes, enabling appchain developers to perform targeted impact assessments without reading full changelogs.
The operational risk of missing a breaking change is a chain halt. A validator that runs an incompatible binary will fail to process a block, stop producing consensus signatures, and incur downtime slashing. For exchanges and wallet providers, the risk is a silent desynchronization where transaction parsing breaks, balances become inaccurate, and deposits are lost. By maintaining a filterable catalog of breaking changes tied to specific SDK, IBC, and CometBFT versions, infrastructure teams can pre-verify their dependency stack against a target upgrade before the governance proposal even enters the voting period. This shifts upgrade preparation from a reactive scramble to a deterministic, auditable process.
The catalog also serves as a forensic tool for incident response. When a chain halts unexpectedly after an upgrade, the first diagnostic step is to identify which breaking change was mishandled. A structured record of past breaking changes—including the module affected, the nature of the state mutation, and the required migration logic—enables responders to rapidly isolate the root cause and coordinate a patch. Chainscore Labs uses this catalog as the foundation for diff-based impact assessments, where we analyze an appchain's codebase against a target SDK version and produce a precise list of required code and state migrations, eliminating the guesswork from upgrade planning.
Catalog Scope and Structure
How this catalog organizes state-breaking changes to help appchain developers identify the root cause of a required migration without reading full changelogs.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
Cosmos SDK Core | Module interface signatures, store key layouts, or genesis import/export logic that breaks state compatibility with prior versions. | Appchain core developers, node operators, and block explorers parsing historical state. | Review the upgrade handler deep dive for the specific SDK version; run a diff-based impact assessment on your codebase. |
IBC-Go | Light client verification logic, connection handshake semantics, or channel state machine changes that alter the IBC packet lifecycle. | Relayer operators, counterparty chain teams, and wallet providers tracking IBC transactions. | Verify IBC connection liveness after upgrade; audit relayer configuration against the new IBC-Go release. |
CometBFT Consensus | Changes to ABCI method signatures, block data structures, or evidence handling that require a coordinated validator upgrade. | Validator operators, sentry node architects, and monitoring tool maintainers. | Check the CometBFT version compatibility matrix; rehearse the upgrade with a testnet activation before mainnet. |
Interchain Security | Modifications to the provider-consumer handshake, validator set updates, or slashing packet logic that affect consumer chain sovereignty. | Consumer chain development teams and the Cosmos Hub validator set. | Coordinate consumer chain binary release with the provider's governance-triggered upgrade timeline. |
Amino to Protobuf Encoding | Deprecation of legacy Amino endpoints and transaction formats in favor of Protobuf, altering how transactions are signed and broadcast. | Exchanges, custodians, and indexers that construct or parse transactions. | Migrate transaction signing and parsing pipelines to Protobuf; test against both legacy and new endpoints during the transition window. |
Store Migration Patterns | In-place state transformations executed by an upgrade handler that can cause non-deterministic app-hash failures if written incorrectly. | Appchain architects writing custom migration logic. | Audit migration handler code for determinism and gas efficiency; verify state integrity with a dry-run against mainnet state. |
Governance Module | Changes to proposal types, voting periods, or deposit mechanics that alter the on-chain governance lifecycle. | Governance delegates, proposal submitters, and dashboard operators. | Update governance monitoring dashboards to track new proposal types and activation signals. |
What Qualifies as a State-Breaking Change
A precise definition of the code changes that force a coordinated network upgrade in the Cosmos SDK and IBC ecosystem.
A state-breaking change in the Cosmos SDK, IBC-Go, or CometBFT is any modification to the codebase that causes a node running the new version to compute a different AppHash for a given block height than a node running the old version. This deterministic state divergence triggers a consensus failure, halting the network until all validators restart with the patched binary at a coordinated upgrade height. The change is 'breaking' because it is not backward-compatible with the existing on-chain state; a simple binary swap without a coordinated migration will fork the network.
The root cause is typically a change to the state machine's deterministic execution logic. Common triggers include: modifications to a protobuf message schema without a proper migration, altering the key structure of a store, changing the logic of a state transition function (e.g., staking rewards calculation), or introducing a new module that requires an initial genesis state. For IBC, a breaking change can also be a modification to the light client verification logic or the connection handshake semantics, which would cause a counterparty chain to reject proofs. A change in the binary's serialization format, such as the Amino-to-Protobuf transition, is a classic example of a state-breaking change that required extensive migration handlers.
For appchain developers, identifying the exact state-breaking change in a new SDK release is the critical first step in planning an upgrade. It determines the complexity of the required migration handler and the risk of a consensus failure. Chainscore Labs performs diff-based impact assessments on an appchain's codebase to identify all required changes for a target SDK version, allowing teams to scope their upgrade work precisely and avoid the trial-and-error of reading full changelogs.
Who Is Affected by Each Breaking Change
Validator Operators
Validator operators are the most directly affected by any state-breaking change, as failing to upgrade before a specified block height results in a consensus failure, downtime slashing, and potential tombstoning.
Immediate Actions:
- Monitor the
upgrademodule'sPlanfor the exactnameandheight. - Build and verify the patched binary (e.g.,
gaiad,cometbft) against the correct Git commit hash. - Run the new binary on a sentry or backup node first to test state migration logic.
- Coordinate with other validators on a halt-time procedure to minimize missed blocks.
Risk: A misconfigured UPGRADE_NEEDED panic at the upgrade height will cause a node to halt. If a supermajority of voting power fails to upgrade, the chain halts entirely, requiring a manual genesis export and restart.
Chainscore can design a tabletop exercise for your validator set to rehearse the upgrade playbook and can implement automated monitoring to detect an impending upgrade height.
Impact Categories and Required Actions
A state-breaking change in a core dependency requires appchain teams to identify, plan, and execute a coordinated network upgrade. The following categories define the critical areas of impact and the immediate actions required.
Transaction Indexing and API Compatibility
Breaking changes often deprecate legacy Amino types, alter event emission, or restructure protobuf message schemas. Exchanges, block explorers, and indexers must update their parsing logic to handle new message types and removed fields. Failure to do so results in missed transactions or incorrect balance reporting. Chainscore can review your indexing pipeline against a target SDK version to identify all required parser changes before activation.
Wallet and Signing Logic Changes
New SDK versions may introduce new transaction signing modes, alter the sign bytes construction, or deprecate legacy key algorithms. Wallet providers must update their signing libraries to match the new canonical format, or users will be unable to broadcast transactions after the upgrade. This is a hard compatibility break for all front-end interfaces. Chainscore can assess your wallet's signing path against the target SDK's auth module to identify breaking changes.
Migration Risk Matrix
Map specific breaking changes to affected actors and required actions to prevent consensus failure or data corruption during a network upgrade.
| Area | What changes | Who is affected | Action |
|---|---|---|---|
In-Place Store Migrations | Module state schema is transformed by a migration handler during the upgrade. | Appchain developers, archival node operators, block explorers | Audit migration logic for determinism and gas consumption. Verify indexers can parse the new state schema. |
Protobuf Encoding | A module transitions from Amino to Protobuf for state serialization or message handling. | Exchanges, wallets, block explorers, IBC relayers | Update transaction parsing and signing logic. Verify IBC light client compatibility with counterparty chains. |
Module API Breaking Change | A module's Keeper interface, message server, or query service is refactored. | Appchain developers integrating custom modules | Refactor custom module code to match the new API. Run integration tests against the target SDK version. |
Consensus Parameter Change | CometBFT consensus parameters (e.g., block size, evidence age) are modified via migration. | Validator operators, node operators | Verify node configuration is compatible with new parameters. Monitor for unexpected mempool or propagation behavior. |
IBC Light Client Logic | The verification algorithm for a light client (e.g., Tendermint) is altered. | Counterparty chain teams, IBC relayer operators | Audit relayer configuration. Ensure counterparty chain's light client is updated before the connection expires. |
Genesis Export/Import | The format or content of the exported genesis file changes. | Validator operators, emergency response teams | Test the export and import procedure in a staging environment. Validate the new genesis against the target binary. |
Command-Line Interface (CLI) | A CLI command is removed, renamed, or its flags are altered. | Validator operators, devops teams, automation scripts | Update operational playbooks and scripts. Verify all automated tasks use the new command structure. |
Default Node Configuration | The default value for a node configuration parameter in app.toml or config.toml is changed. | Node operators, infrastructure teams | Review the diff between old and new default configs. Explicitly set critical parameters to avoid silent behavioral changes. |
Appchain Upgrade Scoping Checklist
A systematic checklist for appchain teams to scope the impact of a state-breaking change identified in the catalog. Use this to move from a known breaking change to a concrete migration plan without reading full changelogs.
Pinpoint the specific pull request, ADR, or specification change that introduced the breaking behavior. This is not just the symptom (e.g., 'app hash mismatch') but the root cause (e.g., 'Protobuf field renumbering in the staking module's Validator struct').
Why it matters: Misidentifying the root cause leads to incomplete migration logic. A state export/import cycle will fail if the migration handler does not address the exact data structure that changed.
Readiness signal: You can cite the exact commit hash, the module it affects, and the data structures that are modified. Cross-reference this against the Cosmos SDK, IBC-Go, or CometBFT changelog for the target version.
Canonical Resources
Use these sources to verify state-breaking changes before planning a Cosmos SDK, IBC-Go, CometBFT, Gaia, or appchain upgrade. Treat the catalog as an operational index, but confirm activation details against the release notes, governance record, and chain-specific upgrade handler.
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
Answers to common questions about identifying, planning for, and mitigating the impact of state-breaking changes in the Cosmos SDK, IBC-Go, and CometBFT.
A release is state-breaking if it modifies the on-chain state machine in a way that is not backward-compatible with the previous version's stored data. This typically requires a coordinated network upgrade with an upgrade handler.
Signals to check:
- The release notes explicitly state 'Consensus Breaking' or 'State Breaking'.
- The changelog includes changes to Protobuf message definitions, store key formats, or module genesis state.
- A new migration is required in the
UpgradeHandlerfor existing modules. - Core data structures (e.g.,
Account,Validator,Delegation) have been altered.
Why it matters: Running a state-breaking binary without a governance-approved upgrade plan will cause your node to halt with a consensus failure at the upgrade height, leading to downtime and potential slashing.
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.


