That is the harder standard for privacy infrastructure. A public-chain upgrade can often be diagnosed from visible state: a transaction failed, an event is absent, a balance moved incorrectly. In a shielded system, a node can correctly reject a private state transition without revealing whether the incompatibility sits in an old transaction encoding, a stale witness, an obsolete verifier key, an out-of-date DUST tree index or an application that reconstructed its state wrongly.

The Block reported in March that Midnight operates its own ledger, consensus mechanism, smart-contract environment and dual-token system, while retaining links to Cardano. That independence makes Ledger 9 consequential. Midnight can govern its own protocol change, but it also owns the operational burden of moving an ecosystem whose core privacy properties depend on closely matched software across several layers.

The upgrade guide records that Mainnet moved from Ledger 8 to Ledger 9 on November 6, 2026. Preview was relaunched as a new chain on November 7, while Preprod received an in-place transition on November 9. Those are three very different migration models. Mainnet preserved state. Preview discarded old chain history. Preprod retained its history but had to cross the new compatibility boundary. Midnight’s Ledger 9 upgrade guide says the compatible Mainnet set includes Wallet SDK 2.0.1, Midnight.js 5.0.1, Compact toolchain 0.36.1, proof server 9.0.2 and indexer 4.4.101.

The lesson is not that every participant must upgrade simultaneously. It is that every participant must know exactly what version relationship it has with the ledger.

Four boundaries, not one upgrade

The cleanest way to understand Ledger 9 is to separate four boundaries that can fail independently.

First comes consensus and block validation. Nodes must agree on the runtime, transaction decoding and state-transition rules. A node still running the old software does not merely expose an outdated API. It stops importing blocks at the upgrade point. That is a consensus-level outage.

Second is transaction construction and proving. Ledger 8 transactions do not decode on Ledger 9. Wallets and applications cannot rescue a pending Ledger 8 transaction by submitting it again after the switch. They must rebuild it under the new era and generate the compatible proof artifacts.

Third is application state and contract artifacts. A contract can remain deployed while its local artifact, generated verifier key or runtime assumptions become invalid. The source code may not have changed, but recompiling under a new proving representation can produce different verifier keys. The compatibility object is therefore not source code alone. It is source, compiler, runtime, circuit and deployed contract state together.

Fourth is off-chain reconstruction. Indexers, wallet caches and private-state stores make the chain usable. If they interpret state in an old layout, a chain can remain healthy while users see incomplete history, wrong DUST capacity or an unspendable local view of their own assets.

ARTIFACTS AND VERIFICATION RULESBLOCK INTERPRETATIONTRANSACTIONS AND PROOFSRECONSTRUCTED STATECONSENSUSAND NODESFailure:block importstopsTRANSACTIONBUILDER ANDPROVERFailure:transactionrejectedCONTRACTSANDVERIFIERFailure:artifactmismatchWALLETSANDINDEXERSFailure:stale localstateLEDGER 9VERSIONSharedcompatibilitytarget
Figure 1 - How Ledger 9 compatibility spans node behavior, proving artifacts, deployed contracts and off-chain state

The first layer received a coordinated but two-stage change. Midnight’s Node v2.1.101 release notes say operators first replaced node binaries, then governance applied the runtime upgrade that activated Ledger 9. The distinction matters. Installing the binary did not itself change the live ledger. It prepared the network to interpret the governance-triggered transition.

That model is reasonable for a governed chain, but it makes readiness a governance question. Validators, RPC providers and block producers had to be operationally prepared before the proposal took effect. The node documentation also warns that once the new binary has opened a data directory, the previous node version cannot start against it. Rollback is not a button. It requires a pre-upgrade snapshot or a fresh sync.

Privacy makes the proving boundary more brittle

Ledger 9 adds contract-to-contract calls, unshielded events, ECDSA verification, native Keccak support and secp256k1 primitives. Those are visible new capabilities. The subtler change is ZKIR version 3 across the Compact toolchain and proving stack.

The Ledger v9.1.0.1 release notes record that ZKIR 3.2.0 moves proofs to midnight-zk-stdlib v2 and midnight-circuits v7. They also say proofs and verifier keys made with the prior zk-stdlib remain verifiable, including Zswap verification of version 1 proofs. That is an important compatibility promise, but it is not universal artifact portability.

A contract compiled again under Compact toolchain 0.36.0 receives new verifier keys even where its source is unchanged. The newly generated artifacts no longer match the deployed contract unless a maintenance authority updates those keys. A contract without that authority may need redeployment. In privacy systems, this is a material governance constraint. Whoever controls maintenance authority controls whether an application can migrate in place, rather than forcing its users toward a replacement contract and a new state relationship.

PRIVATEWITNESSprivateprover inputPROVERZKIR V3circuitLEDGER 9TRANSACTIONproof andpublic dataDEPLOYEDVERIFIERKEYnetworkvalidationkeyLOCALVERIFIERARTIFACTrecompiledverifier key
Figure 2 - how a private witness stays with the prover while a proof is checked against a deployed verifier key for Ledger 9 verification

The exact failure message may be more useful than generalized retry logic. Midnight.js 5 can surface EraMismatchError for a Ledger 8 transaction sent to a Ledger 9 network. Wallet SDK 2 can return ProtocolVersionMismatchError. Those errors identify a compatibility failure before a user mistakes it for insufficient funds, a bad connection or a failed proof.

That distinction is especially valuable because privacy-preserving validation does not expose the private data that caused the failure. Operators need observability at the edges: protocol era, transaction format, proof-server version, artifact version, verifier-key hash and indexer height. They should avoid logging witnesses, private inputs or unshielded equivalents of user secrets.

DUST and indexers are recovery work, not housekeeping

DUST illustrates why wallet migration is more than a front-end update. Ledger 9 reset DUST state once. On Mainnet, registrations were replayed automatically to their full cap. But wallet developers still had to drop cached DUST tree indices when the protocol crossed to version 2000000 or higher, because the indexer did not send a dedicated reset event.

This is a sound example of a chain preserving economic state while requiring clients to invalidate derived state. The asset relationship remains. The local map used to reason about it no longer does.

Indexers faced the more severe form of that problem. Ledger 9 requires indexer 4.4.101 and a complete re-index from genesis because its contract-state layout cannot be converted in place. An older indexer can report DUST capacity incorrectly after the upgrade. A client also needs an explicit history offset if it expects historical contract actions, because a subscription opened without one receives only new actions.

Indexer Databasederived history
re-index from genesis; drop cached DUST indices
Wallet Cachelocal balance interpretation
restore local balance interpretation
Ledger 9 Readyvalidated local state restored

Invalidate derived state before serving Ledger 9 clients

Figure 3 - Recovery sequence for rebuilding indexer-derived state and wallet balance interpretation after the Ledger 9 upgrade

A production rehearsal should therefore have two success criteria. The first is that the network produces and validates Ledger 9 blocks. The second is that users can recover a correct local interpretation of their balances, contract history and DUST capacity without disclosing shielded inputs.

That means testing a deliberately mixed environment before activation: an old wallet against a new RPC endpoint, a new wallet with a stale indexer, an old transaction submitted after the switch, a pre-upgrade contract called with preserved artifacts, and a recompiled contract with changed verifier keys. Each produces a different incident class. Treating them all as “the upgrade failed” loses the information required to restore service.

What the upgrade revealed

The available critical reaction is narrow, and it should be described that way. OpenZeppelin maintainer 0xisk wrote that moving its Compact contracts tooling toward Ledger 9 was not a simple dependency update: it involved the ledger package, Midnight.js, the on-chain runtime, simulators, test utilities and Ledger 9 node images. The issue was labelled as blocking the release process, while the 0.4.0 line remained on a beta distribution tag before Ledger 9 reached mainnet.

No opposing external reaction was supplied. That does not prove broad agreement. It establishes only that the documented criticism found here concerns coordination cost across the toolchain.

Ledger 9’s practical achievement is that it makes those dependencies explicit. Its weakness is that explicitness does not eliminate operational risk. A compatibility matrix is useful only if teams rehearse it as an incident runbook: snapshot nodes, pin binaries and proof-server images, rebuild queued transactions, preserve contract artifacts, re-index from genesis, clear derived wallet state and monitor era-specific rejection codes.

The conclusion changes if Midnight can make those steps routine and automated without asking users to surrender privacy for diagnostics. That would mean version-aware wallets that recover state safely, indexers that signal reset conditions clearly, contract tooling that exposes verifier-key migration before deployment, and observability that identifies the failed compatibility layer without recording the private assumption beneath it. Only then does a privacy-chain upgrade become boring in the way production infrastructure should be.

#Midnight#Ledger 9#privacy#blockchain upgrades#zero-knowledge proofs#ZKIR#Compact#DUST#indexers#wallets#protocol compatibility#incident response

Jesica Davis is not a person. No notebook, no deadlines, no face behind the name — just a byline this newsroom publishes under. Here is the production line underneath it, because a name beside a portrait reads like a journalist, and this one is not one.

The models. Writing: gpt-5.6-luna and gpt-5.6-terra. Out on the live web: gpt-5.6-terra and gpt-5.6-luna. Pictures: gpt-image-1 and flux. Swap one in the newsroom and this line swaps with it — it is read off the machines, not typed here.

How a story is made

  • Research. The searching model reads around the story, pointed at primary sources — the filing, the post, the repository — rather than at somebody else's write-up of them.
  • Writing. The writing model drafts it against what was found, at Jesica Davis's usual length and in Jesica Davis's usual register.
  • The loop. A reviewer reads the draft and sends it back with notes. Then reads it again. A piece can go round several times before it leaves the building.
  • Enrichment. A quotation has to appear word for word on the page it is taken from. A chart may only use figures that appear in the source it cites. Whatever fails is dropped, and the reason is kept.
  • Fact check. A last pass hunts for claims the article makes and its sources do not.
  • A human stop. Sensitive subjects are held for a person to read before publication, and a person can kill any of it at any point.

If that sounds less like a newsroom and more like a factory: quite. It is called Press Factory.

This article was generated using AI and published automatically without human pre-publication review.

How this article was made

The article was produced by the Grandmonts Media News Engine using automated research, drafting and verification workflows. No human editor reviewed the article before publication. Grandmonts Media remains responsible for the published content. Errors can be reported at office@grandmonts.cz.