The house has a liquidation price.

ruin matches each 500–1000× bet on SOL, BTC and ETH with one house and puts both stakes in the same Solana contract. Two lines are fixed at the fill: yours one division away, the house's k divisions away. The first line the DOVES price reaches ends the bet, whichever side it is on. Stop before that and the table is split where the price stands, along a straight line you can read before you open.

On YOLO, the house is one pool for every market, filled only by traders' losses, and nobody can deposit into it [4]. A move of 0.002% or less in your favour pays nothing, and a bigger one is cut, most when it is small [5]. A win the pool cannot cover waits in a queue [4]. Here anyone can post a house, nothing is zeroed near the fill, the house's cut is one number printed on it, and everything a bet can win is in the house's vault before it fills.

This page is the manual and the record: how to bet and how to run a house, the formula and the code that settle a table, the values the program holds and every call it takes, what it was measured against, and what you are trusting.

1The window

A bet on ruin is a contract between two wallets. A, the trader, puts up margin m. B, the house, puts up k·m. Both amounts sit in the contract from the moment it fills. Their sum, (1+k)·m, is the table.

Two lines are fixed at the fill. A's line is 1/L from the fill price, against A. B's line is k/L from it, in A's favour. Measured in divisions of 1/L, A's line is one division away and B's line is k. At 1000× and k = 10, a long has its lines at −0.1% and +1%. Whoever's line the price reaches first gives up the table.

The fill is YOLO's own (4TB9…U7bk, slot 457,263,940). The moves after it are Binance 1 s closes, because the bet comes from the YOLO sample of 15 Oct. ruin itself settles only on DOVES (section 6).

2Using it

You need a Solana wallet in this browser, USDC for the margin or the stake, and a little SOL for network fees and account rent. The page builds each transaction; your wallet signs it and sends it.

Bet. On bet, pick a market, a side, a margin from $1.00 and a leverage of 500–1000×, then the house you bet against. Its window is drawn before you ask. Request bet moves the margin into that house's vault and asks for a fill, which comes 2–5 s later (section 5). From the fill the two lines stay where they are. Stop asks for the split at the price 2–5 s later (section 3). A line, a stop or 72 hours ends the table, and the transaction that ends it pays you. Your bets and their receipts are on you, and every ended table is on tape.

House. On house, pick a market, a stake, k, e and the sides you take, then Post house. The stake, and any $RUIN the house locks (section 8), moves into the house's vault. A house takes one bet at a time, up to its stake divided by k. Between bets you can top up, withdraw or close it on you, and pause stops new bets at any time.

Rent. A request pays the rent of its table account, and the trader gets it back when the table ends or is refunded. Posting a house pays the rent of the house and its vaults, and closing the house returns it.

3Stopping early

A can stop at any time. The table is split where the price stands between the two lines.

f is the price's place in the window: 0 on A's line, 1 on B's. At the fill f = 1/(1+k), so a $10 long against a $100 house that stops with nothing moved gets $103 / 11 = $9.36.

ruin · mainnet · receipt H0·0000 · 2026-10-26 20:55:44 UTC · SOL long · $5.00 · 1000× · k 10 · e 7% · filled 100.2396 · stopped at 100.2537, f 0.1037 · A $5.34 · B $49.66 · tx 53iy…Tc6p

// programs/ruin/src/math.rs
pub fn split(side: Side, lev: u16, m: u64, k: u8, e: u16, p0: u64, p: u64) -> Result<Split> {
    require!(p0 > 0, RuinError::InvalidValue);
    let movement = i128::from(p)
        .checked_sub(i128::from(p0))
        .and_then(|v| v.checked_mul(i128::from(lev)))
        .ok_or(RuinError::Overflow)?;
    let num = match side {
        Side::Long => i128::from(p0).checked_add(movement),
        Side::Short => i128::from(p0).checked_sub(movement),
    }
    .ok_or(RuinError::Overflow)?;
    let den = i128::from(p0)
        .checked_mul(i128::from(k).checked_add(1).ok_or(RuinError::Overflow)?)
        .ok_or(RuinError::Overflow)?;
    let c = claim(m, k, e)?;
    let clamped = num.clamp(0, den) as u128;
    let a = if num >= den {
        narrow(c / 10_000)?
    } else {
        narrow(
            c.checked_mul(clamped).ok_or(RuinError::Overflow)?
                / (den as u128)
                    .checked_mul(10_000)
                    .ok_or(RuinError::Overflow)?,
        )?
    };
    Ok(Split {
        a,
        b: sub(mul(add(1, k.into())?, m)?, a)?,
        f_e9: narrow(
            clamped
                .checked_mul(1_000_000_000)
                .ok_or(RuinError::Overflow)?
                / den as u128,
        )?,
        line: if num <= 0 {
            Some(End::TraderLine)
        } else if num >= den {
            Some(End::HouseLine)
        } else {
            None
        },
    })
}

4The edge

B's price is one number, e, printed on the house. Whatever happens, B keeps k·m·e of its stake: at its own line B loses k·m·(1 − e) and keeps the rest. Without e, A's split would be f·(1+k)·m, its place times the table. With e, A gets that less k·e/(1+k) of it, the same share at every price: 6.4% at k = 10 and e = 7%.

The split is one straight line from A's line to B's, set before you open. Nothing is zeroed near the fill, and the share taken does not change with the move. Every price in the window pays an amount you can read before you open.

5Fills

You ask, and the fill comes later. A bet and a stop both fill at the DOVES value read in a window that opens at a random slot, 2.2 to 5.0 seconds after the request lands, and stays open 1.1 seconds. That value must be newer than the one on chain when you asked.

The delay is read from the hash of the slot your request lands in, so nobody, you included, knows it before the request lands. A fill at a price nobody can pick in advance means nobody opens or stops on a DOVES update they have already seen.

6The lines and the oracle

A line is crossed only by a DOVES value written on chain. The keeper reads the DOVES account of each market and calls settle for any table past a line. settle is permissionless: anyone can call it with the same account.

// keeper/src/keeper/engine.ts
  if (
    price &&
    price.publishTs >= t.fillPublishTs &&
    r.split({
      side: t.side,
      lev: t.lev,
      m: t.m,
      k: t.k,
      eBps: t.eBps,
      p0: t.p0,
      p: price.price,
    }).line
  )
    return { kind: "settle-line" };

ruin · mainnet · receipt H1·0000 · 2026-10-26 21:01:01 UTC · SOL short · $5.00 · 1000× · k 10 · e 7% · filled 100.1797 · the trader's line at 100.2877, slot 461,808,758 · A $0.00 · B $55.00 · tx 54jM…e6Hs

7When money waits

No fill. A request fills only inside its window, at a DOVES value newer than the one on chain when it landed. If none comes, the request can be refunded once the window has passed: the margin and the table's rent go back to the trader. The keeper does it, so can anyone, and your bets on you show a Refund key.

A missed stop. A stop fills only inside its own window, at a value newer than the one when it was asked. If it misses, the table stays open and you can ask again. A line reached meanwhile still ends it.

72 hours. A table still open 72 hours after its fill is split at the DOVES price then, by the same formula. When more than one applies, a line comes before a stop, and a stop before this.

No keeper. fill, refund and settle need no key of ours. If the operator's keeper stops, any wallet can send them with the same accounts, using the client in the source (section 12).

An old price. A DOVES value older than 30 s is refused. A request, a fill, a stop or a settle waits for a newer one.

8Houses and $RUIN

A house is a stake waiting for a bet: a market, the stake, k, e and the sides it takes. It takes one table at a time, and a bet of at most its stake divided by k. While a bet is asked for or open against it, a house cannot close, add stake or withdraw. It can stop taking new bets at any time.

A house with a stake up to $100 needs no token. $RUIN is not set yet; until it is, no house holds more than $100.

So the size of the bets a house can take is counted in $RUIN. At k = 10, a bet above $10 needs a house above $100, and until $RUIN is set no house is that big.

In the YOLO sample of 14–19 Oct (49,571 opens), the bets above $10, which a $100 house at k = 10 cannot take, were 52.0% of the count and 97.6% of the margin. Without the ten largest wallets they were 48.2% and 93.0%, and 1,236 of the 2,042 wallets placed at least one.

9The ruin problem

ruin is named after it. Two players stake what they have on one walk, and whoever runs out first is ruined. On ruin, A stakes one division, B stakes k, and the walk is the DOVES price. The problem is older than the market. Huygens printed it in 1657 as the fifth problem of De Ratiociniis in Ludo Aleae [1]: two players with twelve pieces each play until one holds all twenty-four. Neither is the house. Pascal and Fermat had settled in 1654 how to split a game stopped early [2].

"A and B taking 12 Pieces of Money each, play with 3 Dice on this Condition, That if the Number 11 is thrown, A shall give B one Piece, but if 14 shall be thrown, then B shall give one to A; and he shall win the Game that first gets all the Pieces of Money."

Huygens, problem V, in the English of 1714 [1]

If the price is a martingale and touches lines exactly, the chance that B's line comes first is f [3]. At the fill that is 1/(1+k). A's share f·claim is then what A's position is worth at that moment, and by optional stopping its expected value is the same whenever A stops.

The contract leaves the model in three places: DOVES is read at discrete moments, the fill uses a later price, and the stop uses a later price.

10Measurements

Held to a line. 25,724 real 1000× bets (YOLO, 14–19 Oct) held from their real open until a line at k = 10, on Binance 1 s highs and lows, ended within 24 h: 2,401 reached B's line first, 9.33%. The model says 1/11 = 9.09%. With the direction flipped, 10.47%.

Against the current formula. 48,496 real 500–1000× bets on the same paths and hold times, long and short averaged, beside YOLO's published fee formula as read on 25 Oct [5]. Wallets outside the top ten got back 94.04% of their margin under ruin's split and 88.89% under that formula. The top ten closed 61% of their margin inside a 10% move, after a median 28 s: 93.6% here, 95.5% there.

Where each pays more. A $10 long at 1000× against a house at k = 10 and e = 7%, beside the same formula on the same move: from +0.0049% up to B's line at +1%, ruin pays more ($14.05 against $12.50 at +0.05%, $103 against $95.48 at +1%). From −0.069% to +0.0049% it pays less ($9.36 against $9.80 with nothing moved). The table ends at B's line, so the house's k sets how far a bet can run: at k = 10 that is +1% and $103, and held on YOLO the same entry pays more from about +1.085%. Against a $1,000 house at k = 100 the line is at +10%. YOLO's payout stops at $499.80 from about +5.58%, at its cap of 50 times the collateral; this bet goes on to $940 at that line.

Conditions: Binance 1 s paths, original hold times, and YOLO's published values as read on 25 Oct 2026: nothing for a move of 0.002% or less, 0.9·P·d²/(d + c) above it, profit capped at 50 times the collateral, a 2% win fee and a 0.002% close fee [5]. The payout comparison leaves out fill prices and network fees. None of this is an expected return.

11Values and calls

These values are read from the program on Solana mainnet. A house keeps the $RUIN terms it was posted with and a table keeps the timing it was asked with, so a change applies only to new houses and new tables.

The program counts slots, not seconds: a delay of 10–23 slots, a fill window of 5 and a stop window of 5. Seconds on this page are at the recent slot length, 218 ms.

12Trust assumptions

• ruin is one program on Solana.
• The admin key can change, for new houses and new tables only, the minimum margin, the stake a house may hold without $RUIN, the $RUIN per dollar, the fill delay and windows, and how old a DOVES value may be. It cannot move any vault or lock. The admin is set when the program is initialized, and no call changes it.
• DOVES is a price account. Its terms are not published.
• The keeper is run by the operator. Anyone can run another, because fill, settle and refund are permissionless.
• This build links no source. The program's source is published with its mainnet deployment.

13Problems

References

1. [1] C. Huygens, De Ratiociniis in Ludo Aleae, 1657, problem V. In English as The Value of All Chances in Games of Fortune, 1714.
2. [2] B. Pascal and P. de Fermat, correspondence of 1654.
3. [3] W. Feller, An Introduction to Probability Theory and Its Applications, vol. 1, 3rd ed., Wiley, 1968, ch. XIV, "Random Walk and Ruin Problems".
4. [4] Jupiter, YOLO payouts and the House, read 25 Oct 2026.
5. [5] Jupiter, YOLO profit adjustment and fees, read 25 Oct 2026.
6. [6] DOVES price program, DoVEsk76QybCEHQGzkvYPWLQu9gzNoZZZt3TPiL597e. Its terms are not published.