Ordering by Unanimity: Giving Applications Sequencing Rights Without Breaking Composability

Andrea Canidio

REVIEW 3 major objections 5 minor 16 references

Ordering by Unanimity: Giving Applications Sequencing Rights Without Breaking Composability

T0 review · 3 major / 5 minor · reviewed 2026-08-02 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Unanimity override lets blockchain applications specify and protect their own transaction order, and the paper proves exactly which preferences no ordering rule can protect.

desk verdict Solid formal core with an overstated abstract: the local gating condition used in the abstract is not what Proposition 2 proves, and the paper's own Fig. 2 shows an honest cycle that the abstract's guarantee would wrongly protect. read the letter →

arxiv 2607.06144 v3 pith:7BZWSP36 submitted 2026-07-07 cs.DC econ.TH

Andrea Canidio This is my paper

classification cs.DCecon.TH

keywords blockchaintransactionorderingunanimityoverrideapplicationpreferencescomposabilityfront-runningcycle-breakingfallbackgatedtransactionspriority-fee

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Blockchain applications often need transactions to run in a particular order — an oracle update before a swap, a cancellation before a market order, bids from highest to lowest — but the underlying chain, not the application, currently picks the order. The paper proposes unanimity override: whenever every application with a stake in a pair of transactions agrees on their relative order, the protocol follows that agreement; a default order settles ties, and a fallback breaks preference cycles by demoting multi-opinion transactions. Against any attacker who controls the default order, deploys applications, and injects transactions, the paper proves that single-opinion transactions always execute according to their application's preferences, and that gated transactions — those no attacker-crafted transaction can outrank — always execute as the applications unanimously prefer, even when they touch many applications. It then proves the boundary is tight: for multi-opinion transactions gated neither above nor below, applications can genuinely disagree, so no ordering rule of any form can guarantee their preferences. If correct, the rule gives applications sequencing rights without isolating them on their own chain, and it tells senders in advance which transactions will execute in the intended order — subject, as the paper notes, to interaction domains being known or declared before execution.

What carries the argument

The load-bearing object is the unanimity relation, which ranks transaction x above y when every application that interacts with both weakly prefers x and at least one strictly does. The unanimity override algorithm first computes this relation, then uses a fallback that breaks cycles by 'demoting' multi-opinion transactions — removing their unanimity comparisons and placing them below the non-demoted transactions, with the default order ranking the demoted ones — and finally completes the repaired acyclic relation into a total execution order via a topological-sort procedure that uses the default order as a tie-breaker. The key structural fact is that every unanimity cycle contains at least

What would settle it

Simulate the protocol under the paper's exact threat model with a block containing a single-opinion transaction x whose sole opinionated application ranks x above an attacker-controlled transaction y; let the attacker control the default order, craft extensions of y, and bundle interactions, but not change honest applications' rankings or remove honest transactions. Enumerate all feasible strategies: if any strategy makes an extension of y execute before x while x remains single-opinion, Proposition 4 is false. The paper's proof says no such strategy exists, so this search would settle the cen

Watch

Extended reading notes

Core claim

The paper's central claim is that a simple protocol rule can enforce exactly the application-ordering preferences that survive two attack channels — cycle creation plus demotion, and replacement plus topological-sort completion — and that this boundary is tight. Under unanimity override, every strict comparison whose higher-ranked transaction is single-opinion is preserved no matter what an attacker does (Proposition 4); gated transactions, which no attacker-crafted transaction can be made to outrank, preserve every unanimous comparison in which they rank above another transaction, even a multi-application one (Proposition 2); and a symmetric guarantee holds for transactions the applications

Load-bearing premise

The guarantees hold only if the protocol knows, before execution, which applications each transaction interacts with: the paper assumes these interaction domains are given or declared, and its Section 8 concedes that deriving them from actual execution behavior is an unsolved fixed-point problem whose failure would strip single-opinion and gated transactions of their protections.

Editorial extensions

If this is right

Oracle updates and cancellations, including cancellations spanning several markets, qualify as gated transactions: they execute before any transaction an attacker can craft, so applications like price-feed AMMs and order books get their required ordering without a dedicated chain.
An on-chain auction works when bids are sent as single-opinion transactions: the highest bid reaches the auction first under any attack, and bidders have an incentive to keep bids simple because routing through a second opinionated application forfeits the guarantee.
An application that currently gets sequencing by running its own rollup can instead run on the shared chain and keep the same ordering guarantee for its own transactions, while still composing with non-opinionated applications.
Transactions over which no application expresses a preference keep the same front-running protection as a priority-fee market: another transaction can jump ahead only by paying a strictly higher fee.
The guarantees extend to any Paretian aggregation rule, provided cycles are broken by discarding non-unanimity comparisons before any unanimity comparison is demoted.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Because the formal results take interaction domains as declared, an implementation may over-declare: a transaction that actually touches one opinionated application but declares two is treated as multi-opinion, losing the Proposition 4 guarantee and becoming eligible for demotion. The protected set in practice is then smaller than the true interaction structure would allow.
The fixed-point problem Section 8 leaves open — deriving domains from actual execution with existence, uniqueness, and cheap verification — is the natural path to restoring the strongest guarantees; a practical solution would let the gated guarantees track real interactions rather than declarations.
The paper studies only the default-order-based demotion rule; topology-aware demotion rules that use the structure of the cyclic component could shrink the attacker's cycle-creation options, and comparing their guarantees under the same threat model is a testable extension.
The impossibility result suggests that any richer Paretian rule changes which preferences survive a conflict, not whether conflicts exist; the practical design question is therefore less about aggregation and more about helping senders route transactions into the protected single-opinion or gated classes.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague — quick read of 2607.06144. The headline guarantees as stated in the abstract are not quite what the theorems prove. Proposition 2 protects X*, the largest set satisfying unreachability and acyclicity under all attacker strategies. The abstract and Section 4.2 define gated by a local condition: no transaction the attacker can craft ranks strictly above. That is not sufficient. The stress-test counterexample is real and comes from the paper's own Fig. 2: three honest applications with R empty; every transaction satisfies the local condition vacuously, yet the unanimity relation contains a cycle and the fallback demotes one of them. X* is empty, so the abstract's second guarantee, as written, is false. This is not a formal refutation of the theorem — Proposition 2 is correctly proved — but it is a serious presentation problem: the paper tells applications in advance which transactions are protected, and the local condition does not identify X*. The acyclicity part is doing real work and cannot be characterized by local attacker reach alone.

Credit where due: the unanimity-override mechanism is new relative to the cited literature, and the three-way characterization (single-opinion guarantee, gated guarantee, impossibility for the residual class) is the right way to frame the problem. I checked Lemmas 1–3 and Propositions 1, 2, 4, 5; the central arguments are sound. The impossibility construction via decomposition and bundling is clean. Section 8 is honest about the interaction-domain fixed-point problem. The paper is also careful about what depends on censorship resistance.

Soft spots, in proportion. The abstract overclaim is the main one and should be fixed before publication. Proposition 6 has a small gap: the proof says a no-opinion transaction is kept unchanged, which fails if the attacker controls that baseline transaction; the intended honest-sender claim is fixable by adding x outside C or replacing the statement. Lemma 1 is explicitly informal, and while the weaker statement used later is enough, a formal proof would help. The gating region X* is defined by a fixed point over all attacker strategies; the paper does not give a direct way to check membership, and that matters for the 'tells senders in advance' promise. Over-declaration of interaction domains is acknowledged and is a real cost, not a hidden flaw.

Who this is for: anyone working on application sequencing, order fairness, or MEV. It deserves a serious referee. I would send it out, with the expectation of revision on the abstract, Section 4.2 wording, and Proposition 6.

Referee Report

3 major / 5 minor

Summary. The paper proposes a blockchain transaction-ordering rule, 'unanimity override', under which the execution order respects application unanimity whenever this is acyclic, with a default order breaking ties and a 'demotion' fallback breaking cycles. The main claimed guarantees are: (i) single-opinion transactions are always ordered according to their sole opinionated application (Proposition 4); (ii) 'gated' transactions — informally, those no attacker-crafted transaction can outrank — always execute as the applications unanimously prefer (Proposition 2); and (iii) no ordering rule can protect multi-opinion transactions that are gated neither above nor below (Proposition 5). The paper also analyzes front-running costs relative to priority-fee ordering, extends the guarantees to Paretian aggregation rules, and discusses how interaction domains are determined.

Significance. If the results hold, the paper makes a valuable contribution to the blockchain ordering/MEV literature: it gives a simple, composable mechanism with nontrivial provable guarantees against a strong adversary who controls the default order, deploys applications, and injects transactions. The derivations are parameter-free; there is no calibration or data fitting, and the impossibility result is a crisp, falsifiable statement. The distinction between the two attack channels (cycle-creation-plus-demotion and replacement-plus-Kahn-completion) is insightful and likely to influence follow-up work. The formal apparatus — Lemma 1, Propositions 2–5, and the fixed-point discussion in Section 8 — is mostly sound and clearly presented.

major comments (3)

[Abstract and §4.2 (before Prop. 2), with Fig. 2] This is a load-bearing mismatch between the advertised result and the formal theorem.
[§8, 'Actual interactions'] The ex-ante guarantees of Propositions 2 and 4, and the ex-ante impossibility of Section 5, all presuppose that the interaction domains X_t are known before execution. Section 8 explicitly concedes that deriving X_t from actual execution behavior is circular and that the fixed-point problem's existence, uniqueness, and cheap verification are 'left for future work.' The declared-interaction alternative avoids circularity but, as the paper notes, causes over-declaration: a transaction that in reality touches one opinionated application may be treated as multi-opinion and thereby lose the Proposition 4 guarantee and become demotion-eligible. Since the paper's title and introduction promise that applications and senders can know 'in advance' which transactions will execute as intended, this limitation is significant for the central claim's practical scope. I would ask the authors to state cl
[§4.2, Proposition 4 statement] The statement of Proposition 4 reads 'for every z∈X^σ: U_t(x_i)>U_t(z) =⇒ x_i ≻^σ_e z', but U_t is defined only on X_t, the interaction domain of application a_t. For z∉X_t, U_t(z) is undefined. The proof in Appendix A.6 correctly restricts to z∈X^σ∩X_t. Please adjust the proposition's quantifier to avoid this domain error, e.g., 'for every z∈X^σ∩X_t'. This is a formal presentation issue, but for a theorem statement it matters.

minor comments (5)

[§1 and §4.2] The informal definition of 'gating' appears in three different forms: the abstract, the introduction's second guarantee, and the pre-Proposition-2 paragraph. Please unify them with the formal X* definition to avoid the mismatch described in the first major comment.
[§4, 'Baseline profile and replacement'] The definition of a 'successful attack' on a target pair (x_i,x_j) says 'κ_σ(x_j) ≻^σ_e x_i', but if x_j is replaced, the target pair originally involved x_j; the phrase 'tracks the stand-in κ_σ(x_j) but the original x_i' is clear enough, but the notation 'x_j' is overloaded. A brief clarification would help.
[§3.1.1, Lemma 1] The proof of Lemma 1 is labeled 'informal' and the text says 'the derivations below use only a weaker statement: a cycle cannot exist without multi-opinion transactions.' Please make the weaker statement a standalone lemma and move the informal proof to a remark; the current presentation is slightly confusing.
[§7, Proposition 8] The proof of Proposition 8 uses the claim that every imposed comparison has a corresponding directed path of unanimity comparisons with the same endpoints. This is true in the original strongly connected component, but the proof should explicitly state that the path may use vertices that are later demoted, and explain why the argument still yields a contradiction. As written, a reader may doubt the step.
[General] There are several minor typos, e.g., '⇐ ⇒' in the definition of Pareto principle and the duplicated 't' in Proposition 5's 'a_t and a_t′'. A copyedit would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the guarantees are proved from explicit structural assumptions; the only circular definition in the paper is acknowledged and non-load-bearing.

full rationale

The derivation chain is self-contained. Sections 3-4 define unanimity override and prove Propositions 1-4 from explicit assumptions: declared interaction domains, the R1/R2 reachability axioms, the fallback demotion rule, and Kahn's completion. Proposition 2's X* is not defined in terms of the execution order; it is defined by unreachability and acyclicity of the unanimity relation under all feasible attacker strategies, and the proof then derives non-demotion and preservation. This is a substantive fixed-point characterization, not a restatement of the conclusion. The abstract's informal gloss of 'gated' omits the acyclicity condition and is therefore overbroad, but overstatement is a correctness/precision issue, not circularity. Section 8 explicitly flags the alternative 'actual interactions' definition as circular ('actual interactions depend on the order, so the definition is circular') and leaves the fixed-point problem for future work; the main results rely on the declared-interactions reading, which the paper states has 'no circularity,' so this acknowledged limitation does not infect the claimed guarantees. There are no fitted parameters, no data calibration, and no load-bearing self-citations; citations to Arrow, Sen, Szpilrajn, and Kahn are independent external tools. Proposition 5's impossibility result unpacks the definition of 'gated neither above nor below' and the existence of conflicting pairwise preferences; it is a limit argument rather than an assumed conclusion.

Assumptions & free parameters 0 free parameters · 6 assumptions · 0 invented entities

Theory-only paper: no fitted parameters, no data, no calibration. The central claims rest on five domain assumptions the paper states explicitly — strong censorship resistance (§1), ex-ante preference expression (§2), ex-ante declared interaction domains (§2, §8, with the circular alternative admitted as unresolved), attacker-reach decomposability/bundling (R1/R2, §4), and separation of newly deployed applications from honest transactions (§4). Kahn's algorithm and standard graph facts are the only mathematical background.

assumptions (6)

domain assumption Strong censorship resistance: the attacker cannot remove or modify honest transactions, only inject its own and replace its own.
Explicit caveat in §1: 'the paper assumes throughout a strong form of censorship resistance. Without it, the proposer could manipulate the order simply by withholding transactions.' Scope condition on the threat model.
domain assumption Applications express complete, ex-ante preference rankings U_t over all valid transactions in their domain, known to the protocol.
§2 model: 'Each application has preferences over the order... represented by a function U_t', taken as given. Practical expression, registration, and verification of such rankings are not modeled.
domain assumption Interaction domains X_t are determined ex ante (declared interactions); the actual-interactions alternative is circular.
§2: 'I take the interaction domains as given, for example because each transaction must declare them beforehand (similarly to Solana's account list)'. §8: 'defining the interaction sets by actual rather than declared interactions poses a fixed-point problem... that this paper only states.'
domain assumption Attacker reach R satisfies (R1) single-opinion decomposition and (R2) bundling without changing applications' rankings.
§4 assumptions (R1)-(R2); load-bearing for Proposition 2 Step 3 and Proposition 5. If decomposition or bundling changes how applications rank the resulting transaction, the gated-region proof and the impossibility construction can fail.
domain assumption Newly deployed applications' domains contain only transactions that interact with them; the attacker cannot place honest transactions in its new applications' domains.
§4 threat model: 'a newly deployed application's domain contains only transactions that interact with it'. Used in Proposition 4 to ensure honest single-opinion transactions stay single-opinion.
standard math Kahn's algorithm extends any acyclic relation to a total order; standard strongly-connected-component and DAG facts.
§3.1.2 completion step and Lemma 2's acyclicity argument; standard graph theory from Kahn (1962).

how reviews work

0 comments

Cite this review

Pith. "Pith review of Ordering by Unanimity: Giving Applications Sequencing Rights Without Breaking Composability." pith.science (2026). https://pith.science/paper/7BZWSP36

@misc{pith2026260706144,
  author       = {Pith},
  title        = {Pith review of: Ordering by Unanimity: Giving Applications Sequencing Rights Without Breaking Composability},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7BZWSP36}},
  note         = {Machine review of arXiv:2607.06144}
}

read the original abstract

Blockchain applications may have preferences over the order in which transactions execute: an automated market maker may use an external feed to price its liquidity, and require that the oracle update incorporating this price execute before any swap; an exchange may want to execute cancellations of limit orders before incoming market orders; an application may run an on-chain auction by executing bids from highest to lowest, so that the first bid wins. However, the ordering of transactions is chosen by the underlying blockchain and may not be compatible with the requirements of a specific application. In this paper, I tackle this problem by introducing an algorithm called unanimity override. The intuition is that when all the applications agree on how to order two transactions, the underlying blockchain should respect this agreement; a default order - the order in which transactions appear in the block - settles the rest. The problem with this naive approach is that application unanimity may form cycles, which the algorithm must break. Cycle-breaking is also the rule's main vulnerability because an attacker can insert transactions to manufacture a cycle. Yet two guarantees hold against any attacker who sets the default order, deploys applications, and inserts transactions. All transactions that interact with a single application that expressed preferences are ordered according to that application's preferences, even when they also interact with other applications that did not express preferences. Also, gated transactions - those that cannot be outranked in the unanimity order by any transaction crafted by an attacker - always execute as the applications unanimously prefer, even when they touch many applications. The two guarantees identify the preferences the protocol can protect, and they tell applications and senders in advance which transactions will execute in the intended order.

Figures

Figures reproduced from arXiv: 2607.06144 by the authors.

**Figure 2.** Intransitivity example: three applications each with two transactions, whose unanimous [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 2.** Intransitivity example: three applications each with two transactions, whose unanimous [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

Figures from the paper (4 more)

**Figure 3.** Figure 3: Example 1: the unanimity graph (transitively implied comparisons omitted) is layered: [PITH_FULL_IMAGE:figures/full_fig_p010_3.png]

**Figure 4.** Figure 4: Example 2. (a) The unanimity relation contains the cycle [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]

**Figure 5.** Figure 5: The attack of the threat model. (a) Honest applications [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]

**Figure 5.** Figure 5: The cycle-and-demotion attack. The attacker preserves the target transactions, creates [PITH_FULL_IMAGE:figures/full_fig_p014_5.png]

Review history (2 revisions) →

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

16 extracted references · 1 linked inside Pith

[1]

, title =

Arrow, Kenneth J. , title =. 1963 , publisher =

1963
[2]

Advances in Cryptology -- CRYPTO 2020 , series =

Kelkar, Mahimna and Zhang, Fan and Goldfeder, Steven and Juels, Ari , title =. Advances in Cryptology -- CRYPTO 2020 , series =

2020
[3]

Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS) , publisher =

Kelkar, Mahimna and Deb, Soubhik and Long, Sishan and Juels, Ari and Kannan, Sreeram , title =. Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS) , publisher =

2023
[4]

2026 , eprint=

The Monotone Priority System: Foundations of Contract-Specific Sequencing , author=. 2026 , eprint=

2026
[5]

arXiv preprint arXiv:2306.15743 , year=

Condorcet attack against fair transaction ordering , author=. arXiv preprint arXiv:2306.15743 , year=

arXiv
[6]

Proceedings of the 43rd ACM Symposium on Principles of Distributed Computing , pages=

Brief announcement: Fair ordering via streaming social choice theory , author=. Proceedings of the 43rd ACM Symposium on Principles of Distributed Computing , pages=
[7]

Ferreira, Matheus V. X. and Parkes, David C. , title =. 2022 , howpublished =

2022
[8]

, title =

Sen, Amartya K. , title =. The Review of Economic Studies , volume =

Show all 16 references

[9]

, title =

Sen, Amartya K. , title =. 1970 , publisher =

1970
[10]

Fundamenta Mathematicae , volume =

Szpilrajn, Edward , title =. Fundamenta Mathematicae , volume =
[11]

Economica , volume =

Suzumura, Kotaro , title =. Economica , volume =
[12]

2025 , url =

Sarisht Wadhwa and Julian Ma and Thomas Thiery and Barnabe Monnot and Luca Zanolini and Fan Zhang and Kartik Nayak , title =. 2025 , url =

2025
[13]

, title =

Kahn, Arthur B. , title =. Communications of the ACM , volume =. 1962 , doi =

1962
[14]

International Colloquium on Structural Information and Communication Complexity , pages=

FnF-BFT: A BFT protocol with provable performance under attack , author=. International Colloquium on Structural Information and Communication Complexity , pages=. 2023 , organization=

2023
[15]

2025 , eprint=

Multiple Concurrent Proposers: Why and How , author=. 2025 , eprint=

2025
[16]

2026 , eprint=

Cadence: Extreme Pipelining with Multiple Concurrent Proposers , author=. 2026 , eprint=

2026

Pith tools

Reviewed August 2, 2026 · model on record in the stance chip above.

[1] [1]

, title =

Arrow, Kenneth J. , title =. 1963 , publisher =

1963

[2] [2]

Advances in Cryptology -- CRYPTO 2020 , series =

Kelkar, Mahimna and Zhang, Fan and Goldfeder, Steven and Juels, Ari , title =. Advances in Cryptology -- CRYPTO 2020 , series =

2020

[3] [3]

Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS) , publisher =

Kelkar, Mahimna and Deb, Soubhik and Long, Sishan and Juels, Ari and Kannan, Sreeram , title =. Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security (CCS) , publisher =

2023

[4] [4]

2026 , eprint=

The Monotone Priority System: Foundations of Contract-Specific Sequencing , author=. 2026 , eprint=

2026

[5] [5]

arXiv preprint arXiv:2306.15743 , year=

Condorcet attack against fair transaction ordering , author=. arXiv preprint arXiv:2306.15743 , year=

arXiv

[6] [6]

Proceedings of the 43rd ACM Symposium on Principles of Distributed Computing , pages=

Brief announcement: Fair ordering via streaming social choice theory , author=. Proceedings of the 43rd ACM Symposium on Principles of Distributed Computing , pages=

[7] [7]

Ferreira, Matheus V. X. and Parkes, David C. , title =. 2022 , howpublished =

2022

[8] [8]

, title =

Sen, Amartya K. , title =. The Review of Economic Studies , volume =