Providing liquidity

​

How shares work

import { vaultGauges, type VaultView } from '@rekt/1000x';

export function sharePrice(vault: VaultView, tokenBalance: bigint) {
  const gauges = vaultGauges(vault, tokenBalance);
  // LP assets per share, scaled so it is exact in integers.
  return gauges.sharePriceMicro;
}

​

The four numbers that describe the pool

import { vaultPda, decodeVault, vaultGauges } from '@rekt/1000x';
import { Connection, PublicKey } from '@solana/web3.js';

export async function poolGauges(connection: Connection, vaultTokenBalance: bigint) {
  const info = await connection.getAccountInfo(vaultPda().address, 'confirmed');
  if (!info) throw new Error('the vault account does not exist');
  const vault = decodeVault(new Uint8Array(info.data));
  const gauges = vaultGauges(vault, vaultTokenBalance);
  // `vault.tokenAccount` is the SPL account whose balance you passed in — read it, do not guess.
  void new PublicKey(Buffer.from(vault.tokenAccount, 'hex'));
  return gauges;
}

​

How a win is paid

• Opening takes the stake and nothing else. The venue decides at the fill whether a position fits, against a rule the program applies per market and in total. An order that does not fit is returned with the whole stake and no fee. A hedge, a smaller target and a close are never refused by it.
• At a close the stake comes back at once. The profit is paid from the pool’s free cash when no earlier claim is unfunded; whatever is left joins the queue. The settlement events say how much was paid now and how much was queued.
• The queue is first in, first out, and cash that other positions leave in the pool funds it. The protocol’s own share of a close is paid last, and not at all while any claim is unfunded.
• Anyone can deliver funded money with pay_queue, in line order, to the wallet recorded on the account. Money for an account that cannot receive it is held for that account under the unclaimed rule below.
• When the line is nearly full, a second unpaid win of the same account waits behind its first.
• A book with an unpaid entry cannot close its account until it is paid.

​

The guarantee: you can only withdraw capital that is not backing a position

withdrawable = lpAssets − stakes − funded queue money − cover the venue needs
execute_redeem:  payout must be ≤ withdrawable, or the program refuses  →  WouldStrandReserve

• The cover rule and your redemption draw on one pool of free cash. A fill is admitted only inside the free cash and the floors, and a redemption is paid only out of the free cash. Cash the venue needs as cover is not free, for either, so neither can take what the other is not allowed to keep.
• A refused execution does not consume your ticket. If positions opened during your wait raised the cover the venue needs, the payout is refused and the ticket survives. Retry after positions settle. The cover is never the thing that yields.
• It is not a promise the pool has money. The guarantee bounds what you may take out of a pool of a given size. If traders have won and the pool is smaller, your shares are worth less, and nothing here recreates money the pool has paid out.

​

Wind-down

​

Getting your money out

​

What you are actually paid

• Arm. If your matured ticket is worth more than the pool can currently pay, you may arm it, which gives it priority over every new open until it is paid. The price of arming is disclosed up front: an armed ticket can be executed by anybody, and cannot be cancelled until it is paid or expires. You cannot arm a ticket the pool can already pay — at that moment the honest instruction is simply to execute.
• Cancel. The owner may cancel an unarmed ticket at any time. Every share returns; the ticket’s recorded ceiling then caps your next request until that ticket’s window would have closed. After the window closes, anyone may reap it.

import {
  armGates,
  cancelGates,
  redeemGates,
  type ConfigView,
  type GateReport,
  type VaultGauges,
  type VaultView,
} from '@rekt/1000x';

// All seven are REQUIRED. `unbondingValue`, `delayS` and `validityS` are frozen onto the ticket at
// request, and `frozenFloorS` when it is armed (0 until then). None has a fallback to the vault's
// live figures: a default would be wrong for a ticket that outlived a governance change.
interface Ticket {
  shares: bigint;
  requestedAt: bigint;
  armed: boolean;
  unbondingValue: bigint;
  delayS: number;
  validityS: number;
  frozenFloorS: number;
}

export function redemptionReports(
  config: ConfigView,
  vault: VaultView,
  gauges: VaultGauges,
  ticket: Ticket,
  nowUnix: bigint,
  signer: string,
  ticketOwner: string,
): Record<string, GateReport> {
  const ctx = { config, vault, gauges, ticket, nowUnix };
  return {
    execute: redeemGates(ctx),
    arm: armGates(ctx),
    cancel: cancelGates({ ...ctx, signer, ticketOwner }),
  };
}

​

How you actually lose money

• Traders win. The pool pays. Over a run of favourable outcomes for traders, the share price falls, and it may not come back.
• The pool is small. A small pool is a concentrated one: a handful of maximum-size wins is a large fraction of it.
• Nothing will catch you. There is no insurance fund, no backstop, no protocol treasury commitment and no third party standing behind a balance. See the insurance fund.
• Parameters are governed. Fees, bounds, caps and the withdrawal delay can be changed on chain by the protocol’s authority. Every change is public and readable; none of them requires your consent.
• This is unaudited software.

​

What you earn

• A share of the entry fee and of the exit fee. Traders pay an entry fee on every open and on every increment they add later (read config.params.entryFeeBps; it is 0, so opens are free), and an exit fee on most closes (not on one paid at the barrier). The exit fee is a share of the exit value, higher on a loss than on a win; the rates are on Fees and limits.
• A share of what losing positions forfeit. The loss tax is divided between the pool and the protocol. The pool is the residual claimant on the loss tax and on both fee splits, so it takes whatever the named shares do not, and the rounding dust lands here.
• The borrow fee, in full. It is rent on the pool capital a position freezes, so all of it goes to the pool. While its rate is zero it collects nothing: Fees and limits has the rate.
• An unclaimed payout that expires. See below.

​

An expired unclaimed payout is released to the pool

​

The insurance fund

​

Before you rely on the pool