Losing Contracts: Diverse Failure Mechanisms

• Losing contracts are defined by gaps between the nominal agreement and actual outcomes, manifesting as underperformance, semantic loss, or security breaches.
• They span a range of domains—from decentralized finance and software design to dynamic principal–agent models, mortgage theory, and smart contract lifecycles.
• Insights reveal that dynamic, relational, and lifecycle analyses are crucial to mitigating risks associated with benchmark underperformance, incomplete specifications, and design-constrained losses.

Searching arXiv for relevant papers on “losing contracts” and adjacent meanings across finance, software contracts, and smart contracts. “Losing contracts” is not a single technical term with one settled meaning. In contemporary research it denotes several distinct but structurally related phenomena in which a contractual mechanism, specification, or protocol ceases to preserve value, enforce intended behavior, or maintain favorable incentive alignment. Across decentralized finance, software specification, principal–agent theory, mortgage design, and smart-contract security, the common theme is a gap between nominal contractual form and realized outcomes. In some settings the loss is financial underperformance relative to a benchmark; in others it is loss of semantic completeness, fairness-adjusted revenue, operational control, or lifecycle integrity. The concept therefore spans both economic contracts and executable contracts, with each literature identifying specific conditions under which a contract becomes “losing” and, equally importantly, conditions under which that outcome can be avoided (Hafner et al., 2024).

1. Decentralized exchanges and liquidity provision

In automated market maker systems, “losing contracts” arise when a liquidity-provision position underperforms a passive buy-and-hold benchmark. The canonical setting studied is the two-asset constant-product AMM, with reserve invariant

$R_A*R_B=k.$

If a trader sends $\Delta_B$ into the pool and withdraws $\Delta_A$, then in the no-fee case the reserve condition is

$(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$

so that

$\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$

The corresponding spot price is

$p_{AMM}=R_B/R_A.$

The static impermanent-loss literature compares the terminal value of the LP position with the value of simply holding the initial token quantities. In the formulation used in the AMM analysis, the LP’s total relative gain without fees is

$\delta^{LP}=\sqrt{p_m^T/p_m^1},$

and the paper states explicitly that “without any fees a market price change will always result in an impermanent loss for the liquidity provider.” This produces the standard static conclusion that any nonzero relative price movement makes the contract losing relative to the wallet benchmark.

The dynamic analysis changes that conclusion. Once trading fees are included, with fee $fee$ and $\gamma=1-fee$, the reserve condition becomes

$(R_A-\Delta_A )*(R_B+\gamma*\Delta_B )=R_A*R_B,$

and the AMM spot price with fees is

$\Delta_B$0

Because every trade, including arbitrage, contributes fee income to the pool, the LP’s realized outcome depends on fee accumulation over the whole path, not solely on the terminal price ratio. In the Monte Carlo study calibrated on Uniswap V2 WETH/USDC data, LPs outperform buy-and-hold over a wide range of market trends; under the baseline calibration they “make a profit relative to a holding strategy as long as market prices do not drop by more than 75\% or increase by more than 300\% within a year” (Hafner et al., 2024).

This reframes AMM “losing contracts” as contingent rather than intrinsic. A constant-product AMM becomes losing only when rebalancing losses from sufficiently large, permanent, and unexpected price movements exceed accumulated fee income. The paper also argues that an arbitrage-friendly environment benefits LPs, because rebalancing losses are independent of the number of arbitrage trades while fee gains increase with arbitrage activity. A plausible implication is that attempts to suppress arbitrage can worsen LP outcomes even when motivated by a static impermanent-loss intuition.

2. Incomplete software contracts and semantic loss

In Design by Contract, “losing contracts” refers to loss of specification content during translation from abstract data type semantics to routine-level preconditions and postconditions. The central problem is that some ADT laws are relational or sequential and cannot be expressed as ordinary postconditions of a single routine. The paper’s stack example defines the ADT with operations

$\Delta_B$1

$\Delta_B$2

$\Delta_B$3

$\Delta_B$4

$\Delta_B$5

and axioms including

$\Delta_B$6

and

$\Delta_B$7

The crucial observation is that $\Delta_B$8 is not a property of extend alone or remove alone; it is a property of their composition. In postcondition form, the intended guarantee is captured as

$\Delta_B$9

If routine postconditions are too weak to entail this, an implementation may satisfy every visible contract while still failing to implement the intended abstract type. The paper illustrates this with a malicious stack implementation that stores only the last pushed element yet still satisfies the translated routine contracts.

The proposed remedy is specification drivers: auxiliary routines written in the same language as the implementation, with ordinary preconditions and postconditions, whose bodies compose implementation features to express ADT laws. For example, the stack law $\Delta_A$0 is encoded by a driver that starts from equivalent stacks, performs extend and remove on one, and asserts equality with the untouched copy. This converts otherwise lost semantics into mechanically checked proof obligations.

The paper formalizes this with a definition of contract completeness. A contract is correct if its postconditions are strong enough to verify specification drivers derived from the ADT axioms and from equivalence; it is well-defined if its postconditions are strong enough to verify well-definedness drivers; and it is complete iff it is both correct and well-defined. The broader significance is that a contract can be “losing” even when every routine verifies: what is lost is not runtime money or state, but semantic force. Verification may certify correctness only relative to an underspecified, incomplete contract unless the broader ADT laws, equivalence relation, and well-definedness conditions are reified as drivers (Naumchev et al., 2016).

3. Dynamic principal–agent contracts that deteriorate over time

In repeated principal–agent problems with a learning agent, “losing contracts” denotes contracts that are intentionally designed to worsen over time while remaining behaviorally effective. The model considers a principal repeatedly offering performance-based contracts over $\Delta_A$1 rounds to an agent who is a no-regret learner. In the success/failure case, a linear contract with scalar $\Delta_A$2 gives agent utility

$\Delta_A$3

and principal utility

$\Delta_A$4

The paper’s central structural result is that, against a mean-based no-regret learner, the optimal dynamic linear contract has a free-fall form: offer a positive-$\Delta_A$5 contract initially, then switch to the zero contract. During the zero-contract phase, the agent continues taking productive actions because cumulative utility from prior rounds remains high; as those cumulative scores decay, the learner “free-falls” through the action space. Since $\Delta_A$6, the principal receives full expected reward at zero payment during this phase.

The paper’s example with three actions shows the mechanism concretely. With costs $\Delta_A$7, $\Delta_A$8, $\Delta_A$9 and success probabilities $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$0, $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$1, and $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$2, the best static contract gives the principal $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$3 per round. A dynamic contract that offers $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$4 for $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$5 rounds and then switches to $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$6 yields total principal utility approximately

$(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$7

strictly better than the static benchmark.

This literature therefore treats a contract as “losing” in form when later offers are sharply less favorable, even collapsing to zero, while still exploiting the path dependence of no-regret learning. The paper is careful, however, not to equate locally deteriorating contracts with globally harmful outcomes. It proves that there exist settings where an optimal dynamic contract improves expected welfare by a $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$8 factor over the best static contract and improves the agent’s expected utility by a factor of $(R_A-\Delta_A )*(R_B+\Delta_B )=R_A*R_B,$9. A plausible implication is that dynamic deterioration and overall exploitation are distinct notions: a contract path may become losing in local compensation terms without being losing in total utility terms for the agent (Guruganesh et al., 2024).

4. Downside-risk mortgage design and underwater states

In mortgage theory, “losing contracts” are contracts that perform badly in low house-price states, especially when borrowers become underwater and selective default becomes rational. The benchmark fixed-rate mortgage has balance and coupon

$\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$0

Because the balance is predetermined and does not depend on house value, a fall in $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$1 below $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$2 creates default incentives and associated deadweight foreclosure losses.

The paper studies alternative mortgage contracts that adjust automatically in losing states. The adjustable balance mortgage sets

$\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$3

with payments recalculated from the reduced balance: $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$4 In the perpetual limit, both payment rate and prepayment amount become proportional to $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$5, so the borrower is never underwater. The paper states that the default option value is zero for the ABM.

A second class, the adjustable payment rate mortgage, also adjusts payments downward in bad states but adds a capital-gain-sharing penalty in good states: $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$6 The paper finds this upside-sharing feature ineffective because even modest $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$7 makes high-state prepayment “virtually eliminated.”

The principal quantitative policy result is that, once foreclosure costs are incorporated, automatic balance-adjustment contracts can dominate standard fixed-rate mortgages at modest rate spreads. The paper reports that for observed foreclosure costs around $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$8, balance-adjustment contracts become competitive at mortgage rate spreads in the neighborhood of $\Delta_A =\frac{R_A*\Delta_B}{R_B+\Delta_B}.$9–$p_{AMM}=R_B/R_A.$0 basis points, with the ABM often requiring the smaller spread and sometimes even a negative spread relative to the FRM (Kitapbayev et al., 2020).

This line of work defines losing contracts as contracts that fail in downside states by forcing socially costly default rather than absorbing some downside contractually. The paper’s broader claim is not that every state contingency is desirable, but that simple automatic downside sharing is superior to ex post foreclosure and to complicated upside clawbacks.

5. Smart contracts that lose funds, liveness, or lifecycle continuity

In the smart-contract security literature, “losing contracts” are executable contracts that lose value, safety, or operational continuity through vulnerabilities that manifest over traces, lifecycle transitions, or external interactions. One foundational distinction is between local bugs and trace vulnerabilities. MAIAN characterizes three trace-vulnerability classes over nearly one million Ethereum contracts: greedy, prodigal, and suicidal. Greedy contracts “remain alive and lock Ether indefinitely”; prodigal contracts leak Ether to arbitrary users; suicidal contracts can be killed by any arbitrary account. On a concretely validated subset, the tool reproduces exploits at a true positive rate of $p_{AMM}=R_B/R_A.$1, and it finds exploits for the Parity bug that indirectly locked $p_{AMM}=R_B/R_A.$2 million dollars worth in Ether (Nikolic et al., 2018).

Lifecycle-oriented work generalizes this view beyond execution-time bugs. The empirical study of vulnerable contracts across lifecycle stages separates vulnerabilities into deployment/execution, upgrade, and destruction stages. It reports distinct transaction and ego-network signatures across these stages and shows that a KNN classifier achieves accuracy $p_{AMM}=R_B/R_A.$3, precision $p_{AMM}=R_B/R_A.$4, recall $p_{AMM}=R_B/R_A.$5, F1 $p_{AMM}=R_B/R_A.$6, with $p_{AMM}=R_B/R_A.$7. This suggests that contracts associated with loss may reveal stage-specific behavioral signatures before or during failure, rather than only through static source-code features (Peng et al., 21 Apr 2025).

Destruction is a particularly direct form of contract loss. The study of selfdestruct on Ethereum reports that among surveyed developers who include selfdestruct, $p_{AMM}=R_B/R_A.$8 do so for security fixes or upgrades, and it identifies five reasons why contracts die: Functionality Changes, Limits of Permission, Unsafe Contracts, Unmatched ERC20 Token, and Setting Changes. LifeScope detects Unmatched ERC20 Token with $p_{AMM}=R_B/R_A.$9 false positives or negatives and achieves $\delta^{LP}=\sqrt{p_m^T/p_m^1},$0 F-measure and $\delta^{LP}=\sqrt{p_m^T/p_m^1},$1 AUC on Limits of Permission. The paper’s analysis therefore treats a contract as lost not only when it is exploited, but when immutability turns interoperability failures or permission bugs into redeployment events (Chen et al., 2020).

Other work focuses on prevention and mitigation rather than classification. Gradual verification for smart contracts addresses loss caused by unverified external contracts and arbitrary re-entrancy by combining optimistic static reasoning with runtime checks synthesized from partial specifications denoted by $\delta^{LP}=\sqrt{p_m^T/p_m^1},$2. The paper’s sell example shows that the latent precondition $\delta^{LP}=\sqrt{p_m^T/p_m^1},$3 can be recovered as a runtime check to preserve the postcondition $\delta^{LP}=\sqrt{p_m^T/p_m^1},$4, preventing a resource-accounting loss even when static specifications are incomplete (Sun et al., 2023). BACKRUNNER addresses loss after deployment under real-world attack conditions, arguing that existing attack-frontrunning defenses fail because $\delta^{LP}=\sqrt{p_m^T/p_m^1},$5 of $\delta^{LP}=\sqrt{p_m^T/p_m^1},$6 recent attack transactions bypass them. Its preemptive hijack and attack-backrunning approach reportedly could have rescued more than $\delta^{LP}=\sqrt{p_m^T/p_m^1},$7M in 28 incidents in two months (Shou et al., 2024).

A different sense of “losing contracts” appears in smart-contract evolution. FlexiContracts aims to avoid losing the deployed address, state, and continuity of a live contract during upgrades by supporting in-place logic change with storage reorganization, rather than proxy indirection or redeployment. The paper’s claims are architectural rather than formally validated, but they frame immutability itself as a source of contract loss when bugs or changing requirements force abandonment of a deployed endpoint (Hossain et al., 15 Apr 2025).

6. Fairness, anonymity, and succinctness as sources of contractual loss

Several principal–agent and fair-division papers use “loss” to describe the value sacrificed when contractual design is constrained by fairness, anonymity, or succinctness.

In envy-free task contracting, the principal assigns tasks using task-level linear contracts $\delta^{LP}=\sqrt{p_m^T/p_m^1},$8 and, in the new model, nonnegative agent-specific subsidies $\delta^{LP}=\sqrt{p_m^T/p_m^1},$9. The principal’s expected revenue under envy-free contracts with subsidies is

$fee$0

The paper shows that standard envy-free contracts without subsidies can have unbounded price of fairness, whereas envy-free contracts with subsidies have a tight price-of-fairness bound of $fee$1. It also proves that EFS can outperform ordinary EF by an arbitrarily large factor. Here the contract becomes losing because exact fairness constraints can force inefficient assignments or excessive payments; subsidies partially recover the lost value without relaxing envy-freeness (Castiglioni et al., 24 Jun 2026).

Anonymous contracts produce a related but distinct loss. In the multi-agent binary-outcome model, an anonymous contract is parameterized by a payment vector $fee$2, where each successful agent is paid $fee$3 when exactly $fee$4 agents succeed. Under limited liability, the principal’s utility collected by an optimal anonymous contract can be $fee$5 times smaller than social welfare, where

$fee$6

Uniform anonymous contracts recover robustness by guaranteeing a unique equilibrium, and they match the best achievable asymptotic approximation up to lower-order terms. Without limited liability, the picture reverses: anonymous contracts achieve an $fee$7 approximation in general and extract the full welfare whenever agents’ success probabilities are distinct. Thus anonymity can be losing under one liability regime and essentially lossless under another (Brustle et al., 12 Feb 2026).

Succinct ambiguous contracts study loss from restricting the support of an ambiguous contract to at most $fee$8 classic contracts. The succinctness gap is defined as

$fee$9

The paper proves

$\gamma=1-fee$0

and, strikingly, when just one contract is missing from the unrestricted support threshold—i.e. $\gamma=1-fee$1—the principal’s utility can drop by a factor of $\gamma=1-fee$2, and this is tight: $\gamma=1-fee$3 In this literature, losing contracts are literally missing contracts: removal of a single support element can collapse half the achievable value, while also making computation NP-hard for constant $\gamma=1-fee$4 or $\gamma=1-fee$5 (Duetting et al., 4 Mar 2025).

These strands share a common mechanism. Constraints motivated by fairness, equal treatment, or simplicity remove discriminatory degrees of freedom. The resulting losses are not accidental but structural: implementability shrinks, expected payments rise, and optimization can become combinatorial.

7. Common structure across meanings

Across these literatures, “losing contracts” refers to at least four analytically distinct loss mechanisms.

First, there is benchmark underperformance. AMM liquidity positions become losing relative to buy-and-hold when rebalancing losses dominate fee income. Mortgage contracts become losing in underwater states when fixed debt obligations induce selective default rather than contractual loss absorption.

Second, there is semantic or incentive incompleteness. In software specification, contracts lose semantic content when ADT laws never become mechanically enforceable obligations. In repeated principal–agent models, a contract path can become locally losing for the agent because the principal exploits learning dynamics after an initially favorable phase.

Third, there is security and lifecycle failure. Smart contracts can lose funds, liveness, or continuity through trace vulnerabilities, destruction, unverified external interactions, or deployment-time immutability. Here “losing” often means that the contract survives on-chain only as a broken endpoint, or disappears altogether while leaving funds, users, or dependencies stranded.

Fourth, there is design-constrained value loss. Envy-freeness, anonymity, and succinctness make contracts losing for the principal by restricting the space of implementable or efficient mechanisms. These works are especially explicit in quantifying the loss through ratios such as price of fairness or succinctness gap.

A plausible implication is that “losing contracts” is best treated not as a domain-specific keyword but as a comparative analytic category. A contract is losing when, under a specified benchmark and environment, it ceases to preserve one of the core contractual functions: value retention, implementability, semantic completeness, strategic robustness, or operational continuity. The papers considered here differ radically in application domain, but they converge on the same methodological lesson: apparent contractual failure often emerges only after introducing the appropriate dynamic, relational, or lifecycle perspective.