Skip to main content

​
Parasitic open interest

Parasitic open interest is when an application tries to use an oracle game price without paying for the oracle game. This creates two incentives: delay and censorship. The censorship risk is addressed above — contrived oracle games exploit the parasitic OI out of existence. To the extent parasitic open interest dodges censorship risk, it can actually benefit the parties that paid for the oracle game. For example, in a lending-style liquidation setup, the oracle game can feature protocol fees. A 1% protocol fee per round can be directed to a protocolFeeRecipient\text{protocolFeeRecipient} address specified at oracle game creation — a smart contract designed to split accrued fees between the lender and borrower who paid for the oracle game. The delay incentive for liquidation is, as a one-step heuristic framed in probability times payoff terms:
P(ST>K)⋅payoff>cost to delayP(S_T > K) \cdot \text{payoff} > \text{cost to delay}
where the payoff is the liquidation penalty, KK is the liquidation price, STS_T is the price at settlement time, and the cost to delay the oracle is approximately 1% of the oracle game size at that round. If the parasitic open interest is very large, the cost to delay is small relative to the payoff, but since the initial oracle liquidity was a function of the non-parasitic open interest to begin with (say 10%), the exponential fees in expectation can more than cover the delay. For example, with M=2M = 2, the oracle game becomes larger than the paying notional in 4 rounds of delay (10% →\to 20% →\to 40% →\to 80% →\to 160%), paying 1% each time split between the original borrower and lender (0.1% →\to 0.2% →\to 0.4% →\to 0.8% →\to 1.6% and so on, as a percentage of paying notional).

​
Linear notional manipulation

​
Manipulation without a swap fee

Assume zero swap fees, protocol fees, and gas fees. Assume the manipulator always front-runs any other disputers and ends up on-chain first (this assumption is relaxed in the stronger form below). Assume a normal distribution. Also, unless otherwise noted, assume zero censorship. The manipulator is trying to bias the settled oracle price as much as possible in their favor. For linear notionals, generally it’s preferable to have ~0 fees and low multipliers in the oracle game since this maximizes oracle accuracy.

​
Distributional robustness

We use normal distributions below for tractability. The key quantities for manipulation bounds are honest dispute barriers, DNT survival, and conditional mean settled bias. Across tested families, results are directionally similar in the relevant parameter range: volatility scale is typically the dominant driver, while distribution shape can shift the maximizing barrier and survival probabilities. In our tests, these shape effects usually did not increase the core bound C=max⁡A(1−Q(A))⋅AC = \max_A (1 - Q(A)) \cdot A for linear notionals. See Oracle Accuracy & Cost for further discussion.

​
Wrong-price reporting

From Oracle Accuracy & Cost, the no-dispute band is ± 0.65⋅M⋅σ(T)\pm\, 0.65 \cdot M \cdot \sigma(T). Assume M=1.1M = 1.1, implying the honest dispute barriers are approximately ± 0.72⋅σ(T)\pm\, 0.72 \cdot \sigma(T). We will use a slightly wider ± 0.8⋅σ(T)\pm\, 0.8 \cdot \sigma(T) for conservatism. A manipulator opening a long wants to settle the oracle price as low as possible relative to the true price. We call the mean difference between these two prices extraction. Strategy 1: Place wrong price and update. The manipulator places a price some YY above the lower dispute barrier. If the true price rises by just under YY, the manipulator updates their report YY higher before the honest dispute network can profitably dispute. If the true price falls by approximately 0.8−Y0.8 - Y standard deviations, the manipulator places a new price YY above the lower barrier from the current price. The extractable value is modeled as a barrier game with upper barrier at +Y+Y and lower barrier at −0.8+Y-0.8 + Y. The per-round survival probability Q(Y)Q(Y) is the DNT (double-no-touch) probability for these barriers, and expected rounds to settlement is 1/Q(Y)1/Q(Y). The number of rounds is minimized (and survival maximized) when the barriers are centered on the true price, i.e. Y=b/2Y = b/2 where b=0.8b = 0.8. At this point the reported price is −b/2-b/2 below true, and by symmetry the conditional mean price given survival is 0. So the expected extraction at settlement is simply b/2=0.40⋅σ(T)b/2 = 0.40 \cdot \sigma(T). This approximately holds for any choice of YY. In the low-survival regime produced by these barrier widths, the conditional mean of the true price given survival (DNT) in an interval [l,u][l, u] converges to the midpoint of the interval. Our barriers are at (Y−b, Y)(Y - b,\, Y), so the conditional mean is (Y−b+Y)/2=Y−b/2(Y - b + Y)/2 = Y - b/2. The extraction is then the conditional mean minus the reported price: (Y−b/2)−(Y−b)=b/2(Y - b/2) - (Y - b) = b/2. As YY moves away from b/2b/2, the reported price gets farther from true (more potential extraction), but the conditional mean shifts in the same direction by the same amount, nearly offsetting it. Extraction is approximately b/2b/2 in this regime, while expected rounds increase as YY moves away from b/2b/2. For equal-width barriers, asymmetric placement (starting point not at the midpoint) strictly lowers the per-round survival probability compared to symmetric placement, strictly increasing expected rounds with little to no extraction gain. For b=0.8b = 0.8, even the best-case YY gives a very small per-round survival probability, meaning many rounds are needed. The sim confirms this: Barrier game analysis The Extract column is noisy due to low survival rates and discrete-step barrier artifacts. This does not seem like a viable strategy in the real world, given the high number of rounds needed with 10% growth in game size each round. Fewer rounds yield proportionately less. Strategy 2: Report wrong price and hope it settles. The manipulator reports a price YY below true and lets the honest network dispute at their standard barriers. If disputed, the manipulator reports another wrong price and tries again. If the manipulator reports YY lower than true, the honest dispute barriers shift to (−0.8−Y, 0.8−Y)(-0.8 - Y,\, 0.8 - Y) around the true price. The reported price sits at −Y-Y, which is the midpoint of these barriers: (−0.8−Y+0.8−Y)/2=−Y(-0.8 - Y + 0.8 - Y)/2 = -Y. By the same midpoint approximation as Strategy 1 (tight in this low-survival regime), the conditional mean true price given survival converges to the midpoint of the barrier interval, which is −Y-Y. So the expected extraction is the conditional mean minus the reported price: −Y−(−Y)≈0-Y - (-Y) \approx 0. The wrong price placement is nearly exactly offset by conditional survival bias. Wrong-price strategy 2 The sim confirms extraction is near zero for all choices of YY. This strategy does not seem worth pursuing given near-zero extraction.

​
Stronger form: true-price delay / timer refresh

The stronger-form manipulation strategy is: report the true price each round, and dispute exactly when delaying has higher utility than settling (Udelay>UsettleU_{\text{delay}} > U_{\text{settle}}), which we define as “favorable” vs “unfavorable.” This is a stopping-time game with first-passage probabilities (DNT), escalating round size, and endogenous stop decisions. We attempt to approximate this optimal control problem numerically below. The analysis is nontrivial and the numerical results should be treated as approximate. Assume the manipulator is opening a long with some external notional NN and wants the settled oracle price lower than the true price in a way that maximizes their expected value, and the counterparty is passive. The manipulator can either delay the game or let it settle, depending on which decision is worth more. Unlike the wrong-price strategies above, the front-running assumption is relaxed here: we assume the honest network gets disputes across at their standard barriers. Let zz be the price error in sigma units at the moment the round is about to settle, SnS_n the oracle game size at round nn, and Vn+1V_{n+1} the continuation value of future disputes. When the manipulator disputes, they earn ∣z∣⋅σ(T)⋅Sn|z| \cdot \sigma(T) \cdot S_n as an internal oracle-game transfer (the profit from correcting the previous reporter’s stale price, not external notional PnL). However, as the new reporter they lose in expectation to future honest disputers. The 0.65⋅M0.65 \cdot M cost term reflects the expected loss from providing new reporter liquidity (see Oracle Accuracy & Cost). This approximation may be off, as discussed in Accuracy under manipulation. Further below, in the “Incorporating self-consistent dispute barriers” section, we revisit this with the self-consistent barrier κ\kappa.
Usettle(z)=−z⋅N⋅σ(T)U_{\text{settle}}(z) = -z \cdot N \cdot \sigma(T)
Udelay(z,n)=∣z∣⋅σ(T)⋅Sn−0.65⋅M⋅σ(T)⋅Sn+Vn+1U_{\text{delay}}(z, n) = |z| \cdot \sigma(T) \cdot S_n - 0.65 \cdot M \cdot \sigma(T) \cdot S_n + V_{n+1}
The continuation value Vn+1V_{n+1} can be computed using dynamic programming (backward induction). Assume dispute barriers at ± 0.65⋅M⋅σ(T)\pm\, 0.65 \cdot M \cdot \sigma(T), a multiplier MM, and initial liquidity LL with Sn=L⋅MnS_n = L \cdot M^n. Define a round cap (say 80). Technically, the net cost to dispute at round nn is:
(0.65⋅M−∣z∣)⋅σ(T)⋅Sn(0.65 \cdot M - |z|) \cdot \sigma(T) \cdot S_n
which can be arbitrarily small if the settlement price zz is close to the dispute barrier ± 0.65⋅M\pm\, 0.65 \cdot M. However, at round 80, S80=L⋅M80S_{80} = L \cdot M^{80} is so large that the required closeness to the barrier relative to the external profit potential is so unlikely that we set V80=0V_{80} = 0 as the base case. Working backwards from there: at round 79, we know V80=0V_{80} = 0, so we can compute UdelayU_{\text{delay}} and UsettleU_{\text{settle}} for every possible settlement price zz. S79S_{79} is still very likely astronomically large, so the attacker settles almost everything and V79V_{79} is barely above 0. This continues for many rounds backwards: the game is too expensive, the manipulator doesn’t really dispute, VV is tiny. Eventually we reach a round where SnS_n is small enough relative to NN that delaying an unfavorable settlement is at least somewhat likely to be cheaper than eating the external loss. At this point, the attacker blocks bad outcomes (delay) and keeps good ones (settle). Each step backwards adds another chance at a favorable settlement, so VV grows. More precisely, at each round nn:
Vn=phit⋅Vn+1+psurvive⋅E[max⁡(Usettle, Udelay)  ∣  survive]V_n = p_{\text{hit}} \cdot V_{n+1} + p_{\text{survive}} \cdot E\bigl[\max(U_{\text{settle}},\, U_{\text{delay}}) \;\big|\; \text{survive}\bigr]
where phitp_{\text{hit}} is the probability the honest network disputes (round continues automatically) and psurvive=1−phitp_{\text{survive}} = 1 - p_{\text{hit}} is the probability the round survives to settlement. By round 0, V0V_0 reflects the full value of being able to selectively settle over all future rounds. This is the manipulator’s total expected utility, which is external extraction net of internal dispute losses:
V0=bias⋅N⋅σ(T)−E[internal losses]V_0 = \text{bias} \cdot N \cdot \sigma(T) - E[\text{internal losses}]
The internal losses (dispute costs minus dispute income) are tracked separately through the recursion. Rearranging:
bias=V0+E[internal losses]N⋅σ(T)\text{bias} = \frac{V_0 + E[\text{internal losses}]}{N \cdot \sigma(T)}
As a simple example, take M=1.18M = 1.18, L/N=15%L/N = 15\% (L = 100k, N = 667k), σ(T)=2%\sigma(T) = 2\%, dispute barriers at ± 0.767⋅σ(T)\pm\, 0.767 \cdot \sigma(T), per-round survival probability ∼18%\sim 18\%, and a round cap of 80. We set V80=0V_{80} = 0 as the base case for the reasons described above. Working backwards, VV stays small for many rounds because the game is too expensive to dispute except for the most extreme zz values near the barrier. As the game size shrinks toward NN, delaying becomes worthwhile for a wider range of unfavorable settlements and VV grows. By round 12, the game size (S12≈729k≈NS_{12} \approx 729\text{k} \approx N) is comparable to the notional and the attacker disputes a meaningful share of survivors. Consider z=+0.5z = +0.5 (unfavorable for the manipulator wanting lower):
Usettle=−0.5⋅667k⋅0.02=−6,667U_{\text{settle}} = -0.5 \cdot 667\text{k} \cdot 0.02 = -6{,}667
Udelay=0.5⋅729k⋅0.02−0.767⋅729k⋅0.02+V13=7,290−11,183+287=−3,606\begin{aligned} U_{\text{delay}} &= 0.5 \cdot 729\text{k} \cdot 0.02 - 0.767 \cdot 729\text{k} \cdot 0.02 + V_{13} \\ &= 7{,}290 - 11{,}183 + 287 \\ &= -3{,}606 \end{aligned}
Delaying costs 3,606 while settling costs 6,667, so the attacker delays. But for z=−0.3z = -0.3 (favorable), Usettle=+4,000U_{\text{settle}} = +4{,}000 and delaying is deeply negative, so the attacker happily settles. Running this numerically over the conditional distribution of zz given survival:
V12=0.82⋅V13⏟honest dispute+0.18⋅E[max⁡(Usettle,Udelay)]⏟survives: attacker chooses≈236+105≈340V_{12} = \underbrace{0.82 \cdot V_{13}}_{\text{honest dispute}} + \underbrace{0.18 \cdot E[\max(U_{\text{settle}}, U_{\text{delay}})]}_{\text{survives: attacker chooses}} \approx 236 + 105 \approx 340
82% of the time, the honest network disputes and the game continues to round 13 (the attacker gets V13V_{13} for free). 18% of the time, the round survives and the attacker picks whichever of settle or delay is better for each zz. At round 11, the same calculation uses V12=340V_{12} = 340 as the continuation value. The game is slightly cheaper (S11≈618kS_{11} \approx 618\text{k}), so the attacker disputes a slightly wider range of unfavorable zz, and V11≈403V_{11} \approx 403. Each step backwards adds another chance at a favorable settlement while blocking unfavorable ones, and VV grows. By round 0, V0≈1,566V_0 \approx 1{,}566 with expected internal losses (dispute costs net of dispute income) of approximately 795795. Applying the formula:
bias=1,566+795667,000⋅0.02≈0.18⋅σ(T)\text{bias} = \frac{1{,}566 + 795}{667{,}000 \cdot 0.02} \approx 0.18 \cdot \sigma(T)
or about 0.35%0.35\% of price. We then sweep this method across different choices of initial liquidity fraction L/NL/N and multiplier MM to find the parameter configuration that minimizes expected bias. Expected bias in units of σ(T)\sigma(T): 
L/N     M=1.10  M=1.15  M=1.20  M=1.25  M=1.30  M=1.35  M=1.40
0.050   0.250   0.243   0.241   0.243   0.255   0.263   0.272
0.075   0.227   0.220   0.218   0.220   0.231   0.239   0.247
0.100   0.209   0.203   0.201   0.203   0.213   0.220   0.228
0.125   0.194   0.189   0.187   0.188   0.199   0.205   0.213
0.150   0.182   0.177   0.175   0.177   0.187   0.193   0.200
0.200   0.162   0.158   0.156   0.158   0.167   0.173   0.179
0.300   0.134   0.131   0.128   0.130   0.139   0.144   0.149
Lower liquidity increases bias (the game is too cheap relative to the notional, giving the attacker more rounds to selectively settle). Bias is non-monotonic in MM: increasing MM widens the dispute barriers (larger price errors survive each round, increasing bias) but also escalates the game faster (making disputes more expensive, decreasing bias). These effects compete, producing a minimum around M≈1.20M \approx 1.20. For a fixed MM, the minimum bias occurs at high L/NL/N, but higher liquidity means the initial reporter must be compensated for bearing risk on a larger position. To capture this tradeoff, we add the reporter compensation cost and score each parameter choice by:
scoreα=0.65⋅(L/N)+α⋅∣bias∣\text{score}_\alpha = 0.65 \cdot (L/N) + \alpha \cdot |\text{bias}|
where 0.65⋅(L/N)0.65 \cdot (L/N) approximates reporter cost as a fraction of notional (from Oracle Accuracy & Cost) and α\alpha weights how aggressively bias is penalized. With α=1\alpha = 1 (neutral weighting): 
L/N     M=1.10  M=1.15  M=1.20  M=1.25  M=1.30  M=1.35  M=1.40
0.050   0.282   0.275   0.273   0.275   0.287   0.295   0.304
0.075   0.275   0.269   0.267   0.269   0.280   0.287   0.296
0.100   0.274   0.268   0.266   0.268   0.278   0.285   0.293
0.125   0.275   0.270   0.268   0.270   0.280   0.287   0.294
0.150   0.279   0.275   0.272   0.274   0.284   0.290   0.298
0.200   0.292   0.289   0.286   0.288   0.297   0.303   0.309
0.300   0.329   0.326   0.323   0.325   0.334   0.339   0.344
The minimum sits at L/N≈10%L/N \approx 10\%, M≈1.20M \approx 1.20 with a score of ∼0.266\sim 0.266. The surrounding region is a broad basin: many nearby pairs score within a few percent of the minimum, meaning small parameter changes do not dramatically alter outcomes.
Self-dispute caveat
An attacker can try to front-run honest disputers and self-dispute to avoid the internal oracle-game losses above. If the policy is held fixed and the front-run is perfect, this just removes the internal transfer: same round count, same bias, higher net profit. But removing the internal penalty changes the optimal policy. It raises the delay value, so the attacker delays in weakly more states. This lowers the per-round settlement probability Q∗Q^*, pushing toward the cost blow-up boundary Q∗>1−1/MQ^* > 1 - 1/M from Economic Bounds. Specifically, if the internal loss is fully avoided and the policy is unconstrained, the attacker targets settlement only in very favorable states — right below the dispute barrier in their favor — to maximize per-settlement extraction. This increases the payoff per successful settle, but crushes the per-round settlement probability. Expected rounds then scale as ∼1/Q∗\sim 1/Q^*, and the required reporter stake grows geometrically (Sn=L⋅MnS_n = L \cdot M^n), making the strategy extremely brittle to any execution miss. The tradeoff is better per-hit extraction at the cost of a huge round count and capital explosion. In the real world, dispute barriers are not a fixed quantity. Different disputers have different thresholds, the manipulator cannot always get on chain first, there are discontinuous price jumps that must be bid against in discrete block units, and so on. These frictions all work against the attacker’s ability to reliably capture the dispute slot with no cost every round.
Explicit transfer accounting
The stronger form section above uses a coarse reporter loss term in Udelay(z,n)U_{\text{delay}}(z,n). Here, we replace that with explicit transfer accounting in the state machine. We use two reporter identity states: HH means the current reporter is honest, and AA means the current reporter is attacker controlled. For this formulation, we assume: if the round hits an honest dispute barrier, control transitions to honest next round (A→HA \to H and H→HH \to H on hit). If the round survives and the attacker chooses delay, the attacker has control next round (H→AH \to A and A→AA \to A on survive & delay). We keep the same honest barriers ± 0.65⋅M⋅σ(T)\pm\,0.65\cdot M\cdot\sigma(T) and same round growth Sn=L⋅MnS_n=L\cdot M^n. The key change is that losses are realized only when they are actually realized in the game flow. Using the stronger form notation defined above:
Usettle(z)=−z⋅N⋅σ(T)U_{\text{settle}}(z) = -z \cdot N \cdot \sigma(T)
UdelayH(z,n)=∣z∣⋅σ(T)⋅Sn+Vn+1AU_{\text{delay}}^{H}(z,n) = |z| \cdot \sigma(T) \cdot S_n + V_{n+1}^{A}
UdelayA(z,n)=Vn+1AU_{\text{delay}}^{A}(z,n) = V_{n+1}^{A}
If a hit happens from attacker-reporter state, capture succeeds with probability pcapturep_{\text{capture}}. On failed capture, attacker control is lost and the reporter-side loss is realized explicitly:
VhitA(n)=pcapture⋅Vn+1A+(1−pcapture)⋅(Vn+1H−0.65⋅M⋅σ(T)⋅Sn)V_{\text{hit}}^{A}(n) = p_{\text{capture}}\cdot V_{n+1}^{A} + (1-p_{\text{capture}})\cdot\left(V_{n+1}^{H} - 0.65\cdot M\cdot \sigma(T)\cdot S_n\right)
With this hit transition, the value function recursions are:
VnH=phit⋅Vn+1H+psurvive⋅E ⁣[max⁡ ⁣(Usettle(z),UdelayH(z,n)) | survive]V_n^{H} = p_{\text{hit}}\cdot V_{n+1}^{H} + p_{\text{survive}}\cdot \mathbb{E}\!\left[\max\!\left(U_{\text{settle}}(z), U_{\text{delay}}^{H}(z,n)\right) \,\middle|\, \text{survive}\right]
VnA=phit⋅VhitA(n)+psurvive⋅E ⁣[max⁡ ⁣(Usettle(z),UdelayA(z,n)) | survive]V_n^{A} = p_{\text{hit}}\cdot V_{\text{hit}}^{A}(n) + p_{\text{survive}}\cdot \mathbb{E}\!\left[\max\!\left(U_{\text{settle}}(z), U_{\text{delay}}^{A}(z,n)\right) \,\middle|\, \text{survive}\right]
Vnmax⁡H=Vnmax⁡A=0V_{n_{\max}}^{H}=V_{n_{\max}}^{A}=0
Like before, bias is decomposed from total EV plus internal transfer accounting:
V0A=bias⋅N⋅σ(T)−E[internal losses]V_0^{A} = \text{bias}\cdot N\cdot\sigma(T) - \mathbb{E}[\text{internal losses}]
bias=V0A+E[internal losses]N⋅σ(T)\text{bias}=\frac{V_0^{A}+\mathbb{E}[\text{internal losses}]}{N\cdot\sigma(T)}
We first sweep this explicit transfer model at pcapture=0p_{\text{capture}}=0 across the same L/NL/N and MM grid (round cap nmax⁡=80n_{\max}=80). Expected bias in units of σ(T)\sigma(T): 
L/N     M=1.10  M=1.15  M=1.20  M=1.25  M=1.30  M=1.35  M=1.40
0.050   0.224   0.217   0.221   0.232   0.245   0.257   0.264
0.075   0.202   0.196   0.200   0.211   0.225   0.236   0.242
0.100   0.186   0.180   0.184   0.195   0.209   0.220   0.225
0.125   0.172   0.167   0.172   0.183   0.196   0.207   0.211
0.150   0.161   0.156   0.161   0.172   0.186   0.196   0.200
0.200   0.143   0.139   0.144   0.155   0.168   0.178   0.181
0.300   0.117   0.113   0.118   0.129   0.142   0.151   0.152
With score =0.65⋅(L/N)+∣bias∣=0.65\cdot(L/N)+|\text{bias}|: 
L/N     M=1.10  M=1.15  M=1.20  M=1.25  M=1.30  M=1.35  M=1.40
0.050   0.256   0.249   0.253   0.264   0.278   0.290   0.297
0.075   0.251   0.245   0.249   0.260   0.273   0.285   0.291
0.100   0.251   0.245   0.249   0.260   0.274   0.285   0.290
0.125   0.254   0.248   0.253   0.264   0.277   0.288   0.292
0.150   0.259   0.254   0.259   0.270   0.283   0.293   0.297
0.200   0.273   0.269   0.274   0.285   0.298   0.308   0.311
0.300   0.312   0.308   0.313   0.324   0.337   0.346   0.347
Under explicit transfer accounting, the minimum is at approximately L/N=7.5%L/N=7.5\%, M=1.15M=1.15, score ≈0.245\approx 0.245. Next, holding that basin pair fixed (L/N=7.5%L/N=7.5\%, M=1.15M=1.15), we sweep self-dispute success probability at the honest barrier hit transition, this time using 200 rounds: 
p_capture   Rounds   Q_A(0)   Bias (sigma units)   Score
0.00         11.83   0.0592       0.194            0.243
0.25         11.82   0.0592       0.193            0.242
0.50         11.79   0.0594       0.193            0.242
0.75         11.76   0.0595       0.192            0.241
0.90         12.17   0.0569       0.201            0.250
0.95        131.91   0.0000       0.000            0.049
In this model, bias is fairly stable through moderate capture success, then behavior changes sharply at high capture: the optimal policy moves toward almost always delaying (QA(0)→0Q_A(0)\to 0), expected rounds rise dramatically, and measured external signed bias can collapse toward zero because settlement is pushed into late round states. At round cap 200, this shift is already visible at pcapture=0.95p_{\text{capture}}=0.95. This is driven by continuation value dominating both settle utility and loss-of-control loss. When we add an escalation halt into the mix (the point past which the game stops increasing in size each round but disputes can still continue), we see the degenerate regime collapse. For example, for pcapture=0.95p_{\text{capture}}=0.95 across varying escalation halts, we see: 
halt multiple   Rounds   Q_A(0)   Bias (sigma units)   Score
0.10             67.46   0.0158       0.538            0.586
0.20             43.02   0.0240       0.482            0.531
0.50             24.58   0.0368       0.389            0.438
1.00             16.60   0.0452       0.304            0.353
2.00             14.88   0.0488       0.252            0.301
5.00             13.91   0.0500       0.226            0.275
10.00            13.81   0.0498       0.225            0.274
20.00            13.80   0.0495       0.225            0.274
50.00            13.87   0.0488       0.227            0.275
100.00           13.97   0.0483       0.228            0.277
Incorporating self-consistent dispute barriers
From Oracle Accuracy & Cost, the honest dispute barriers in the presence of manipulation may be different from the simpler 0.65⋅M0.65 \cdot M bound. If we denote the self-consistent honest dispute barrier by κ\kappa, the explicit transfer DP equations become:
Usettle(z)=−z⋅N⋅σ(T)U_{\text{settle}}(z) = -z \cdot N \cdot \sigma(T)
UdelayH(z,n)=∣z∣⋅σ(T)⋅Sn+Vn+1AU_{\text{delay}}^{H}(z,n) = |z| \cdot \sigma(T) \cdot S_n + V_{n+1}^{A}
UdelayA(z,n)=Vn+1AU_{\text{delay}}^{A}(z,n) = V_{n+1}^{A}
If a hit happens from attacker-reporter state, capture succeeds with probability pcapturep_{\text{capture}}. On failed capture, attacker control is lost and the reporter-side loss is realized explicitly:
VhitA(n)=pcapture⋅Vn+1A+(1−pcapture)⋅(Vn+1H−κ⋅σ(T)⋅Sn)V_{\text{hit}}^{A}(n) = p_{\text{capture}}\cdot V_{n+1}^{A} + (1-p_{\text{capture}})\cdot\left(V_{n+1}^{H} - \kappa \cdot \sigma(T)\cdot S_n\right)
With this hit transition, the value function recursions are:
VnH=phit⋅Vn+1H+psurvive⋅E ⁣[max⁡ ⁣(Usettle(z),UdelayH(z,n)) | survive]V_n^{H} = p_{\text{hit}}\cdot V_{n+1}^{H} + p_{\text{survive}}\cdot \mathbb{E}\!\left[\max\!\left(U_{\text{settle}}(z), U_{\text{delay}}^{H}(z,n)\right) \,\middle|\, \text{survive}\right]
VnA=phit⋅VhitA(n)+psurvive⋅E ⁣[max⁡ ⁣(Usettle(z),UdelayA(z,n)) | survive]V_n^{A} = p_{\text{hit}}\cdot V_{\text{hit}}^{A}(n) + p_{\text{survive}}\cdot \mathbb{E}\!\left[\max\!\left(U_{\text{settle}}(z), U_{\text{delay}}^{A}(z,n)\right) \,\middle|\, \text{survive}\right]
Vnmax⁡H=Vnmax⁡A=0V_{n_{\max}}^{H}=V_{n_{\max}}^{A}=0
Like before, bias is decomposed from total EV plus internal transfer accounting:
V0A=bias⋅N⋅σ(T)−E[internal losses]V_0^{A} = \text{bias}\cdot N\cdot\sigma(T) - \mathbb{E}[\text{internal losses}]
bias=V0A+E[internal losses]N⋅σ(T)\text{bias}=\frac{V_0^{A}+\mathbb{E}[\text{internal losses}]}{N\cdot\sigma(T)}
The key differences from the fixed-barrier model: κ\kappa replaces 0.65⋅M0.65 \cdot M as the dispute barrier and reporter-side loss, and the survival distribution is computed at ±κ\pm\kappa rather than ±0.65⋅M\pm 0.65 \cdot M. Depending on MM, κ\kappa may be wider or tighter than 0.65⋅M0.65 \cdot M, changing both the survival probability per round and the loss on each dispute. The score function also changes, from the work in Accuracy under manipulation. The reporter cost is no longer 0.65⋅(L/N)0.65 \cdot (L/N) but f(κ)⋅(L/N)f(\kappa) \cdot (L/N), with f(κ)=(1−Q(κ))⋅κ+Q(κ)⋅Rˉ(κ)f(\kappa) = (1 - Q(\kappa)) \cdot \kappa + Q(\kappa) \cdot \bar{R}(\kappa) as the reporter’s expected loss per unit at barrier κ\kappa:
score=f(κ)⋅(L/N)+α⋅∣bias∣\text{score} = f(\kappa) \cdot (L/N) + \alpha \cdot |\text{bias}|
We sweep this model at pcapture=0p_{\text{capture}}=0 across the same L/NL/N and MM grid (round cap nmax⁡=1000n_{\max}=1000). Expected bias in units of σ(T)\sigma(T): 
L/N     M=1.01  M=1.025  M=1.05  M=1.075  M=1.10  M=1.15  M=1.20  M=1.25  M=1.30
0.050   0.181    0.204   0.227    0.245   0.260   0.287   0.310   0.332   0.352
0.075   0.164    0.184   0.206    0.222   0.236   0.261   0.283   0.303   0.323
0.100   0.150    0.169   0.189    0.204   0.218   0.241   0.262   0.281   0.300
0.125   0.139    0.156   0.175    0.190   0.202   0.224   0.244   0.263   0.281
0.150   0.130    0.146   0.164    0.178   0.190   0.211   0.230   0.248   0.266
0.200   0.115    0.130   0.146    0.158   0.169   0.188   0.206   0.223   0.240
0.300   0.093    0.106   0.119    0.129   0.138   0.155   0.171   0.186   0.201
With score =f(κ)⋅(L/N)+∣bias∣= f(\kappa) \cdot (L/N) + |\text{bias}|: 
L/N     M=1.01  M=1.025  M=1.05  M=1.075  M=1.10  M=1.15  M=1.20  M=1.25  M=1.30
0.050   0.207    0.233   0.259    0.278   0.294   0.322   0.347   0.369   0.390
0.075   0.203    0.227   0.253    0.272   0.287   0.314   0.338   0.360   0.380
0.100   0.202    0.227   0.252    0.270   0.286   0.312   0.335   0.356   0.376
0.125   0.204    0.229   0.254    0.272   0.288   0.314   0.336   0.357   0.377
0.150   0.208    0.233   0.258    0.277   0.292   0.318   0.340   0.361   0.380
0.200   0.220    0.245   0.271    0.290   0.306   0.331   0.353   0.373   0.392
0.300   0.251    0.279   0.307    0.327   0.343   0.370   0.391   0.411   0.429
Effective rounds (in units of TT) under the manipulator’s optimal strategy: 
L/N     M=1.01  M=1.025  M=1.05  M=1.075  M=1.10  M=1.15  M=1.20  M=1.25  M=1.30
0.050    36.4     18.3    11.3      8.6     7.2     5.7     4.9     4.4     4.1
0.075    32.9     16.5    10.2      7.8     6.6     5.2     4.5     4.0     3.7
0.100    30.6     15.4     9.5      7.3     6.1     4.9     4.2     3.8     3.5
0.125    28.9     14.5     9.0      6.9     5.8     4.6     4.0     3.6     3.3
0.150    27.7     13.9     8.6      6.6     5.5     4.4     3.8     3.4     3.2
0.200    25.9     13.0     8.0      6.2     5.2     4.1     3.6     3.2     3.0
0.300    23.7     11.9     7.3      5.6     4.7     3.8     3.2     2.9     2.7
Effective rounds account for early termination of disputed rounds (the price hits the barrier before the settlement window ends). The manipulator’s optimal strategy affects round count. Higher L/NL/N gives the manipulator less incentive to delay, reducing rounds. Under self-consistent barriers, bias is monotonically increasing in MM. Wider barriers always give the manipulator more room. Low multipliers like M=1.01M = 1.01 produce dramatically tighter barriers (κ=0.53σ\kappa = 0.53\sigma vs 0.75σ0.75\sigma at M=1.10M = 1.10), which compress the manipulator’s extraction. The tradeoff is fairly simple: you can get lower bias at the cost of waiting nonlinearly longer, as M→1M \to 1. Also, absent censorship and block stuffing, fairly low (but not arbitrarily so) L/NL/N can produce better scores. Overall, the best scores appear around L/N≈10%L/N \approx 10\%, and multiplier selection reduces to how much waiting time you are willing to trade for better execution quality.

​
Binary notional manipulation

​
Delay attacks

In a binary notional application (e.g. a bet that price STS_T is above strike KK at some future time), the attacker’s goal is to delay oracle settlement until the true price drifts into their favor. The decision to delay triggers when:
P(ST>K)⋅payoff>cost to delayP(S_T > K) \cdot \text{payoff} > \text{cost to delay}
Roughly, this compares the payoff given a breach times the chance the price moves across the threshold over the settlement time TT of the oracle game, against the cost to delay that round. This is a one-step heuristic. The forthcoming full control formulation includes continuation value from future delay opportunities, as in the linear notional analysis above. The same backward induction approach applies: the attacker delays when the expected value of continuing (including all future delay options) exceeds the cost of the current delay. The utility from a delay versus settlement can be broken down as follows. Assume zero swap fees and protocol fees. Let xx be the distance from the reported price to the strike, positive meaning favorable for the attacker:
Usettle(x)={payoffif x>00otherwiseU_{\text{settle}}(x) = \begin{cases} \text{payoff} & \text{if } x > 0 \\ 0 & \text{otherwise} \end{cases}
Udelay(z,n,x′)=∣z∣⋅σ(T)⋅Sn−0.65⋅M⋅σ(T)⋅Sn+Vn+1(x′)U_{\text{delay}}(z, n, x') = |z| \cdot \sigma(T) \cdot S_n - 0.65 \cdot M \cdot \sigma(T) \cdot S_n + V_{n+1}(x')
where x′=x+δx' = x + \delta is the distance to strike after the price moves over the settlement time. As in the linear case, the attacker earns ∣z∣⋅σ(T)⋅Sn|z| \cdot \sigma(T) \cdot S_n from correcting a stale price but loses 0.65⋅M⋅σ(T)⋅Sn0.65 \cdot M \cdot \sigma(T) \cdot S_n in expectation as the new reporter. The continuation value Vn+1(x′)V_{n+1}(x') captures all future delay opportunities starting from the updated price. The continuation value is computed via the same hit-versus-survive decomposition as the linear case. During the settlement time, the true price moves by δ\delta, updating x′=x+δx' = x + \delta. However, the oracle settles at the reported price from the start of the round, not the true price at the end. So UsettleU_{\text{settle}} depends on xx (the reported price), while UdelayU_{\text{delay}} depends on x′x' (the true price at time of dispute, which becomes the reported price for the next round):
Vn(x)=phit⋅E[Vn+1(x′)∣hit]⏟honest dispute+psurvive⋅max⁡(Usettle(x), E[Udelay(z,n,x′)∣survive])⏟survives: attacker choosesV_n(x) = \underbrace{p_{\text{hit}} \cdot \mathbb{E}[V_{n+1}(x') \mid \text{hit}]}_{\text{honest dispute}} + \underbrace{p_{\text{survive}} \cdot \max\bigl(U_{\text{settle}}(x),\, \mathbb{E}[U_{\text{delay}}(z, n, x') \mid \text{survive}]\bigr)}_{\text{survives: attacker chooses}}
where phit=1−Qp_{\text{hit}} = 1 - Q is the probability the honest network disputes and psurvive=Qp_{\text{survive}} = Q is the probability the round survives to settlement. Because the continuation value depends on x+δx + \delta (the absolute price level relative to the strike), the distributional robustness that applies to the two-sided barrier game in the linear notional analysis does not carry over here. The binary delay problem is highly distribution-dependent.

​
Reducing the probability of successful delay

The probability term can be reduced by:
  • Strike distance: strike price KK far from current price S0S_0 at time of bet
  • Maturity ratio: time to maturity of bet long relative to the oracle’s settlement time
These reduce the chance the true price ends up close enough to the strike to make delay profitable.

​
Cost to delay

A protocol fee (burn fee) enforces a minimum exponentially increasing cost to delay the oracle. Multiple rounds of frivolous delay become costly with exponential speed (see Economic Bounds). Even with delays, the probability that the price moves enough in the attacker’s favor can be made unlikely under appropriate parameters. The goal is to parameterize such that the loss to successful delay attacks in expectation can be made small as a percentage of notional.