Decentralised News · 2027 planning series · Reviewed 21 November 2026
What Matters
A rollup recovery plan needs a state it can justify, a complete route from published data to that state, and enough processing capacity to catch up. A service returning successful responses establishes none of those by itself. For applications that trigger payments, orders or external jobs, reopening on an ambiguous history can create consequences that a later chain correction does not undo.
This article examines documented sequencing and finality architectures, then introduces a conditional backlog model. The planning question is how an operator distinguishes a stalled component from an unsafe assumption about recovery, and what evidence is still needed before applications resume their external actions.
The Signal
Names can hide different architectures. Astria describes a sequencing layer that orders rollup data without executing the rollup’s application logic. Espresso’s current Nitro integration describes chains keeping their own sequencer and execution stack while Espresso finalizes their blocks. A recovery procedure must identify the actual integration, network and software version before borrowing either model.
Start With the State the Application Relies On
Consider an automated purchasing agent. It receives a transaction acknowledgement, observes a balance change and starts an external delivery job. Those observations may come from different stages of the system. The business event is the delivery instruction, while the chain event is the state transition that justified it. A recovery review needs a link between them. A new RPC response is not enough to establish that the original justification still holds.
DN’s proposed recovery record therefore starts with a small question: which state was the last one this application was permitted to act on? Record its chain identity, height and hash, the acceptance rule, the evidence used, and the identifier of any external action already taken. These are proposed operational controls, not fields that every protocol exposes through the same interface.
Keep two inventories. One contains transactions whose accepted execution is established. The other contains submissions, acknowledgements and proposed actions still awaiting that evidence. Moving an item between inventories requires the declared acceptance rule. This prevents the queue length from becoming a substitute for deciding which work is valid.
Separate Ordering, Publication and Execution
Astria’s sequencing documentation also describes sequencer-native operations, including transfers and validator changes. That distinction matters: saying that a sequencer does not execute a particular rollup’s transactions does not mean it performs no execution at all. The relevant recovery question is which component applies the application’s state-transition rules.
Its relayer documentation describes collecting validated sequencer blocks, batching and compressing them, and submitting the result to the data-availability layer. A conductor can obtain sequencer data before that publication. The two delivery paths can therefore be at different stages without the application having received two equivalent forms of evidence.
The Conductor documentation describes checking finalized ordering, completeness and relevance of rollup data before forwarding it to execution. It also describes a commitment to the included rollup IDs: an omitted rollup must not look like one with no transactions. Its terminology distinguishes soft commitments obtained through the sequencer connection from explicitly verified firm commitments obtained through the DA layer. These are named architecture properties, not a universal definition for every service that advertises a confirmation.
For planning, map each handoff to an observable artifact. A block identifier belongs with its ordering evidence; a publication belongs with the data range and commitment; an executed state belongs with the runtime and derivation rule. If the artifacts cannot be linked, a status dashboard may be displaying several healthy components that have not demonstrated agreement about the same history.
| Observed boundary | Evidence to request | Question still open |
|---|---|---|
| Submission accepted | Request or transaction identifier and receiving component | Was this included in the history the application accepts? |
| Order established | Protocol-specific ordering evidence and relevant namespace | Can the complete required data be obtained and checked? |
| Data obtained | Verified range, commitments and absence/completeness checks | Does the intended runtime derive the expected state? |
| State derived | State commitment, version and checkpoint comparison | Does the application or bridge accept this state under its own rule? |
| Action resumed | Reconciled work identifier and duplicate-action control | Are new arrivals sustainable at the validated processing rate? |
This table is a DN analysis framework. It intentionally gives every observation a remaining question rather than assigning a percentage of safety.
Diagnose the Boundary Before Choosing a Recovery Action
Suppose an application stops seeing new accepted states. At least four hypotheses deserve separate investigation: ordering stopped; publication stopped; the local data reader has gaps; or execution cannot advance through otherwise available inputs. Those hypotheses can produce a similar user symptom but imply different work. Replacing a local reader does not resolve missing publication. Restarting execution does not decide which history is canonical.
Espresso’s Node API provides a useful concrete caution. It exposes the view of an individual node and describes that view as eventually consistent. Its height can reflect the latest known block while earlier blocks are missing. The API separately reports missing and pruned data. The operational inference is limited but important: a rising height is not evidence that the required historical interval is complete.
Keep observations scoped. Write “our reader has no verified payload for this interval” if that is what the evidence shows. Do not convert it into “the network lost the data” without further evidence. Similarly, distinguish a connection failure from a rejected proof and a rejected proof from execution under an unexpected version. Their resolution owners and recovery conditions differ.
For a named integration, inspect its additional dependencies. Espresso’s Nitro guide describes a batcher operating in a trusted execution environment and a signature checked by a modified Sequencer Inbox. It identifies liveness and fast-settlement bridge dependencies on that arrangement. The guide says removing the TEE dependency is a future update. This review does not treat that future state as an existing property or generalize the arrangement to every Espresso integration.
A Fallback Must Belong to the Protocol
An emergency path changes where a message enters the system. It does not give an operator permission to invent an alternative ordering rule. Before relying on a fallback, record the deployed contract or mechanism, who can use it, what event makes it available, and how ordinary nodes incorporate its output. If that evidence is unknown, label the fallback unknown.
Arbitrum documents a Delayed Inbox route on the parent chain and subsequent force inclusion after the applicable window. The page also identifies chain-owner access settings and states that chains can use different timing parameters. It is a concrete example of a defined alternate entry path. It is not evidence that an Astria rollup, or every chain using an external finality service, has the same mechanism.
Timing needs the same discipline. A configured deadline, the time a message actually entered the relevant inbox, and the time a local client noticed an outage are different inputs. Do not start a countdown from the incident chat message and call it a protocol deadline. Read the deployed rule and its current inputs; preserve the reference used to reach the conclusion.
Fallback execution can also alter the history an application previously saw. Arbitrum’s outage documentation explains that block production can continue during a batch-posting outage, while force inclusion can cause unposted blocks to be dropped. Recovery therefore includes reconciling provisional observations. A submitted transaction should not be treated as permanently executed merely because it once appeared in a fast feed.
Build a Recovery Record That Explains Its Checkpoint
DN proposes a four-part record. First, identify the recovery base: chain, accepted height and hash, software interpretation, and why that state is accepted. Second, identify the next required data interval and the method for checking its completeness and order. Third, identify the authorised recovery path. Fourth, identify the application actions that must be reconciled before processing resumes.
There is a deliberate distinction between recording a checkpoint and trusting a checkpoint. A convenient snapshot can reduce work only under an acceptance policy that permits it. If a team chooses a trusted snapshot, the record should name that trust assumption and its approval route. It must not quietly describe the result as independent replay from genesis.
For an application with external effects, attach an action identifier to each proposed effect. In a hypothetical procurement system, the relevant question is whether purchase instruction P-104 has already been sent, not merely whether a transaction with some similar payload appears again. A replayed event can be valid chain data while a second delivery instruction would be an application error. The precise reconciliation design belongs to the application.
The Arbitrum response runbook separately checks block production, batch posting and post-recovery backlog. That supports keeping these observations separate. Our additional proposal is to assign an owner and evidence reference to each transition in the recovery record, so “waiting” identifies a missing decision or artifact instead of concealing it.
For example, imagine a synthetic record naming checkpoint C-700 and a required interval of 701 through 760. The first reader supplies 701 through 724 and 730 through 760. A second reader reports height 760 but provides no missing payloads. Counting two responsive readers does not close the five-block gap. The next useful task is obtaining and validating 725 through 729 under the declared rule, or explicitly selecting an authorised recovery base that changes the verification assumptions.
After the gap closes, preserve the original observation and the replacement evidence. The incident record should explain why the status changed. That distinction helps a later reviewer separate a resolved data-access problem from an unrecorded decision to trust a different state. It also keeps a temporary workaround from silently becoming the permanent acceptance policy.
A Worked Backlog Budget, With Explicit Assumptions
The following numbers are synthetic. They do not measure Astria, Espresso, Arbitrum or any other network. Assume a single queue of comparable work units. There are 12,000 units already waiting when processing stops. During a 20-minute pause, 300 new units arrive each minute. After processing resumes, the system can complete 900 validated units per minute, and arrivals remain at 300.
The queue at restart is 12,000 + (300 × 20) = 18,000 units. Catch-up uses capacity left after new arrivals: 900 − 300 = 600 units per minute. Clearing the inherited queue therefore takes 18,000 ÷ 600 = 30 minutes. The interval from the start of the assumed pause to a cleared queue is 20 + 30 = 50 minutes.
That 50-minute result is conditional arithmetic. It does not predict how long evidence collection, protocol recovery or bridge acceptance will take. The pause input must include whatever interruption the scenario intends to model. If the checkpoint remains disputed, the number still describes an assumed queue but cannot establish a restart time.
Now reduce validated capacity to 300 units per minute. New arrivals consume all capacity, so the existing queue does not shrink. At 250, the queue grows. At 600, net capacity is 300 and catch-up takes 60 minutes, giving an 80-minute combined interval. This sensitivity is often more informative than a single attractive headline capacity.
Use one work unit consistently. Transaction counts are suitable only if their processing demands are comparable enough for the planning question. Acknowledgements per second cannot stand in for validated replay throughput. If workload mix changes materially, divide the queue into classes or build a richer model; this worksheet does not infer those weights for you.
Use the DN Recovery Backlog Planner
The planner separates queue arithmetic from evidence status. Enter a scenario alias, existing backlog, arrival rate, pause duration and sustained validated processing rate. Separately declare the status of the recovery checkpoint, required data interval and recovery path. Unknown or conflicting declarations remain visible even when the arithmetic is complete.
A documented declaration means the user says there is supporting evidence. The tool does not fetch a chain, authenticate a proof, inspect a node or approve an operational change. Empty numeric inputs remain missing; they are not silently converted to zero. A processing rate that cannot drain an existing queue produces an explicit unresolved catch-up result.
DN Recovery Backlog 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.
Reopen the Application in Deliberate Stages
DN’s suggested release sequence is to validate the recovery base, derive the intended history, reconcile previously observed actions, and then decide which application functions can reopen. Read-only access, new submissions, external effects and bridge activity can have different acceptance policies. Giving each one a named condition makes the residual interruption understandable.
During catch-up, compare the scenario with actual observations and revise assumptions rather than treating the original result as a commitment. If arrival rate rises, compute the changed net capacity. If a data interval is missing, identify that interval; do not hide the pause inside an averaged throughput number. If processing produces a different state commitment, stop the arithmetic from being read as a claim that recovery succeeded.
For an AI agent, the same distinction belongs in its allowed actions. It may be permitted to observe provisional data while waiting to issue an irreversible business instruction. That is a proposed application policy, not an inherent guarantee of an agent framework. The chain supplies evidence under its own rules; the application decides what evidence is sufficient for a particular action.
In another hypothetical application, historical reads can reopen after the selected state is verified, while new external fulfilment remains paused until the job ledger is reconciled. That is a partial restoration with an explicit boundary. Report it that way: state which functions resumed, which evidence they use, and which decision still blocks the rest. An undifferentiated “operational” status would discard information the application’s users need.
Choose the observation interval to match the decision. A momentary burst above arrivals does not demonstrate sustained catch-up capacity. Conversely, a deliberate pause for verification should remain identifiable instead of being treated as ordinary slow execution. The model is useful because its assumptions can be challenged individually.
DN Alpha Thesis
The useful advantage in shared sequencing is an intelligible recovery boundary. A team that can identify its last accepted state, explain the next derivation step and reconcile external effects can reason about reopening. A team that only watches uptime and maximum throughput cannot tell whether it has restored the service its application actually needs.
Methodology, Limits and Corrections
Primary documentation was reviewed on 21 November 2026. Astria, Espresso and Arbitrum illustrate different architectures; this article does not assert that their recovery mechanisms are interchangeable. No outage was induced, node benchmark run, live exploit reproduced or production recovery certified for this research.
The recovery record and queue calculation are original DN analysis. The model assumes a full processing pause followed by constant arrivals and constant validated service capacity, with homogeneous work and no further interruptions. It omits network-specific execution, proof, finality and withdrawal delays unless the user explicitly includes them in the scenario. Corrections should identify the network, integration version, affected claim and primary evidence so the article and its source register can be revised together.
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.
- Astria: The Astria Sequencing Layer — Separates ordering of rollup data from execution of a rollup state transition; includes sequencer-native operations.
- Astria: The Astria Conductor — Rollup-data completeness and order checks, rollup-ID commitment, and the documented soft/firm commitment distinction.
- Astria: Relayer — Batched publication from sequencer to the data-availability layer. This is an architecture description, not an outage measurement.
- Espresso: Nitro / Orbit integration — The chain retains its sequencer and execution stack. This documented integration describes a TEE batcher dependency; a future removal is not treated as deployed.
- Espresso: Node API — Local node view, possible historical gaps and sync-status fields. Endpoint height alone does not establish complete history.
- Arbitrum: Forced transactions — Delayed Inbox and chain-specific force-inclusion rules, including configurable access and timing. No universal waiting period is assumed.
- Arbitrum: Sequencer outages — Distinguishes sequencer downtime from batch-posting downtime and describes possible reorganisation of unposted blocks.
- Arbitrum: Respond to a sequencer outage — Operational observations for block production, batch posting and recovery. The DN queue model does not replace the implementation runbook.
Frequently asked questions
Does a shared sequencer execute every rollup transaction?
Not necessarily. Astria documents ordering rollup data separately from the rollup execution engine, while also executing sequencer-native operations. Identify the deployed architecture before assigning responsibility for state execution.
Does a rising API block height prove a node has complete history?
No. Espresso documents that its local Node API may know a recent block while older blocks are missing. A recovery review needs evidence for the required interval, not only the latest height.
Can every rollup use Arbitrum force inclusion?
No. Arbitrum documents a specific parent-chain inbox mechanism with chain-specific rules. Another integration needs its own documented fallback; this article does not establish that one exists.
What does the 50-minute worked example establish?
Only the queue arithmetic under the synthetic assumptions: a 20-minute pause and 30-minute catch-up. It does not establish a protocol recovery time, bridge reopening time or service guarantee.
Why does catch-up use processing capacity minus arrivals?
New work continues to consume capacity. Only the remaining capacity drains the inherited backlog. If processing cannot exceed arrivals, a positive backlog cannot clear under this constant-rate model.
Can the planner approve a restart after all evidence is marked documented?
No. Those fields are user declarations. The planner performs conditional arithmetic and preserves unresolved evidence; it does not verify checkpoints, authorise a fallback or release application actions.




