Profit, hourly references and payment claims
> Local V11 math and House checks have passed; this version is not deployed. Release validation is separate. These Docs do not change the terms of existing positions.
The V11 model removes the four-times-margin profit ceiling and the shared closing-profit budget. Pressure changes the profit retention locked at opening, rather than deleting a confirmed gain at settlement. A factor's deduction limit is not a guaranteed minimum share of raw profit.
Profit, fees and losses
M is margin, L leverage, N notional, r the favorable price-move fraction, and t seconds from actual opening fill to closing fill. R=L×r; R=1 means a raw margin return of 100%. D is the positive hourly reference locked at open; q is the integrated pressure retention. The first 0.002% of price movement earns no profit. d is the market's configured curve parameter; the reference values are 814598000 for BTC and 483979000 for ETH. The real-valued formulas explain the model; the exact integer operation and rounding sequence is given below.
N = M * L; R = L * r; m = max(r - 0.00002, 0)
k0 = 1/15000 + 100000/d
P0 = 0.9 * N * m*m/(m+k0)
hL = 0.03*(L/1000)^2
hR = 0.30*R/(R+30)
hT = 0.98/(1+(t/10)^2)
x = min(r/D, 1)
hD = 0.70*(1-x)^2*(1+2*x)*(0.2+0.8/(1+t/60))
P = P0*0.99*q*(1-hL)*(1-hR)*(1-max(hT,hD))
F = ceil(N_atomic/25000)
profit_fee = floor(P_atomic/50)
profit_claim_atomic = P_atomic - profit_fee
net_result_atomic = profit_claim_atomic - F - principal_loss_atomic
principal_return_atomic = M_atomic - F - principal_loss_atomic
paid_profit_atomic + queued_profit_atomic = profit_claim_atomic
The nominal fee is 0.004% of notional, rounded up once and deducted from margin at close. Loss is capped at M−F; the 2% loss fee is carved from that loss, not added again. Only eligible USDC principal loss mints OH: nominal fees and OH-collateral losses do not. The profit fee is 2% of adjusted gross profit, charged once. A tiny or very short favorable move can still leave a negative net result after the nominal fee.
Opening pressure
E = max(lp_cash - execution_due, 0)
Q = total_queued
S = [Q + sum_j rho_j*(Nlong_j+Nshort_j+0.5*abs(Nlong_j-Nshort_j))]/E
rho_j = 0.01
g(S) = 0.65 + 0.35*(1+2*S)/(1+S+S*S)^2
avg(S0,S1) = 0.65 + 0.35*(1+S0+S1)/[(1+S0+S0*S0)*(1+S1+S1*S1)]
The implementation uses E = max(lp_cash − execution_due, 0) and Q = total_queued. Q excludes separately funded pending_queue_credits. User collateral and protected balances are not free LP capital. Do not subtract the same queued debt from E again when it is already included in Q. In the current code, every market uses rho_j = 0.01. This is a dimensionless shock scale, not a dollar position limit or the hourly volatility table. Both sides add pressure; a fake opposite position cannot create capital. Include this order by integrating its pressure, splitting at the directional balance point if necessary. Lock q at opening. The pressure factor approaches 0.65 as pressure grows; E=0 uses that limit rather than an economic-pressure rejection. Valid signatures, collateral, rent and accepted prices remain required.
Holding time
The time axis is doubled: the short-hold constant changes from 5 to 10 seconds and the small-move time scale from 30 to 60 seconds. The larger of the short-hold and small-move deductions applies, not their product. This changes earnings, not execution waiting time or quote freshness. Queued-order waiting does not count as position holding time.
Hourly historical reference
r_i = ln(close_i/close_previous)
weight_i = base_quantity_i
sigma(asset,hour) = sqrt(sum(weight_i*r_i^2)/sum(weight_i))
sigma_BTC = sqrt(sum_all_BTC(weight_i*r_i^2)/sum_all_BTC(weight_i))
D(asset,hour,standard) = 600 ppm * sigma(asset,hour)/sigma_BTC
D(asset,hour,other) = 1000 ppm * sigma(asset,hour)/sigma_BTC
600 ppm = 0.06%; 1000 ppm = 0.1%
Use only consecutive completed 1-minute bars, with opening timestamps exactly 60000 ms apart. Assign each return to the UTC hour of the current bar's opening timestamp. Weight it by that bar's base-asset quantity; convert contract counts first and give zero-volume bars no weight. Pool eligible observations across approved perpetual venues within the actual trailing-year coverage. BTC's overall weighted RMS anchors 600 ppm in the standard mode and 1000 ppm in the other mode; each asset/hour scales by its RMS divided by that BTC RMS. This is a small-move deduction scale, not a zero-profit boundary. Income-time ownership of staking rewards does not change.
At opening, every market uses the standard 600 ppm BTC anchor during the valid, on-chain published US regular equity session: normally 09:30–16:00 New York time, with holidays and early closes following the calendar. Other valid times use the 1000 ppm anchor. The UTC hour selects only the hourly bucket. An expired calendar cannot be treated as permission to bypass validation by choosing the other mode. This does not change each market's trading hours.
The table has 24 UTC buckets and combines daylight-saving and standard-time seasons. It is a historical baseline, not an immediate risk signal or an automatic response to current volatility. Only the selected positive D is locked in ppb at opening; zero or missing calibration is rejected.
Historical calibration weights each return by that minute's base quantity. The live price feed instead uses rolling 24-hour quantity shares and its randomized weights; these are different calculations.
The current production allowlist has 9 venues and 92 theoretical product candidates. MEXC downloads are research-only and excluded from the production calibration set. A candidate is usable only after confirming the actual perpetual product, underlying and units; the list does not prove that every API or full year of history is available.
The calibration uses verified product identities, quantities and observed historical windows from eligible perpetual sources. The values, coverage and provenance hashes are in the price appendix. This does not mean all candidate venues supplied a full year. Gaps, recent listings and unit-change exclusions are disclosed without inventing records. Native-quote returns without full historical FX conversion are not an exact reconstruction of the live composite feed. Missing or zero calibration is rejected.
Claims and cash
Return surviving user margin separately from profit. Confirm the full formula-derived net profit, pay available cash and record the unpaid remainder in FIFO order. Unpaid claims are not withdrawable cash and must not be reused as funded margin. They cannot generate cash dividends or referral balances. Eligible unassigned reserves and unvested rewards may support repayment; founder allocations, protected 2% chain-network and 1% server-network balances, vested user rights and credited referrals remain protected. Preserve reward ownership from the time income was generated.
Limits
The 35% maximum pressure deduction and 30% maximum ROI deduction are separate factors, not a cap on total deductions. Payment may be delayed or incomplete. Historical RMS does not identify bots or validate execution prices; positions still require valid quotes to use ordinary closes. Local mathematical and House checks cover the tested implementation, not every future market condition or indefinite operation.
This V11 build supports fresh deployments only. Its changed account discriminators and layouts must be decoded with the matching release's sdk/idl/perp.json and SDK; legacy accounts cannot be reinterpreted or upgraded in place by this build. The intent wire version is separate from the account ABI.
Local V11 implementation
The following order describes the current integer implementation for a profitable, non-liquidated close. WAD ratios use W = 10^18; C is first rounded down from segment-weighted pressure retention in ppm. Every displayed floor or ceiling is applied at that step, not once at the end. The hourly generator rounds the standard D upward to ppb; the other mode rounds 5D/3 upward from that stored standard value. If the ROI denominator exceeds its integer representation, its additional term is exactly zero at WAD precision.
W = 10^18; K = 10000
t = floor((settlement_time_ms-opened_unix_ms)/1000); t >= 0
if E == 0: q_ppm = 650000
else:
s0 = ceil(K*S0); s1 = ceil(K*S1)
if max(s0,s1) >= 3500010000: q_ppm = 650000
else: q_ppm = 650000 + floor(350000*K^3*(K+s0+s1) /
((K*K+K*s0+s0*s0)*(K*K+K*s1+s1*s1)))
C = floor(sum(segment_notional*q_ppm_segment)/1000000)
rW = floor(abs(exit-entry)*W/entry)
mW = max(rW-W/50000, 0)
kW = ceil(W/15000) + ceil(100000*W/d)
p1 = floor(C*mW/W)
p2 = floor(p1*mW/(mW+kW))
p3 = floor(p2*891/1000)
keepL = W-ceil((3*W/100)*L^2/1000000)
keepR = 7*W/10 + floor(9*W^2/(L*rW+30*W))
hT_W = ceil(98*W/(t*t+100))
D_W = D_ppb*1000000000
if rW >= D_W: hD_W = 0
else:
xW = floor(rW*W/D_W)
aW = W-xW
shapeW = ceil(ceil(aW*aW/W)*(W+2*xW)/W)
decayW = W/5 + ceil((4*W/5)*60/(60+t))
hD_W = ceil(ceil((7*W/10)*shapeW/W)*decayW/W)
keepB = W-max(hT_W,hD_W)
P_atomic = floor(floor(floor(p3*keepL/W)*keepR/W)*keepB/W)
D_standard_ppb = ceil(600000*sigma(asset,hour)/sigma_BTC)
D_other_ppb = ceil(5*D_standard_ppb/3)