Using “Failure Costs” to Guarantee Execution Quality in Competitive and Permissionless Order Flow Auctions

Abstract

In the context of decentralized blockchains, accurately simulating the outcome of order flow auctions (OFAs) off-chain is challenging due to adversarial sequencing, encrypted bids, and frequent state changes. Existing approaches, such as deterministic sorting via consensus layer modifications (e.g., MEV taxes) (Robinson and White 2024)[1] and BRAID (Resnick 2024)[2] or atomic execution of aggregated bids (e.g., Atlas) (Watts et al. 2024)[3], remain vulnerable in permissionless settings where limited throughput allows rational adversaries to submit ”spoof” bids that block their competitors’ access to execution.

We propose a new failure cost penalty that applies only when a solution is executed but does not pay its bid or fulfill the order. Combined with an on-chain escrow system, this mechanism empowers applications to asynchronously issue their users a guaranteed minimum outcome before the execution results are finalized. It implies a direct link between blockchain throughput, censorship resistance, and the capital efficiency of auction participants (e.g., solvers), which intuitively extends to execution quality. At equilibrium, bids fully reflect the potential for price improvement between bid submission and execution, but only partially reflect the potential for price declines. This asymmetry—unbounded upside for winning bids, limited downside for failed bids, and no loss for losing bids—ultimately benefits users.

Alex Watts FastLane Labs [email protected]

Davide Sinesi FastLane Labs [email protected]

Jacob Greene FastLane Labs [email protected]

1. Background

Order flow auctions (OFAs) have gained prominence in blockchain ecosystems as a means to improve transaction execution by allowing third-party participants (i.e., solvers or market makers) to compete for the right to fulfill orders. Commonly, OFAs grant these exclusive fulfillment rights at an initial time $t_{0}$, while the actual on-chain execution of the trade occurs later at time $t_{1}$. Ensuring that the participant who wins at $t_{0}$ will indeed execute the promised trade at $t_{1}$ is nontrivial. Without proper enforcement, a malicious actor could submit multiple high-value bids at $t_{0}$ and then simply refuse to fulfill them at $t_{1}$, undermining the auction’s reliability. Even if basic execution simulations are performed at $t_{0}$, market conditions can change between $t_{0}$ and $t_{1}$ in ways that invalidate those simulations, allowing participants to exploit the gap and sidestep their commitments.

Current OFA implementations have developed various methods to enforce execution, including stateful simulations provided by block builders, reputation-based systems, and upfront payment schemes. Although stateful simulations—designed to model future execution conditions—are conceptually sound, they are not widely available across different blockchain ecosystems and often rely on relatively centralized block builder infrastructures. Reputation-based approaches (e.g., UniswapX) (Adams et al. 2023)[4] limit the number of times a participant can cancel their bids between $t_{0}$ and $t_{1}$. Exceeding a cancellation threshold leads to exclusion from the set of authorized participants. However, such reputation-based strategies restrict the auction’s permissionless nature since they limit who can participate.

As discussed by Resnick (2023)[5], another challenge is that current penalty structures do not adequately incorporate the opportunity cost of failing to execute. If the market price moves unfavorably between $t_{0}$ and $t_{1}$, a participant may find it more profitable to cancel their order, even at the risk of reputation damage, rather than honor a trade that has become disadvantageous. While this behavior might still comply with formal reputation rules, it erodes the integrity of the auction. Designing penalties that fully capture this opportunity cost is difficult. Furthermore, in a permissionless environment, excluded participants can easily generate new identities to re-enter the system, negating the intended effects of reputation-based exclusions.

1.1 Mechanism Context

This analysis proposes a new on-chain settlement approach for OFAs. Unlike traditional models that grant exclusive execution rights at $t_{0}$, this framework allows multiple participants to be selected at $t_{0}$ and then settled at execution time, $t_{1}$, based on their bid values and execution outcome. Such on-chain settlement preserves the capital efficiency of reputation-based methods while achieving properties similar to those of upfront payment systems.

This approach is well-suited to environments where trusting transaction sequencers (e.g., block builders) or relying on off-chain simulations is undesirable. We assume that bidders cannot be censored by either the auctioneer or the block builder—an outcome achievable via censorship-resistant blockchain architectures such as the multiple concurrent proposer model proposed by Fox, Pai, and Resnick (2023)[6], or through trusted execution environments combined with cryptographic bundling protocols (e.g., the Atlas $CallChainHash$ mechanism) (Watts et al. 2024)[3]. We acknowledge finite blockspace constraints at $t_{1}$, which naturally limit the number of contending participants. Although our primary focus is the Atlas OFA framework, these principles apply broadly to any on-chain implementation of OFAs that defer winner selection until execution time and allow atomic execution of multiple bids.

1.2 Atlas

Unlike many infrastructure-driven solutions that depend on the accuracy of stateful simulations and the power to exclude conflicting transactions, Atlas is an application-specific sequencer that pairs users and solvers on-chain at execution time. As described in Section 3.3 of the Atlas white paper, (Watts et al. 2024)[3], each Atlas transaction includes a user’s $UserOperation$ followed by multiple $SolverOperation$s. These solver bids are typically aggregated without pre-execution simulations, sorted optimistically by bid amount, and submitted to the blockchain as a single, large transaction. Once the transaction is included in a block, each $SolverOperation$ is executed in the sequence of their bid amounts until a solver successfully pays its bid and fulfills the user’s order.

This direct, on-chain approach removes non-performing solvers even when simulations are unreliable. However, it also ties the discovery of counterparties to the blockchain’s throughput constraints (e.g., gas limits) due to the resources consumed by each $SolverOperation$ during execution.

1.3 Atlas Structure

An Atlas transaction is composed of $UserOperations$ ($o_{i}\in O_{user}$) and $SolverOperations$ ($o_{i}\in O_{solver}$). Let $G(t)$ be the gas limit of the transaction. The number of $SolverOperations$ is limited by the total gas limit and the gas consumed by user operations. Let $g(o_{i})$ denote the gas reserved for an operation $o_{i}$, and $g^{*}(o_{i})$ the actual gas consumed. We have:

$$\sum_{o_{i}\in O_{solver}}g(o_{i})\;\leq\;G(t)\;-\;\sum_{o_{i}\in O_{user}}g^{*}(o_{i})$$

Maintaining this limit ensures that the gas needed to execute $SolverOperations$ does not exceed the remaining available gas after executing the $UserOperations$. The total gas available to all $SolverOperations$, $\Gamma$, is:

$$\Gamma=G(t)-\sum_{o_{i}\notin O_{solver}}g(o_{i})$$

$SolverOperations$ are sorted in descending order by their bid amount $b(o_{i})$ and executed in sequence until one succeeds. To succeed, a $SolverOperation$ must pay its bid to the designated beneficiary and cover its own execution gas costs (minus the costs of any previously failed $SolverOperations$). If it cannot, the operation reverts but still pays for its consumed gas.

To disincentivize double-spend attacks, each solver can only submit one $SolverOperation$ per block and must escrow at least $\phi_{t}\cdot g(o)$ of collateral, where $\phi_{t}$ is the gas price of the transaction $t$.

1.4 The Censorship Vector

In a permissionless setting, a malicious solver $i^{\prime}$ can submit ”spoof” bids designed purely to consume the available gas limit, $\Gamma$, rather than to win. By doing so, solver $i^{\prime}$ incurs a cost proportional to the gas consumed ($\phi_{t}\Gamma$, where $\phi_{t}$ is the gas price) but gains access to any value (e.g. MEV) (Phil Daian et al. 2019) [9] $v_{i^{\prime}}$ left by the user’s operation. Note that even if all solutions fail, the user’s operation might still create value that is then open to extraction. Since all other solvers’ solutions are effectively blocked from executing, the app’s designated beneficiary - typically the user - is never compensated. When the value $v_{i^{\prime}}$ exceeds the cost of censorship $\phi_{t}\Gamma$, it becomes rational for solver $i^{\prime}$ to engage in this censorship strategy.

2. Proposed Mechanism

We introduce a new cost, referred to as the failure cost, which applies only when a $SolverOperation$ attempts execution but fails to pay its full bid or fulfill the user’s order. To calculate this cost, take the difference between the bid of the failing solver and the bid of the successful solver (if any), then multiply that difference by the fraction of the total gas allocated to the operation of the failing solver. Unlike bids in an all-pay auction, the failure cost is incurred only by a solver who secured the opportunity to execute and consumed some of the blockchain’s throughput resources but did not meet their bid commitment or fulfill the user’s order.

2.1 The Failure Cost Mechanism

The formula for the failure cost $c_{fail}(o_{i})$ of a $SolverOperation$ $o_{i}$ is dependent on whether the array of $SolverOperation$s includes another solver’s successful operation, denoted as $b(o_{j}^{\checkmark})$. Here, $b(o_{j}^{\checkmark})$ represents a successful solver operation—that is, an operation that executes and manages to pay its bid.

$$c_{fail}(o_{i})=\begin{cases}\left(b(o_{i})-b(o_{j}^{{\checkmark}})\right)\frac{g(o_{i})}{\Gamma}&\text{Solver }j\text{ Succeeded, }\ b(o_{j})<b(o_{i})\\ b(o_{i})\frac{g(o_{i})}{\Gamma}&\text{No Solver Succeeded}\end{cases}$$ (1)

By combining the failure cost with actual the gas units consumed during execution $g^{*}(\cdot)$ and the gas price $\phi_{t}$, we can describe the payoff function $V_{i}$ for solver $i$:

$$V_{i}=\begin{cases}v_{i}-b(o_{i})-\phi_{t}\left(G^{*}(t)-\sum_{O^{\rotatebox[origin={c}]{180.0}{$\circlearrowleft$}}}g^{*}(o)\right)&\text{Solver }i\text{ Succeeded}\\ -\left(b(o_{i})-b(o_{j}^{\checkmark})\right)\frac{g(o_{i})}{\Gamma}-\phi_{t}\cdot g^{*}(o_{i})&\text{Solver }i\text{ Failed, Solver }j\text{ Succeeded, }\ b(o_{j})<b(o_{i})\\ -b(o_{i})\frac{g(o_{i})}{\Gamma}-\phi_{t}\cdot g^{*}(o_{i})&\text{Solver }i\text{ Failed, No Solver Succeeded}\\ 0&\text{Solver }j\text{ Succeeded, }\ b(o_{j})>b(o_{i})\end{cases}$$ (2)

Where $G^{*}(t)$ is the total gas used in the transaction $t$ and $O^{\circlearrowleft}$ denotes the set of operations that reverted.

The payoff for the auction beneficiary $i^{*}$, denoted by $W$, is defined as follows:

$$W_{i^{*}}=\begin{cases}b(o_{i}^{\checkmark})&\text{First Solver Succeeded}\\ b(o_{i}^{\checkmark})+\sum_{o_{j}\in O^{\rotatebox[origin={c}]{180.0}{$\circlearrowleft$}}}\left(b(o_{j})-b(o_{i}^{\checkmark})\right)\frac{g(o_{j})}{\Gamma}&\text{Mix}\\ \sum_{o_{j}\in O^{\rotatebox[origin={c}]{180.0}{$\circlearrowleft$}}}b(o_{j})\frac{g(o_{j})}{\Gamma}&\text{All Solvers Failed}\end{cases}$$ (3)

Figure 1: An example of value flowing through the failure cost mechanism, with the total gas available $\Gamma$ for $SolverOperations$ equal to $1,000,000$ and the gas price $\phi_{t}$ equal to $7.5e-7$.

2.2 The Guaranteed Minimum Outcome

An essential property of the failure cost mechanism is that it enables the auctioneer in a competitive order flow auction to guarantee the beneficiary a predictable minimum payout—even in the worst-case scenario where all solvers fail. Specifically, the worst-case outcome in a competitive auction corresponds to receiving a gas-weighted average of all the bids.

$$\sum_{i=1}^{N}\left(b_{i}\times\frac{g(o_{i})}{\Gamma}\right)=W_{i}^{\text{worst case}}$$

Here, $N$ denotes the finite set of solvers participating in the auction.

2.3 Escrow and Engineering Considerations

Atlas is designed for blockchain settings where simulations that predict order fulfillment and bid payment can be unreliable. This unreliability may arise because block times are too short relative to network latency, transactions can be asynchronously sequenced by consensus before execution (Monad 2024)[7], adversarial entities can insert conflicting transactions between simulation and inclusion (Robinson and Konstantopoulos 2020)[8], or the blockchain’s state may be subject to reorganization.

While Atlas mitigates these issues by selecting the highest-bidding solution atomically at execution time, the capital backing failure costs remains vulnerable. For example, an adversarial solver could front-run (Oz et al. 2024)[10] the Atlas transaction with its own transaction that depletes its balance before the failure penalty is applied.

To address this, we propose extending Atlas’s gas escrow to also include bid balances. Recall that this mechanism’s auctioneers are responsible allocating their auction’s limited throughput resources, which they do by choosing the set of $SolverOperations$ executed on-chain - they do not select the winning solution. Since the auctioneers cannot predict which solver solutions will succeed, each solver must maintain an escrow covering their worst-case penalty $b(o_{i})\frac{g(o_{i})}{\Gamma}$ and their potential gas costs for all unexecuted, pending $SolverOperation$s. Formally:

$$e_{i,a}(o_{i})\ \geq\sum_{o_{i}\in O_{i,a}^{?}}\ b(o_{i})\frac{g(o_{i})}{\Gamma}\ +\ \phi_{t}\cdot g(o_{i})$$

where $a$ is the auctioneer, $O_{i,a}^{?}$ is the set of $SolverOperation$s from solver $i$ handled by auctioneer $a$ whose execution outcomes are unknown, and $e_{i,a}(o_{i})$ is the required escrow for operation $o_{i}$.

The auctioneer can pre-fetch and cache each solver’s escrow balances. With local ”in flight” accounting of potential expenditures and a direct mapping of escrowed balances to auctioneers, the auctioneer can sequence $SolverOperation$s without querying the blockchain or performing simulations during the live auction.

2.4 Asynchronous User Experience

The failure cost mechanism, combined with the “in flight” accounting system, allows applications to provide a guaranteed minimum outcome without relying on additional blockchain reads or writes between receiving a user’s order and issuing the guarantee. This greatly improves the user experience (UX):

• At $t_{-2}$ or earlier, the auctioneer pre-fetches and caches each solver’s escrow balances.

• At $t_{-1}$, the auctioneer receives a user’s order, initiates the order flow auction and begins collecting bids from solvers.

• At $t_{0}$, once bidding ends, the auctioneer can immediately compute and provide the user with a guaranteed minimum outcome while simultaneously submitting the transaction to the blockchain.

• At $t_{1}$, the blockchain executes the transaction and finalizes the actual outcome.

Because no on-chain operations are needed during the auction itself, the user’s waiting time is limited only by network and auction durations. For example, if user-to-auctioneer latency is $50ms$ and the auction lasts $300ms$, the user can view their guaranteed minimum outcome within about $400ms$ of placing the order, providing a fast and responsive experience comparable to off-chain trading environments.

3. Mechanism Properties

The mechanism’s design ensures that participants behave in ways that maximize user value, discourage censorship, and maintain overall market integrity. Specifically, we identify the following desirable properties:

1. User-oriented value maximization: The user’s payoff is highest when the top-bidding solver completes its operation successfully. Since users do not gain additional value if solvers fail, their optimal outcome is always to secure a successful, well-priced solution. This aligns user incentives with the mechanism’s fundamental objective—efficient and reliable order execution.

2. Incentives for subsequent solver success: If a solver fails, it becomes that solver’s interest for the next solver to succeed. Because $SolverOperation$s are executed in descending order of their bid amounts, each subsequent solver’s success reduces the failure cost borne by the previously failing solvers. In other words, when a solver fails, it does not benefit from further failures; instead, it prefers that a successor solver succeed to minimize its own penalty.

3. Penalties scale with resource usage: Solvers reserving more gas resources are effectively penalized more in the event of failure. As a solver’s relative gas consumption $\frac{g(o_{i})}{\Gamma}$ increases, so does its potential failure cost. This creates a natural deterrent against unnecessarily large or gas-intensive operations that would otherwise crowd out other participants.

4. Censorship requires comprehensive dominance: Consider a solver $i^{\prime}$ aiming to censor all other solvers. To do so, $i^{\prime}$ must (1) outbid every other solver, and (2) reserve the entire (or nearly entire) block of gas ($\Gamma$) allocated to $SolverOperation$s:

   $$b(o_{i^{\prime}})>b(o_{i})\quad\forall o\in O,\quad\text{and}\quad\sum g(o_{i^{\prime}})\geq\Gamma$$

   Under these conditions, the cost to the censoring solver is:

   $$b(o_{i^{\prime}})+\phi_{t}\cdot g^{*}(o_{i^{\prime}})$$

   which strictly exceeds the combined bids of the censored solvers. If the censoring solver values its chance of winning the auction (and thereby capturing $v_{i^{\prime}}$) at least as much as it values the act of censorship, it is always more profitable in expectation to execute successfully rather than revert and censor others. This dynamic ensures that censorship, while theoretically possible, is made less attractive by the mechanism’s incentive structure. Moreover, if the censoring solver does succeed, the user’s payoff corresponds to $b(o_{i^{\prime}})$, which is strictly greater than the user’s payoff in the absence of censorship, thereby preserving user welfare.

3.1 Escrow and Capital Efficiency

The capital efficiency of the auction participants depends on $\Gamma$ the total gas allocated to solvers. Increasing $\Gamma$ reduces the share of total gas reserved by any single solver, thereby lowering their worst-case penalty and the failure cost’s escrow requirements. As solvers often act as counterparties or market makers, the intuition is that blockchains with higher throughput are more capital efficient.

Conversely, decreasing $\Gamma$ forces solvers to escrow more capital, reducing efficiency. However, higher $\Gamma$ not only enhances efficiency but also strengthens censorship resistance, as solvers have more room to operate, increasing competition. The gap between required escrow and failure cost remains fixed at $\phi_{t}\times g(o_{i})$, a term independent of $\Gamma$.

Figure 2: Combined Plots of Gas Availability and Costs

In addition to directly lowering the maximum failure cost $c_{fail}(o_{i})$ for each $SolverOperation$ as throughput $\Gamma$ grows, an increase in $\Gamma$ also indirectly reduces the expected failure cost $\mathbb{E}[c_{fail}(o_{i})]$. This secondary effect occurs because larger $\Gamma$ values allow more $SolverOperation$s to be included, increasing the likelihood that at least one succeeds and thus diminishes the expected penalty faced by any failing solver.

Example: Suppose a $SolverOperation$ $o_{i}$ uses $g(o_{i})=100{,}000$ gas and bids $b_{i}(v_{i})=\$100$. If $\Gamma_{1}=1{,}000{,}000$, then:

$$\max[c_{fail}(o_{i})]=\frac{100{,}000}{1{,}000{,}000}\times 100=\$10.$$

If the gas usage is similar across solvers, we might expect around 10 $SolverOperation$s in the transaction. As a median bid, if $o_{i}$ fails, about 5 other operations remain to succeed and mitigate $c_{fail}(o_{i})$.

Now consider $\Gamma_{2}=10{,}000{,}000$:

$$\max[c_{fail}(o_{i})]=\frac{100{,}000}{10{,}000{,}000}\times 100=\$1.$$

With this higher throughput, we might now expect around 100 $SolverOperation$s. If $o_{i}$ fails as a median bid, about 50 other operations can succeed and further reduce $\mathbb{E}[c_{fail}(o_{i})]$.

Thus, two factors lower $\mathbb{E}[c_{fail}(o_{i})]$ when $\Gamma$ increases:

1. The maximum possible failure cost per operation decreases proportionally to $\Gamma$.

2. The probability that at least one other solver succeeds (and thereby reduces the penalty) increases as more $SolverOperation$s fit into a single auction.

Define $N^{*}=\mathbf{card}\{o_{j}:b(o_{j})<b(o_{i})\}$ as the number of strictly lower-bidding $SolverOperation$s than $o_{i}$. As $\Gamma\to\infty$:

$$\mathbb{E}[N^{*}]\to\infty,$$

$$P\left(\exists\,o_{j}\in O^{\checkmark}\mid o_{i}\in O^{\rotatebox[origin={c}]{180.0}{$\circlearrowleft$}}\right)\to 1,$$

$$b(o_{i})-\mathbb{E}[b(o_{j})\mid o_{i}\in O^{\rotatebox[origin={c}]{180.0}{$\circlearrowleft$}}]\to 0.$$

Since the failure cost depends on the difference between $b(o_{i})$ and the successful bids $b(o_{j}^{\checkmark})$, and this difference approaches zero, the expected failure cost also approaches zero. Formally:

$$\lim_{\Gamma\to\infty}\mathbb{E}[c_{fail}(o_{i})]=0.$$

3.2 Censorship Resistance

The cost-of-censorship expression derived earlier over-simplifies the problem and assumes that the censoring solver must reserve all available gas. In practice, a censoring solver need only reserve:

$$\Gamma-\min_{O}\{g(o)\}$$

where $\min_{O}\{g(o)\}$ is the smallest gas allocation among the other solvers. By reserving just enough gas to exclude all other solvers, the censoring solver reduces its cost of censorship by:

$$\frac{\min_{O}(g(o))}{\Gamma}$$

This adjustment is critical for understanding how to choose an optimal $\Gamma$ and how to relate blockchain throughput directly to censorship resistance. To analyze this further, define:

$$\Gamma_{i^{\prime}}^{\prime}=\Gamma-\min_{O}\{g(o_{i}):i\neq i^{\prime}\}$$

$$B_{i^{\prime}}=\max_{O}\{b(o_{i}):i\neq i^{\prime}\}\\$$

Here, $\Gamma_{i^{\prime}}^{\prime}$ represents the effective gas limit after accounting for the smallest $SolverOperation$’s gas usage, and $B$ represents the largest competing bid. The censorship threshold can now be expressed as:

$$\text{Censorship Resistance}=\Gamma_{i^{\prime}}^{\prime}\left(\phi_{t}+\frac{B}{\Gamma}\right)-v_{i^{\prime}}$$ (4)

This refined formulation provides a more nuanced perspective on how increasing blockchain throughput ($\Gamma$) enhances censorship resistance. As $\Gamma$ grows, censorship resistance improves, making it more difficult and less profitable for adversaries to censor competing operations. Figure 3 illustrates how variations in gas price and gas available to solvers (throughput), highlighting throughput as a crucial design lever for maintaining a robust and equitable auction environment.

Figure 3: Relationship between Censorship Resistance, Gamma, and Gas Price

4. Bidding Strategies

Solvers choose their bids based on expectations about future values and the behavior of others. Because the final outcome depends on everyone’s decisions, no single solver can simply choose a strategy without considering the likely actions of others. The mechanism is therefore not strongly incentive compatible.

Instead, the mechanism leads to a Bayes-Nash equilibrium. Although this equilibrium ensures that no solver can profit by changing their own strategy once the equilibrium is established, it does not mean that solvers simply bid their true values. A rational solver would adjust their bid in light of the probabilities of winning, potential penalties, and anticipated moves by competitors. Strongly dominant strategies are unlikely given the complexity, uncertainties, and strategic interactions between participants.

4.1 Theoretical Framework

Consider a setting in which solvers, unaware of their counterparts’ bids, must select a strategy that maps their private valuation $v_{i}$ to an optimal bid $b_{i}(v_{i})$.

To review the operational sequence:

• Let $n\in\mathbb{N}$ denote the (finite) number of solvers participating in a given auction. Note that $n$ is not predetermined but depends on factors such as the available throughput and the gas consumption of user operations.

• Each solver must escrow sufficient funds to guarantee coverage of potential failure costs.

• $SolverOperations$ are executed in descending order of their bids until one operation is successfully completed.

• A $SolverOperation$ is deemed successful if it pays its own bid, its associated gas costs, and fulfills the user’s order by the conclusion of its execution.

• Any $SolverOperation$ that is executed but fails to cover its bid, fulfill the order, or pay its gas costs is penalized via the specified failure cost mechanism.

We consider an environment where each participant (i.e., bidder) faces an independent probability $q\in(0,1)$ from M. Resnick (2003) [5] that their operation fails to fulfill its obligation, and there are $n>1$ active bidders in a sealed-bid, first-price auction. Each bidder’s valuation of winning the auction is the commonly known quantity $v$. Suppose we focus on a symmetric profile where all other bidders bid a common amount $b$. We aim to determine the best response for a single bidder under this assumption—specifically, whether it is profitable to deviate from $b$ by a small increment $\varepsilon>0$.

While these assumptions are strong - especially $q$ being independent between solvers - they serve as a useful benchmark. If valuations and all public signals truly remained fixed, simulations would yield deterministic outcomes, leaving no incentive for a winner to default on their promised bid. Yet, real-world conditions are more complex, and the proposed mechanism must accommodate the possibility of unexpected failures at execution time.

When all bidders, including the focal bidder $i$, submit the same bid $b$, the expected utility is:

$$U(b)\;=\;v\,(1-q^{n})\;-\;b.$$

This arises because, with probability $(1-q^{n})$, the bidder’s bid “succeeds” and they pay $b$ to secure value $v$, thereby obtaining a net utility of $v-b$.

By bidding slightly more, $b+\varepsilon$, the expected payoff changes according to the probabilities of bid success or failure. Intuitively, this is because bidder $i$ will have the highest bid in the array and will be executed first. When all players other than $i$ bid $b$, we model the utility to $i$ of bidding $b+\epsilon$:

$$U_{i}\bigl{(}b_{i}=b+\varepsilon,b_{-i}=b\bigr{)}\;=\;(1-q)\,\bigl{[}v-(b+\varepsilon)\bigr{]}\;+\;q\,\frac{-\,\varepsilon}{n}\;+\;q^{n}\,\frac{-\,b}{n}.$$

Intuitively, with probability $(1-q)$, the bidder wins and pays $b+\varepsilon$ while receiving $v$. In the complementary states of failure, the bidder pays only a fraction of the submitted amount, depending on how many other bidders fail simultaneously. To find the symmetric-equilibrium bid $b$, we set up the difference

$$\Delta(\varepsilon)\;=\;U\bigl{(}b+\varepsilon\bigr{)}\;-\;U(b),$$

and examine the limit of $\Delta(\varepsilon)$ as $\varepsilon\to 0$. At equilibrium, we require $\lim_{\varepsilon\to 0}\Delta(\varepsilon)\;=\;0,$ so that the bidder is indifferent between bidding $b$ and slightly deviating to $b+\varepsilon$.

By equating that limit to zero and performing straightforward algebraic manipulation, we obtain the following closed-form expression for the symmetric equilibrium bid, denoted $b^{*}$:

$$b^{*}\;=\;v\,\cdot\frac{\,n\,\bigl{(}1-q^{\,n-1}\bigr{)}}{\,n-q^{\,n-1}\!}.$$

The factor $\frac{n\,(1-q^{\,n-1})}{\,n-q^{\,n-1}\!}$ reflects how the failure probability $q$ and the number of bidders $n$ jointly affect the bid level in this probabilistic, first-price mechanism. Note that while a bid of zero might appear to have utility at first glance by paying nothing to capture the expectation of all other bidders failing, in practical applications of this design this is a non-issue due to the existence of gas costs and the presence of $>n$ bids - only the top $n$ are included in the array.

This result, though derived under generous assumptions, provides a powerful intuition: as the number of solvers $n$ increases, the geometric influence of $q^{n}$ ensures that even substantial probabilities of failure are tempered. A higher $n$ can offset a higher $q$, maintaining incentives to bid more assertively than one might expect from a large failure probability alone. The resulting relationship offers a theoretically sound baseline for understanding how the scale of competition (reflected in $n$) and the underlying risk (reflected in $q$) jointly shape equilibrium bidding behavior in complex, dynamically evolving blockchain ecosystems.

4.2 Extending the Model with Discrete Time

In the previous analysis, we assumed that private valuations and public information remained fixed from the moment bids are placed ($t_{0}$) until the auction settles ($t_{1}$). In practice, this is rarely the case. Valuations can evolve, external signals may arrive, and clever adversaries can exploit changing conditions. To capture these complexities more faithfully, we now extend our model to incorporate the potential for valuations to change over time and the strategic implications this creates.

Previously, we introduced a single probability of failure $q$, treating it as an exogenous factor, but in a truly permissionless setting we must acknowledge the presence of adversarial solvers and asymmetric information. A solver cannot alter its posted solution ex post, but it can undertake minimal-cost actions—such as toggling an “off switch” in a smart contract or rapidly reallocating un-escrowed resources—to force an ostensibly winning solution to fail. This potential for strategic manipulation complicates the relationship between posted bids and realized outcomes, particularly as time and state evolve.

As a solver’s relative bid increases, it indirectly creates more “attempts” from lower-bidding solvers to succeed and thereby mitigate its own potential penalty. In other words, the higher a solver’s bid relative to its competition, the greater its expectation of the number of solutions available to execute should it fail and backstop its failure penalty. This interplay heightens the strategic complexity: the marginal incentive to bid higher depends not only on expected value and risk but also on the dynamic interaction between other solvers’ future actions and the evolving price distribution.

We define $v$ as the commonly known value of the asset at $t_{0}$, while at $t_{1}$ the asset’s price follows a normal distribution $X\sim N(v,\sigma^{2})$ with mean $v$, standard deviation $\sigma$, CDF $F_{X}(x)$, and PDF $f_{X}(x)$. Solvers must commit their bids at $t_{0}$ based solely on the expected distribution of $X$, yet at $t_{1}$ each solver privately observes its own realization of $X$—but not that of its competitors. This observational asymmetry enables a winning solver to extract positive slippage when $X>v$, while providing a cushion against losses due to the bounded failure penalty $\frac{b(v)}{n}$.

If at the time of execution $t_{1}$ the solver observes $X_{i}<b(v_{i})$, it will cancel rather than incur a larger loss. We can incorporate this concept into our utility framework by replacing $X$ in the payoff calculations with its conditional expectation given $X>b(v)$:

$$\mathbb{E}[X\mid X>b(v)]=\int_{b(v)}^{\infty}\frac{xf_{X}(x)}{1-F_{X}(b(v))}dx$$

Note that the decision threshold for profitability remains firmly at $X>b(v)$, not $X-\text{penalty}>b(v)$. This is because $b(v)$ already addresses the expectation of the failure penalty, which informs the solver’s choice to cancel but does not redefine the fundamental break-even point for profitable trade execution. Substituting in this conditional expectation of $X$ and recalling the normality assumption for $X$ yields our utility function $U_{i}\left[b_{i}(v),\ b_{-i}(v)\right]$:

$$n\left[v(1-F_{X}(b(v)))+\sigma f_{X}(b(v))-\frac{b(v)(1-F_{X}(b(v)))}{1-[F_{X}(b(v))]^{n}}\right]$$

Unlike simpler models, no neat closed-form solution emerges. Instead, the equilibrium depends on the entire distribution of future values and on strategic cancellation options that arise as solvers observe their private realization of $X$.

4.3 Numerical Analysis

The equilibrium bid $b^{*}(v)$ is found by setting the derivative of $U_{i}[b(v)]$ with respect to $b(v)$ to zero. Letting $z=\frac{b(v)-v}{\sigma}$ and recognizing that $\Phi(z)$ and $\phi(z)$ represent the normal CDF and PDF respectively, we derive a complex condition for equilibrium (as shown in Appendix I).

When using numerical optimization solutions to solve for the optimal bid, we observe that $b^{*}(v)$ exceeds $v$, and that it increases with both $\sigma$ and $n$. This matches our expectations given the assumptions - as long as the solver sampling in $X$ is independent, additional solvers act to reduce the expectation of a failure penalty, and as the standard deviation increases, the solvers return in expectation increases with their expectation of positive slippage augmented by a lower bound on the penalty.

Figure 4: The optimal bid ratio, $\frac{b^{*}(v)}{v}$, as a function of $n$ and $\sigma$, with an initial value of $v=\$3,500$ and a range of $[\$0,\$12.00]$ for $\sigma$.

4.4 Model Limitations

It is important to note that the model proposed in this section assumes that solver valuations sampled from $X$ are independent. In reality, however, these valuations are highly covariant, and solver competition often results in congestion costs that reduce the overall welfare of participants (Chitra, Kulkarni, Pai, and Diamandis 2024) [11].

Another important caveat is the simplifying assumption that the expectation of solver bids are rank-agnostic: $\mathbb{E}[b(v_{i})]\approx\mathbb{E}[b(v_{j})\,|\,b(v_{j})<b(v_{i})]$. If all solvers bid the same $b(v)$ then one solver’s success fully offsets the failure cost of all the others. In reality, differences in the private valuations at $t_{0}$ would lead to a distribution of bids, which would increase the expectation of failure costs. A model treating each bid as an order statistic may lead to a more applicable framework for deriving an optimal bid formula.

While the assumptions of independent $X$ samples and rank-agnostic bid expectations are likely resulting in inflated optimal bid values, the potential for the failure cost mechanism to unlock a path towards users internalizing a portion of the expectation of positive slippage is promising. Understanding how correlated or covarying valuations affect equilibrium bidding behavior, the distribution of failure costs, and the dynamics of censorship resistance would significantly deepen our theoretical understanding and practical guidance. Future research that incorporates these complexities would improve the model’s predictive power and deepen our knowledge of the mechanism.

5. Implications & Observations

Beyond its primary role in enhancing censorship resistance, the failure cost mechanism also encourages more responsible bidding behavior. Without a penalty for failed bids, solvers might submit numerous low-quality or speculative solutions (i.e., high bid, low probability of payment), consuming valuable resources. Here, the financial penalty for failure motivates solvers to ensure their solutions are valid and likely to succeed.

5.1 Permissionlessness

The failure cost mechanism allows solvers to participate in order flow auctions (OFAs) without relying on a reputation system. As long as they maintain the required escrow balances, their bids can be considered. This makes the OFA inherently permissionless unless the auctioneer chooses to impose additional restrictions.

While permissionless bidding may influence execution quality, achieving optimal execution is not the only goal. Fundamentally, permissionlessness aligns with the core principles of decentralized blockchains and their applications. We believe this attribute is inherently valuable, and we hope readers appreciate its importance in fostering open, accessible, and censorship-resistant ecosystems.

5.2 Blockchain Throughput

Intuitively, a blockchain’s throughput (total gas per block) is an upper bound for an on-chain auction’s throughput (total gas per OFA), which directly influences both censorship resistance and execution quality. Increasing the throughput makes censorship more resource-intensive and less economically viable, encouraging legitimate solvers to participate and submit robust solutions. A higher throughput allows more $SolverOperation$s to fit into a block, increasing competition and pushing bids upward, ultimately improving the beneficiary’s payoff.

Reduced censorship risk and greater solver participation lead to more frequent successful executions and lower failure costs in expectation, prompting solvers to bid more aggressively. This dynamic reduces the amount of capital each solver must escrow, which reduces barriers to entry, improves execution outcomes, and increases capital efficiency of market makers - the blockchain’s primary active liquidity providers.

5.3 Applications to Cross-Chain Orders

Beyond enhancing UX in a single-chain context, the ability to offer a guaranteed minimum outcome without on-chain state checks has potential implications for cross-chain interactions. In cross-chain swaps (also known as intent-based bridging or chain abstraction), transactions may span multiple chains, introducing delays as information and assets move through bridges.

If the guaranteed minimum outcome can be computed asynchronously—without waiting for confirmations or state changes on the destination chain—users might receive timely assurance on their eventual outcome even when assets have not yet crossed the bridge. This early assurance could reduce uncertainty, encourage participation in multi-chain strategies, and improve overall efficiency in cross-chain trades. For complex orders requiring multiple interdependent cross-chain interactions, the guaranteed minimum outcomes of each step could be calculated and used as the foundation of the following step, enabling multiple solvers to trustlessly coordinate while executing the steps in parallel.

These potential benefits highlight the need for further research. How might this asynchronous guarantee interact with various bridging protocols, liquidity conditions, or complex multi-chain topologies? Investigating these questions could uncover valuable insights into extending the mechanism’s application.

Conclusion

In this work, we introduced and analyzed a novel on-chain settlement mechanism for order flow auctions centered around the concept of a failure cost. This mechanism imposes a structured penalty on solvers who gain the right to execute but fail to pay their bid, ensuring that participants bear real consequences for low-quality, manipulative, or obstructive bidding tactics. By doing so, it strengthens censorship resistance, discourages spam or spoof bids, and guarantees the beneficiary a predictable minimum payout—even under worst-case conditions.

Our analysis demonstrates that the mechanism leads participants toward a Bayes-Nash equilibrium, where no single solver can profitably deviate from their chosen strategy once the equilibrium is established. While the mechanism does not ensure strict incentive compatibility or dominant strategies, it does encourage bidding behavior guided by rational, forward-looking expectations. Solvers must carefully weigh private valuations against the risk of failure, adjusting their bids to maximize their expected payoff in a competitive and uncertain environment.

In a more dynamic scenario where valuations and external information evolve between bid submission and execution, the complexity and strategic considerations deepen. Nonetheless, the key principles remain: the failure cost mechanism aligns economic incentives, encourages meaningful engagement from solvers, and fosters an environment in which quality, reliability, and well-informed bidding become the norm. As decentralized finance and blockchain-based auctions continue to mature, these insights—rooted in equilibrium analysis, throughput considerations, and the interplay of risk, valuation, and competitive strategies—offer a robust theoretical and practical foundation for designing next-generation auction protocols that serve both solvers and end-users more effectively.

Acknowledgements

We would like to thank Tom Mroz, Christian Saur, Nagu Thogiti and the FastLane team for their advice, input, and support in the creation of this paper.

Appendix I - Math

Foundational Strategy

Solving for the utility function:

Background: bidder $-i$ bids $b$
Scenario 1: ”If I want to bid more than $b$ I will go first, so I bid $b+\epsilon$”

$$U_{i}(b_{i}=b+\epsilon)=(1-q)[v-b-\epsilon]\ +\ q\frac{-\epsilon}{n}\ +\ q^{n}\frac{-b}{n}$$

Scenario 2: ”I want to bid the same as everyone else, so I bid $b$”

$$U_{i}(b_{i}=b+\epsilon) =\sum_{k=0}^{n-1}\Bigl{[}(1-q^{k})\cdot 0\;+\;q^{k}(1-q)(v-b)\;+\;q^{k}\,q\,\Bigl{(}\tfrac{-b}{n}\Bigr{)}\;+\;q^{k}\,q\,\Bigl{(}1-q^{\,n-k-1}\Bigr{)}\Bigl{(}\tfrac{b}{n}\Bigr{)}\Bigr{]}$$

$$=\;\sum_{k=0}^{n-1}\Bigl{[}q^{k}(1-q)(v-b)\;-\;\tfrac{b}{n}\,q^{k+1}\;+\;\tfrac{b}{n}\,q^{k+1}\Bigl{(}1-q^{\,n-k-1}\Bigr{)}\Bigr{]}$$

$$=\;\sum_{k=0}^{n-1}q^{k}(1-q)(v-b)\;+\;\tfrac{b}{n}\,\sum_{k=0}^{n-1}\Bigl{[}-\,q^{k+1}\;+\;q^{k+1}\bigl{(}1-q^{\,n-k-1}\bigr{)}\Bigr{]}$$

$$=\;(1-q)(v-b)\,\sum_{k=0}^{n-1}q^{k}\;+\;\tfrac{b}{n}\,\sum_{k=0}^{n-1}\Bigl{[}-\,q^{k+1}\;+\;q^{k+1}-q^{k+1}q^{\,n-k-1}\Bigr{]}$$

$$=\;(1-q)(v-b)\,\frac{1-q^{n}}{1-q}\;+\;\tfrac{b}{n}\sum_{k=0}^{n-1}\bigl{[}-\,q^{n}\bigr{]}$$

$$=\;(v-b)\,\bigl{(}1-q^{n}\bigr{)}\;-\;\tfrac{b}{n}\;\bigl{[}n\,q^{n}\bigr{]}$$

$$=\;(v-b)\,\bigl{(}1-q^{n}\bigr{)}\;-\;b\,q^{n}$$

$$=\;v\,\bigl{(}1-q^{n}\bigr{)}\;-\;b.$$

Discrete Time Strategy

$U_{i}\left[b(v_{i}),b(v_{-i})\right]\ =\$

$$\underbrace{\frac{n}{\sum_{j=1}^{n}\left[F_{X}(b(v))\right]^{n-j}}}_{\text{sum of }P(\text{execute})\text{ for all }i}$$

$$\quad\times\sum_{r=1}^{n}\Bigg{(}\underbrace{\left[F_{X}(b(v))\right]^{n-r}}_{P(\text{execute}\mid i=r)}$$

$$\quad\times\bigg{[}\underbrace{\left[1-F_{X}(b(v))\right]}_{\text{$P(\text{success}\mid\text{execute})$}}\times\underbrace{\left[v-b(v)\right]}_{\mathbb{E}[\text{success}]}$$

$$\quad+\underbrace{\left[F_{X}(b(v))\right]}_{\text{$P(\text{fail}\mid\text{execute})$}}\times\underbrace{-\left[\frac{b(v)}{n}-\left(\frac{b(v)}{n}\left[1-\left(F_{X}(b(v))\right)^{r-1}\right]\right)\right]}_{\text{$\max[\textit{failure cost}]-\mathbb{E}[\textit{cost reduction}]\times P_{-i}(\text{win}\mid-i<r)$}}\bigg{)}\Bigg{)}$$

$$=\frac{n}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}\times\sum^{n}_{r=1}\Bigg{(}\ \left[F_{X}\left(b(v)\right)\right]^{n-r}\times\bigg{[}$$

$$\left(\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\right)$$

$$+ \left(\left[F_{X}\left(b(v)\right)\right]\times\left[-\frac{b(v)}{n}\times\left(F_{X}\left(b(v)\right)\right)^{r-1}\right]\right)$$

$$\bigg{]}\Bigg{)}$$

$$=\ \frac{n}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}\times\sum^{n}_{r=1}\Bigg{(}\$$

$$\left[\left(F_{X}\left(b(v)\right)\right)^{n-r}\times\left([1-F_{X}\left(b(v)\right)\right)\times\left(v-b(v)\right)\right]$$

$$- \left[\left(F_{X}\left(b(v)\right)\right)^{n-r}\times\left(F_{X}\left(b(v)\right)\right)^{r}\times\frac{b(v)}{n}\right]$$

$$\Bigg{)}$$

$$=\frac{n\times\sum^{n}_{r=1}\left(\left[\left(F_{X}\left(b(v)\right)\right)^{n-r}\times\left([1-F_{X}\left(b(v)\right)\right)\times\left(v-b(v)\right)\right]\ -\ \left[\left(F_{X}\left(b(v)\right)\right)^{n}\times\frac{b(v)}{n}\right]\right)}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}$$

$$=\frac{n\times\sum^{n}_{r=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-r}\times\left[[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\right)}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}\ -\ \frac{n\times\left[n\ \times\ \left[\left(F_{X}\left(b(v)\right)\right)^{n}\times\frac{b(v)}{n}\right]\right]}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}$$

$$=\frac{n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\times\sum^{n}_{r=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-r}\right)}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}\ -\ \frac{n\ \times\ \left(F_{X}\left(b(v)\right)\right)^{n}\times b(v)}{\sum^{n}_{j=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-j}\right)}$$

$$=n\times\frac{\left(\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\times\sum^{n}_{r=1}\left[\left(F_{X}\left(b(v)\right)\right)^{n-r}\right]\right)\ -\ \left(\left[F_{X}\left(b(v)\right)\right]^{n}\times b(v)\right)}{\sum^{n}_{r=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-r}\right)}$$

$$=n\times\left[\left(\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\right)\ -\ \left(b(v)\times\frac{\left[F_{X}\left(b(v)\right)\right]^{n}}{\sum^{n}_{r=1}\left(\left[F_{X}\left(b(v)\right)\right]^{n-r}\right)}\right)\right]$$

$$=n\times\left[\left(\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\right)\ -\ \left(b(v)\times\frac{\left[F_{X}\left(b(v)\right)\right]^{n}}{\frac{1-\left[F_{X}\left(b(v)\right)\right]^{n}}{1-\left[F_{X}\left(b(v)\right)\right]}}\right)\right]$$

$$=n\times\left[\left(\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-b(v)\right]\right)\ -\ \left(b(v)\times\frac{\left[F_{X}\left(b(v)\right)\right]^{n}\times\left(1-\left[F_{X}\left(b(v)\right)\right]\right)}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right)\right]$$

$$=n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[\left(v-b(v)\right)\ -\ \left(\frac{b(v)\times\left[F_{X}\left(b(v)\right)\right]^{n}}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right)\right]$$

$$=n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[\left(\frac{\left[\left(1-\left[F_{X}\left(b(v)\right)\right]^{n}\right)\times\left(v-b(v)\right)\right]\ -\ \left(b(v)\times\left[F_{X}\left(b(v)\right)\right]^{n}\right)}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right)\right]$$

$$=n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[\left(\frac{\left[v\times\left(1-\left[F_{X}\left(b(v)\right)\right]^{n}\right)\right]\ -\ \left(b(v)\times\left(1-\left[F_{X}\left(b(v)\right)\right]^{n}\right)+\left[F_{X}\left(b(v)\right)\right]^{n}\right)}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right)\right]$$

$$=n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[\left(\frac{\left[v\times\left(1-\left[F_{X}\left(b(v)\right)\right]^{n}\right)\right]\ -\ b(v)}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right)\right]$$

$$U_{i}\left[b(v_{i}),b(v_{-i})\right]\ =\ n\times\left[1-F_{X}\left(b(v)\right)\right]\times\left[v-\frac{b(v)}{1-\left[F_{X}\left(b(v)\right)\right]^{n}}\right]$$

Numerical Analysis

The equilibrium bid $b^{*}(v)$ is found by setting the derivative of $U_{i}[b(v)]$ with respect to $b(v)$ to zero. Assume $X\sim N(v,\sigma^{2})$. Letting $z=\frac{b(v)-v}{\sigma}$ and recognizing that $\Phi(z)$ and $\phi(z)$ represent the normal CDF and PDF respectively, we derive a complex condition for equilibrium:

$$U_{i}[b(v)] =n\biggl{[}v(1-F_{X}(b(v)))+\sigma f_{X}(b(v))-\frac{b(v)(1-F_{X}(b(v)))}{1-[F_{X}(b(v))]^{n}}\biggr{]}$$

$$=n\left[v(1-\Phi(z))+\sigma\frac{\phi(z)}{\sigma}-\frac{b(v)(1-\Phi(z))}{1-[\Phi(z)]^{n}}\right]$$

$$=n\left[v(1-\Phi(z))+\phi(z)-\frac{b(v)(1-\Phi(z))}{1-[\Phi(z)]^{n}}\right]$$

$$\frac{d}{db(v)}[v(1-\Phi(z))]=v(-\frac{\phi(z)}{\sigma})$$

$$\frac{d}{db(v)}[\phi(z)] =\frac{d\phi(z)}{db(v)}$$

$$=\frac{-z\phi(z)}{\sigma}$$

$$Q(b(v))=\frac{b(v)(1-\Phi(z))}{1-[\Phi(z)]^{n}}$$

$$\frac{d}{db(v)}[b(v)(1-\Phi(z))]=(1-\Phi(z))+b(v)(-\frac{\phi(z)}{\sigma})$$

$$\frac{d}{db(v)}[1-(\Phi(z))^{n}]=-n(\Phi(z))^{n-1}\frac{\phi(z)}{\sigma}$$

$$\frac{dQ}{db(v)} =\frac{(1-[\Phi(z)]^{n})\frac{d}{db(v)}[b(v)(1-\Phi(z))]-b(v)(1-\Phi(z))\frac{d}{db(v)}[1-[\Phi(z)]^{n}]}{[1-(\Phi(z))^{n}]^{2}}$$

$$=\frac{(1-(\Phi(z))^{n})[(1-\Phi(z))-\frac{\phi(z)}{\sigma}b(v)]-b(v)(1-\Phi(z))[-n(\Phi(z))^{n-1}\frac{\phi(z)}{\sigma}]}{[1-(\Phi(z))^{n}]^{2}}$$

$$\frac{dU_{i}}{db(v)} =n\Biggl{[}\frac{d}{db(v)}[v(1-\Phi(z))]+\frac{d}{db(v)}[\phi(z)]-\frac{dQ}{db(v)}\Biggr{]}$$

$$=n\Biggl{[}-\frac{v\phi(z)}{\sigma}-\frac{z\phi(z)}{\sigma}-\frac{dQ}{db(v)}\Biggr{]}$$

$$=n\left[-\frac{v\cdot\Phi(z)}{\sigma}-z\cdot\Phi(z)+\frac{1-\frac{\phi(z)-b(v)\cdot\Phi(z)}{\sigma}}{1-(\frac{\phi(z)}{\sigma})^{n}}+\frac{(1-\frac{\phi(z)}{\sigma})b(v)n(\frac{\phi(z)}{\sigma})^{n-1}\Phi(z)/\sigma}{(1-(\frac{\phi(z)}{\sigma})^{n})^{2}}\right]$$