> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rekt.money/llms.txt
> Use this file to discover all available pages before exploring further.

# Knockout

> A knockout barrier product on Solana. Pick a direction, a stake and a rung. A win is paid in full; part of it may be paid later, in order.

Rekt runs two products on Solana: **Knockout**, described on this page, and
**[Minute](/minute/how-to-think-about-it)**, a timed round built on Knockout that you cannot close
early.

**Knockout is a leveraged product on Solana with two hard limits.** A **barrier** that ends your
position if the price reaches it, and a **cap** on the most it can pay. You stake a small, fixed
amount, choose a direction and a target, and the position resolves — quickly, and by rules that
were fixed the moment you opened it.

It is not a perpetual. There is no funding, no margin call and no partial liquidation. There is a
barrier below you and a target above you. A win that the pool cannot pay in full at once is paid in
order, from a queue: see [how a win is paid](/liquidity#how-a-win-is-paid).

A governed **borrow fee** on the time you hold is taken out of the payout, never out of your equity, so
it never moves the price that ends your position. [Fees and limits](/limits) has the rate in force.

<CardGroup cols={2}>
  <Card title="How the product works" icon="gears" href="/how-it-works">
    Direction, stake, rung, barrier, tenor — and the four ways a position ends.
  </Card>

  <Card title="The venue" icon="shield-check" href="/venue">
    What the program does: admission and the queue, the pricing path, the bounds on loss and payout.
  </Card>

  <Card title="Fees and limits" icon="scale-balanced" href="/limits">
    What a trade costs, the stake and leverage limits, the hours, the minimum hold and how a win is
    paid. Dated, and they can change.
  </Card>

  <Card title="Build on it" icon="code" href="/sdk/quickstart">
    A bot that quotes, opens and closes in one file. The SDK reads state, predicts every refusal
    before you send, and prices every close. It is not public yet.
  </Card>

  <Card title="Orders and closes" icon="list-check" href="/sdk/orders">
    An open is an order that the venue's next price fills, and a close is a request anyone
    completes. The rules a client or a bot builds against.
  </Card>

  <Card title="The liquidity pool" icon="layer-group" href="/liquidity">
    One shared pool takes the other side of every position and funds every win. How a win is paid, how
    the pool is read, and how it loses money. Deposits are closed.
  </Card>

  <Card title="Markets" icon="chart-line" href="/markets">
    BTC, ETH, SOL and XRP around the clock, and gold in its own sessions.
  </Card>
</CardGroup>

## Where it is running

| | |
| - | - |
| **The program** | `1oooxLtzLiYV6LcDybrEPcyXVLPWGnAmeif9s5oNrp6` on Solana mainnet. **This is the ground of truth.** Derive every account address from it rather than copying one |
| **The facts API** | `https://data.rekt.trading` — settled trades, rebuilt by replaying each settlement through the same engine the program runs. No account; CORS is open, so a browser can call it directly. Per-transaction routes answer the last 48 hours and all-time totals stay on `/v0/stats` and `/v0/markets`; see [Data API](/data-api). Start at `/v0/health` |

<Warning>
  **The facts API is a lagging mirror and answers no live question.** There is no RPC endpoint in
  that process. Pool size, open positions, the current price, whether a trade would be admitted —
  none of those routes exist. Read live state from the chain through the SDK; read history from the
  API. Every response carries `asOf` and says `stale: true` when the archive has stopped advancing,
  because **a dead indexer must never read as a quiet venue.**
</Warning>

## A trade, in one paragraph

You pick an asset — **BTC, ETH, SOL, XRP or gold (XAU/USD)** — and a direction. You stake between
**$0.20 and $1,000**. You pick a **rung** — a take-profit target of at least **2.00x** your stake.
**Leverage is 1000x** on every market. Your open is an order: the stake is taken when it lands, and
the venue's next price after a short delay sets your entry. If no price comes in time, the order is
returned and the whole stake comes back. From there the position ends at its barrier, at its target
or when you close it. It has no protocol clock: it stays open until one of those happens, or until
the timer you chose runs out. Opening is free, and a close pays an exit fee, higher on a loss than on
a win. On a gain the terms also withhold part of the gain, a smaller share for a smaller win. The
numbers, with the date they were read, are on [Fees and limits](/limits).

**BTC, ETH, SOL and XRP trade around the clock. Gold trades in sessions, and a gold position's tenor ends before its session closes.** See [markets](/markets).

| The choice | What it does |
| - | - |
| **Asset** | Which price feed decides your outcome: BTC, ETH, SOL, XRP or gold; see [markets](/markets). |
| **Direction** | Long or short. |
| **Stake** | What you put at risk, between `minCollateral` and `maxCollateral`, both governed and read from the chain. It, and any entry fee paid on it, is the whole of what you can lose. |
| **Rung** | Your take-profit target: any multiple of the stake at or above 2.00x, up to the payout cap. Reaching it is a gross gain of the multiple less one, times the stake, before the exit fee and the share of the gain the terms withhold ([how a win is calculated](/limits#how-a-win-is-calculated)). The presets are `presetRungsBps` at the live payout cap, not the choices. |
| **Leverage** | How far the price has to move to get there — so, how *fast* the position resolves. **1000x on every market.** The market's tier (`market.tier`) is a ceiling and the venue's `config.minTier` is a floor; both are governed, so read them from the chain. Leverage changes nothing about what you can win or lose, and everything about how long the position takes to end. |

## How a win is paid

Opening a position takes your stake and nothing else. The venue decides at the fill whether the
position fits, against a rule the program applies per market and in total; an order that does not fit
is returned with your whole stake and no fee.

**A win is paid in full. Part of it may be paid later, in order. There is no guaranteed time. The
amount queued ahead of you is shown.** At a close your stake comes back at once, and the profit is
paid from the pool's free cash; whatever the pool cannot pay yet joins a queue and is paid first in,
first out. When the line is nearly full, a second unpaid win of the same account waits behind its
first. The payout cap, `config.params.payoutCapMultiple`, is the largest multiple the program lets a
target take. [How a win is paid](/liquidity#how-a-win-is-paid) has the rule in full.

<Note>
  The program never writes down an amount it owes: it is paid in full or stays owed.
</Note>

## What you are actually buying

Honest framing first, because it is the part that decides whether this product is for you:

* **The barrier is close, and it is meant to be.** High leverage means a small, ordinary move ends
  the position — that is the mechanism working, not a malfunction. Price and size every trade as
  though reaching it is normal, not a surprise.
* **At the barrier you receive nothing.** Not a residue you can watch drain — the position is over
  and the stake is gone. Literally nothing: even the rounding crumb the arithmetic leaves behind
  goes to the pool.
* **You may double down, and it is not a defence.** The owner may add collateral to a live
  position. It averages the entry, so adding while you are **ahead** moves the barrier toward the
  live price. [Read the table](/how-it-works#adding-to-a-position) before you offer the control.
* **Your maximum loss is your stake.** There is nothing to top up and no way to owe more.

Read [the venue](/venue) before you trade. The [risk disclosure](/risk) follows it.

## Who takes the other side

One shared pool is the counterparty to every position, and it earns the fees. It also funds every
win — so the pool's returns are real, and so are its losses. Deposits to the pool are closed. See
[providing liquidity](/liquidity).

## Everything is on chain, and readable

Every fee, bound and delay that governs your money lives in accounts you can read yourself, and
they are governed — they can be changed by the protocol's authority, on chain, in public.

That is why this documentation prefers to tell you **where a number lives** rather than to print
it. The SDK reads the live values; a page of typed constants goes stale the first time governance
moves one.

```ts theme={"dark"}
import { Connection } from '@solana/web3.js';
import { configPda, decodeConfig } from '@rekt/1000x';

// SOLANA_RPC_URL is read from the environment. Never hardcode an endpoint that carries a token.
const connection = new Connection(process.env['SOLANA_RPC_URL'] ?? '', 'confirmed');
const info = await connection.getAccountInfo(configPda().address, 'confirmed');
const config = decodeConfig(new Uint8Array(info!.data));

// The live bounds, the live fees, the live cap — read, not typed.
console.log(config.params.minCollateral, config.params.maxCollateral);
console.log(config.params.entryFeeBps, config.params.exitFeeBps);
console.log(config.params.payoutCapMultiple, config.params.tMaxSeconds);
```

<Warning>
  Knockout is early software. It has not been audited by a third party. Trade only with money you
  can afford to lose entirely. [Read the risk disclosure](/risk).
</Warning>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.