Decentralised News · 2027 planning series · Reviewed 21 November 2026
What Matters
A sovereign rollup can let its community choose the software rules under which nodes accept its history. That choice does not automatically update a bridge, an application client or a service that consumes the resulting state. The practical upgrade question is therefore: which participants must accept the same transition, and what evidence establishes their agreement?
This article builds a method for mapping that acceptance. Sovereignty describes who chooses the technical rules. Its value depends on whether the proposed transition reaches the nodes, bridges and applications that the service needs.
The Signal
Celestia’s introduction separates the DA chain’s ordering and publication role from the sovereign rollup nodes’ validation of their own state. It describes upgrades through new software that nodes can choose to adopt. That is a different authority boundary from treating a settlement contract on another chain as the source of the canonical rollup state.
Sovereignty Identifies a Decision Boundary
Ask a narrow question before evaluating the label: what makes a proposed state valid for this participant? A full node may apply its configured runtime and fork-choice rules. A bridge may accept messages only through a particular verifier. A trading or fulfilment application may rely on a service whose acceptance policy is narrower still. The answer can differ across participants without any participant being confused about its own rules.
DN’s proposed review starts by naming the state consumer. “The rollup upgraded” is insufficient for a team deciding whether its payment receiver should accept new messages. The relevant statement is that a specified consumer, running specified rules, accepts a specified branch and transition. This replaces a broad sovereignty claim with an operational question that can be investigated.
Separate who proposes a change, who authorises its deployment, who runs it, and who accepts its output. Those roles may overlap, but they need not. Count neither downloads nor a governance announcement as proof that every critical consumer has moved. An upgrade can be widely supported while a necessary application dependency remains on a different interpretation.
Choosing a Fork Does Not Choose Everyone Else’s Fork
The 2022 primary design essay Rollups as Sovereign Chains explains a canonical chain selected by the rollup’s node network rather than an enshrined external settlement layer. It also discusses bridge upgrade paths that can acknowledge a hard fork. Read it as an architectural explanation, not evidence that a particular deployed bridge already supports an arbitrary upgrade.
The useful implication is that local autonomy and interoperability are separate decisions. One group can adopt new validation rules while another keeps old ones. A service connecting them needs an explicit answer about which state it accepts after the transition. Merely describing both groups as part of the same community does not resolve that interface.
For example, suppose a hypothetical upgrade changes how an account balance is computed. A new node may accept a resulting state that an old node rejects. If a downstream consumer still uses the old interpretation, the existence of new valid blocks on the upgraded branch does not establish that consumer’s acceptance. The operator must identify whether the consumer needs a software change, a verifier update, a new trusted checkpoint or another documented transition.
A branch identifier also needs more precision than a product name. Record chain identity and the relevant genesis or checkpoint commitment, the activation boundary, and the runtime or verifier version. Where identifiers are reused across a fork, state explicitly how the intended branch is distinguished. A familiar endpoint URL is not a substitute for that record.
Build the Upgrade Acceptance Map
DN proposes a map organised by consumers rather than organisational teams. Each row states what is changing, whose acceptance is needed, the evidence for that acceptance, and what remains unresolved. A named owner is useful because an unknown item can then be assigned a concrete next action. The map should be versioned with the proposed release.
| Consumer or boundary | What must be identified | Evidence that answers the question |
|---|---|---|
| Rollup node | Accepted branch, runtime and activation rule | Versioned configuration plus a reproducible state-transition or replay result |
| Proof or attestation consumer | Statement, verifier and accepted state commitment | Compatibility evidence for the proposed transition, with assumptions recorded |
| Destination bridge | Origin identity, message format and destination acceptance policy | Deployed configuration and a scoped end-to-end acceptance rehearsal |
| Application client | Endpoint identity, transaction format and state interpretation | Client release and evidence for the operations it must perform |
| Historical reader | Old and new data ranges and their verification boundary | Retrieval and reconstruction evidence for the required history |
These are proposed review artifacts. They do not certify a network or require every architecture to implement the same components. Mark a consumer inapplicable only with an architectural reason. An unexamined bridge is unknown, even if the person completing the map does not operate it.
Suppose the synthetic map shows node N accepting branch B, application C reading branch B, and bridge D still configured for branch A. Two completed rows do not offset the third. The remaining task is to establish D’s intended policy and supported transition, or to limit the upgrade’s declared service scope so it does not promise that route. A count of completed rows cannot answer that decision.
Preserve disagreement as disagreement. If the release note names one activation height but the deployed configuration names another, do not choose whichever produces the more convenient schedule. Record both references, assign a reconciliation owner, and update the map when the authoritative rule is established. That gives the planning process an explicit unresolved state instead of a hidden assumption.
Runtime Flexibility Creates a Compatibility Question
The Sovereign SDK introduction describes a configurable Rust runtime and support for changing DA or zkVM components. It also distinguishes sequencer execution from later data publication and verification by other participants. This documents a framework’s design flexibility. It does not demonstrate that moving a particular running network preserves all historical state, message interfaces and consumer assumptions.
Its module catalogue lists separate components for accounts, transaction uniqueness, chain state, proving or attestation roles, and Hyperlane integration. That provides a concrete reason to inspect more than the application feature being changed. A release affecting transaction interpretation can have a different compatibility surface from one that only adds a read-only API.
For a proposed upgrade, write a change description in terms of observable consequences. Does an old transaction still decode? Does applying the same prior state and input produce the intended new state? Is that change expected at the declared activation boundary? Can a consumer distinguish a rejected old-format message from a temporary service failure? These questions are a DN review method, not an assertion that a named SDK fails them.
Include negative cases in the rehearsal. A consumer accepting the new format is only part of the result; it should also handle messages that the upgrade intends to reject. Record the expected outcome before running the case. Otherwise, a test that merely returns something can be misread as evidence that the transition preserves the intended policy.
A Bridge Has Its Own Acceptance Rule
Celestia’s bridging discussion distinguishes designs according to the connected chains and their verification capabilities. Sovereignty alone does not specify which bridge exists, who can change it, or what it checks. A review therefore needs the actual route rather than a general statement that sovereign rollups can bridge.
For a concrete message-processing example, Hyperlane documents a destination Mailbox passing a message and its metadata to the recipient’s Interchain Security Module before delivery. Its ISM overview explains that applications can use a default or application-specific module, including configured or composed modules. This is evidence that the destination’s verification configuration matters. It is not evidence that every Hyperlane application verifies a sovereign rollup’s entire execution history.
For the upgrade map, record the destination network, recipient, applicable verifier configuration and the origin identity it accepts. Record who can change each part and the applicable activation process from that deployment’s evidence. If the bridge requires a new configuration, “the rollup nodes are ready” leaves a separate task outstanding.
Consider a hypothetical fork that copies local token balances. Copying those entries does not make a destination bridge execute an additional asset release. The bridge’s own state, message checks and release logic still determine what it does. The upgrade team should demonstrate which branch’s messages the relevant destination accepts, rather than describing duplicated local entries as duplicated external backing.
Pause and resumption also need separate descriptions. A bridge may accept an upgrade only after a defined transition, or may not support it at all. Unknown acceptance should remain unknown. An analysis tool cannot turn it into a short delay by assigning zero hours to the missing work.
A DA Migration Needs an Old-History Story
Changing a data adapter in software and migrating a running history are different scopes of work. DN proposes dividing the migration record into an old prefix, a transition boundary and a new suffix. Identify where each range is retrieved, how it is authenticated, and which accepted state links the ranges. If the plan starts from a trusted checkpoint, state that assumption explicitly.
A current testnet example makes the distinction tangible. Celestia’s Mocha documentation says Mocha-5 started from a new genesis and that Mocha-4 history and rollup blobs are not retrievable on the new network. It describes limited carried-over state rather than continuity of the entire previous network. This is a documented testnet transition, not a claim about Celestia mainnet or any sovereign rollup’s migration.
The inference is operational: changing an endpoint and obtaining fresh blocks does not establish access to the required earlier history. Celestia’s DA FAQ separately distinguishes publication availability, historical retrieval and derived state. An upgrade plan that depends on replay must identify how its required history remains retrievable, or explain the alternative checkpoint trust model.
Do not assume an archive is useful merely because it returns bytes. The recovery process also needs a way to associate those bytes with the intended chain and verify them under the selected rules. Conversely, a commitment without retrievable inputs may establish an identifier while leaving reconstruction unfinished. This article’s map records that dependency; DN’s separate data-placement research addresses retention budgeting in more detail.
Budget the Activation Window After Declaring Dependencies
Unknown acceptance and unfinished work are different. The first is an evidence gap; the second can be estimated once the scope and dependencies are understood. DN’s planner keeps them separate. It provides a narrow scheduling model for three branches that begin at a common authorised planning point: node and state validation, bridge acceptance preparation, and client rollout preparation. A joint rehearsal follows all three.
Use the model only if those branches can actually proceed in parallel. If bridge work waits for a node result, or client work waits for a final message format, that dependency changes the calculation. Do not conceal it by putting an optimistic duration into the parallel model. Select the unsupported-dependency option and build an appropriate schedule outside this worksheet.
In a synthetic example, node preparation takes 18 hours, bridge preparation 30 hours and client preparation 12 hours. The parallel work finishes after the longest branch, 30 hours. Add a six-hour joint rehearsal: the conditional budget is 36 hours. Against a declared 48-hour window, that leaves 12 hours of scheduling slack.
Now suppose bridge preparation takes 45 hours. The same model gives 45 + 6 = 51 hours, a three-hour shortfall. Faster node work would not fix that shortfall because the bridge branch remains the longest. The useful next question is whether the bridge scope, dependency plan or activation window must change, not whether the average task duration looks acceptable.
These hours are invented planning inputs, not measured upgrade times or provider commitments. Slack is arithmetic room within a declared window; it is not a probability of success or a security margin. The model excludes any authorisation process or waiting period that precedes the common start, and any later operational work outside the declared rehearsal scope.
Use the DN Upgrade Dependency Planner
Enter the durations, available window and scenario alias, then record the evidence status for change authority, branch identity, transition validation and consumer acceptance. If the parallel dependency model is unknown or unsuitable, the tool withholds its schedule. If evidence is unknown or conflicting, that remains explicit even when the conditional arithmetic fits.
A zero-duration branch needs a reason. For example, a synthetic application with no external bridge can mark the bridge branch inapplicable and record the architectural reason. A deployed bridge whose owner has not responded is not inapplicable. It remains an unresolved consumer, with no justified duration until the work is defined.
DN Upgrade Dependency Planner
Change the illustrative assumptions below. This worksheet runs locally in your browser. It records your declarations; it does not verify evidence, connect to accounts, submit instructions or grant approval.
The initial numbers are synthetic. Unknown evidence remains unresolved. Downloads contain the values you enter; use aliases and avoid private or identifying information.
Activation Is a Recorded Change in Acceptance
Before activation, preserve the intended transition record and the observed rehearsal result as separate artifacts. After activation, compare observed consumers with the planned versions and state commitments. A successful test is evidence for its tested configuration; it does not automatically cover a different binary, verifier or endpoint introduced during deployment.
Describe rollback with equal care. Returning to old software may be insufficient if new state has already been accepted or external effects have occurred. The proposed response must say which history each consumer will accept, which messages remain valid, and how application actions are reconciled. This is a question for the selected architecture, not a universal command that the worksheet can generate.
For an AI application, record the same boundary in its action policy. It may continue observing a proposed branch while withholding actions that require an accepted bridge or validated state. That is a deliberate application choice. Neither the word “sovereign” nor an automated governance label establishes that the required downstream decisions have been made.
DN Alpha Thesis
The practical value of sovereignty is the ability to make explicit choices about execution and acceptance. Its operational cost is carrying those choices through every consumer that matters. A useful upgrade plan identifies whose agreement is needed, what evidence demonstrates it, and which dependencies set the activation window. Control becomes meaningful when its boundaries can be inspected.
Methodology, Limits and Corrections
Primary documentation was reviewed on 21 November 2026. The 2022 Celestia essay supplies a foundational design argument; current product documentation supplies named implementation examples. These sources do not establish the configuration, governance authority or upgrade readiness of an unspecified live rollup. No chain migration, bridge transaction or deployment test was performed for this article.
The acceptance map and scheduling example are original DN analysis. The tool is local conditional arithmetic with user-declared evidence; it cannot inspect a chain, verify a proof, grant authority or activate software. It evaluates no legal status and produces no security score. Corrections should identify the exact network, deployment version, affected boundary and primary evidence, so that an implementation-specific change is not mistaken for a rule about all sovereign rollups.
Sources and evidence register
Primary sources reviewed on 21 November 2026. The article distinguishes documented facts, DN analysis and synthetic examples. Recheck changeable rules and configurations before acting.
- Celestia: An introduction to sovereign rollups — Execution and settlement responsibilities, node verification and the ability to accept or decline a software fork.
- Celestia: Rollups as Sovereign Chains, 7 July 2022 — Foundational design discussion of local canonical-chain choice and optional bridges with an upgrade path. It is not a current deployment attestation.
- Celestia: Misconceptions of sovereign rollups — Explains that bridge assumptions depend on the design and the capabilities of the connected chains.
- Sovereign SDK Book: Introduction — Configurable runtime and DA/zkVM components, with execution and verification roles. SDK flexibility does not establish a completed live migration.
- Sovereign SDK Book: Prebuilt Modules — Named modules for accounts, transaction uniqueness, chain state, proof or attestation roles, and Hyperlane integration.
- Hyperlane: Receive a message — Destination Mailbox processing and verification by the recipient ISM before delivery.
- Hyperlane: ISM Overview — Application-specific message verification and configurable, composed or custom security modules.
- Celestia: Mocha testnet — Current Mocha-5 documentation distinguishes a new genesis from previous-network history. This is a testnet example, not a sovereign-rollup or mainnet migration claim.
- Celestia: Data availability FAQ — Separates publication availability from historical retrieval and derived state.
Frequently asked questions
What makes a rollup sovereign in this article?
Its own node community determines accepted execution rules and canonical state rather than an enshrined external settlement contract. The term identifies a technical authority boundary; it does not establish legal immunity or universal privacy.
Does a sovereign rollup upgrade automatically update its bridges?
No. A destination bridge or message recipient applies its own acceptance configuration. The upgrade plan needs evidence that the particular route accepts the proposed origin, messages and transition.
Does changing a DA adapter prove that a live migration is complete?
No. Software support is only one part of the plan. The old history, transition checkpoint, new data range and affected consumers need their own retrieval, verification and compatibility evidence.
Why does the planner use the longest preparation branch?
The declared model assumes three branches start together and run in parallel, with a joint rehearsal after all finish. Under that assumption, the longest branch determines when rehearsal can begin. Different dependencies need a different schedule.
What does 12 hours of slack mean in the worked example?
Only that a synthetic 36-hour schedule fits inside a declared 48-hour window. It is not a measured upgrade forecast, a security buffer or a probability of successful activation.
Can unknown bridge acceptance be entered as zero hours?
No. Unknown acceptance is an unresolved evidence item. A branch can be marked inapplicable only when that reflects the architecture and a reason is recorded; an unanswered dependency is not inapplicable.




