How the product works

​

An open is an order

• The price on your screen when you tap is not your entry. Your entry is the next price after the delay.
• An order that is not filled in time is returned. If the first price comes too late or does not meet the venue’s quality rule, if the market closes, or if no filler lands inside the fill window, anyone can return the order, and the venue’s keepers do. You get your whole stake back.
• You cannot fill your own order. Only a filler on the venue’s list can write an entry.
• A landed open is not yet a position. Read your entry when the order is filled, never from the screen at the tap.

​

The five choices

​

The barrier

• It is a distance, not a dollar amount. The distance is set by the leverage you chose, which the market’s tier caps. More leverage means a nearer barrier, which is exactly what makes the position resolve fast. Two positions on the same asset can sit at different distances.
• It is direction-relative. For a long it sits below entry; for a short, above.
• It is fixed at your open. Its distance is frozen when your order lands, and its price is set when the order is filled. A governance change later does not move a barrier that already exists.

​

The rung

​

Adding to a position

• It is filled (CollateralAdded): the entry becomes the blend, and both levels move with it.
• It is returned (AddReversed), in full: if no price or no filler comes in time, or if at the add’s price the position is already at its barrier or its target. A returned add keeps the time it added to your timer.

E' = C' × E0 × S / (C0 × S + dC × E0)

• The add is fee-inclusive, exactly as an open is. You hand added_budget — the total to add — the venue takes its entry fee from inside it, and the debit is at most that. min_added_collateral_out is the trader’s mandatory floor on the increment SIZE, the signature over what the add buys.
• The stake bounds bind on two different quantities. The minimum binds on the increment, the maximum on the total. So a position already holding more than maxCollateral − minCollateral has no legal add at all — quote the admissible range and never render a control whose every value is refused.
• The clock may only be lengthened. extend_timer_s is a delta in seconds and it only ever goes forward, and never past the tenor frozen on the position. A double-down is the only way to move a position’s own timer, and it cannot shorten it.
• A position that has touched a level cannot be added to. An add whose price is at or through the barrier, or at or through the take-profit, is returned in full (AddReversed).
• The hold clock restarts. A filled add re-prices the position, so the minimum hold before a close you ask for runs again from the add’s price.

import { addCollateralForMode } from '@rekt/1000x';

// The account list is `open`'s, minus `system_program` — an add grows a slot, it creates none.
// `config` is the decoded config. The add carries no remaining accounts, and while adds are off
// this refuses to build it (`AddsDisabled`).
export const addIx = addCollateralForMode(
  config,
  {
    authority, trader_token: traderToken, config, market, vault,
    vault_token: vaultToken, protocol_token: protocolToken,
    positions, delegate: null,
  },
  {
    seq,                    // the handle, never the slot index
    // Read the live entry fee. At an entry fee of 0 the increment equals the budget.
    added_budget: 250_000n,             // the fee-inclusive TOTAL to add; the debit is AT MOST this
    extend_timer_s: 0,                  // a DELTA, forward only. 0 leaves the clock alone
    min_added_collateral_out: 250_000n, // mandatory floor on the increment SIZE; 0n refused (MinCollateralOutRequired)
  },
  feeds,
);

​

Sizing an add from a total

import { admissibleAdd, sizeAddForTotal, toEnginePosition } from '@rekt/1000x';

// `admissibleAdd` takes the ENGINE position, so a decoded slot goes through `toEnginePosition`.
const room = admissibleAdd(toEnginePosition(position), config.params); // null = the position is full
const size = sizeAddForTotal(500_000n, config.params.entryFeeBps, room!, /* setsTimer */ false);
// size.collateral  500000n   the increment this budget buys — pass as `min_added_collateral_out`
// size.debit       500000n   what actually leaves the wallet (at most the budget you sign)
// size.dust             0n   what could not be spent
// size.summary     "$0.50 adds $0.50 and costs exactly $0.50."
// size.refusal        null   or a Gate-shaped refusal naming the bound that was missed

• setsTimer does not change the debit. Setting a timer is free, on an open or an extension.
• The bounds are admissibleAdd’s interval, not config.params. The ceiling binds on the total, so what a position may still take is the governed ceiling less what it already holds.

​

The tenor

import { deadlines, isIndefiniteTenor, type PositionView } from '@rekt/1000x';

export function clocks(position: PositionView) {
  const d = deadlines(position);
  const noTenor = isIndefiniteTenor(position.tMaxSeconds);
  return {
    openedAt: d.openedAt,
    // The protocol's clock, read from the position's own frozen tenor — never from live config.
    // null means no limit: show "no limit", never a date.
    tenorExpiresAt: noTenor ? null : d.tenorExpiresAt,
    // Your own timer, or null when you set none.
    userExpiresAt: d.userExpiresAt,
    // The earlier of the two: when a stranger may first close this position.
    firstExpiryAt: noTenor ? d.userExpiresAt : d.firstExpiryAt,
  };
}

​

How a position ends

​

The minimum hold

• The hold starts at your entry price, and again at the price of each double-down.
• A close request inside it is refused (MinimumHoldNotMet, MarketHoldNotMet). The position is not affected. Send the request again from the first slot the hold allows: closableFromSlotOf(position, config, market) gives that slot from three public accounts, so an app can show “can close in N seconds” with no guess.
• A take-profit must also clear the hold, measured to the slot of the price that proves it. The venue’s hold also applies to the end of your own timer.
• A knockout is never held back, and a market’s own hold never holds back a timer end.

​

Settlement is permissionless

import { isPermissionless, type CloseReasonName } from '@rekt/1000x';

// Everything except `voluntary` can be submitted by a stranger, and `voluntary` too once the owner
// has requested it: pass the position's phase, `isPermissionless('voluntary', 'ExitRequested')`.
// None of them pays the submitter for it.
export const permissionless: CloseReasonName[] = (
  ['voluntary', 'knockout', 'takeProfit', 'userExpiry', 'tenorExpiry', 'lastResort'] as CloseReasonName[]
).filter((r) => isPermissionless(r));

​

The payout cap

​

The fees

• an entry fee (config.params.entryFeeBps, basis points of the stake), taken from inside your budget when you open, and from the increment when you add. It is 0, so an open costs the stake and nothing more. The venue is fee-inclusive: you hand a total, it takes the fee from within it, and the debit is at most the number you signed;
• an exit fee, charged at every close except a knockout, and waived on a live position closed by lastResort. It is a share of the exit value, the money the position closes with before the fee. The rate depends on the price move at the close: one rate when the close is a gain beyond a small band around the entry price, a higher rate when it is a loss beyond the band, and a rate between the two inside the band. On a gain, the terms also withhold part of the gain: the share you keep is smaller for a small move and rises with the size of the move. Fees and limits has the values, dated, and a worked example. A position freezes its terms when it opens, so a later change to a market’s terms never reaches a position that is already open. The terms of a market are read from its fee-terms account (feeTermsTablePda in the SDK), and the share of each close is on its SettlementFeeTerms event;
• a borrow fee, charged out of the payout for however long the position was held.

import { sizeForTotal, parseUsdc, type ConfigView } from '@rekt/1000x';

// Money is bigint in USDC base units. Parse text exactly; never through a float.
const budget = parseUsdc('1.00');

// The venue is fee-inclusive: it takes its entry fee from INSIDE the budget and opens the largest
// position the remainder buys, so the debit is AT MOST what you hand it. Setting a timer is free,
// so a timed open costs no more.
// Read `config.params` from the config account in production.
export function open(config: ConfigView) {
  const size = sizeForTotal(budget, config.params);
  // size.debit is at most the budget; size.collateral is the position it buys (the smaller number),
  // which you also sign as `min_collateral_out`.
  return { debit: size.debit, collateral: size.collateral };
}

​

The borrow fee

​

The price that decides your outcome

• Your entry is the first price at or after your order’s target slot. An order is filled only by a price that meets the venue’s quality rule for an entry. Otherwise it is returned.
• Your exit is the first price at or after your close’s target slot, by the window rule, or the price that proves a level.
• If no quote can be obtained at all, lastResort is the backstop.

import { type MarketAvailability } from '@rekt/1000x';

export function describe(a: MarketAvailability): string {
  switch (a.state) {
    case 'open':
      return 'open for business';
    case 'closed':
      return `closed (${a.reason}), opens ${a.opensAt.toISOString()}`;
    case 'closing-soon':
      return `opens already refused; forced close at ${a.forceCloseAt.toISOString()}`;
    case 'halted':
      return `halted: ${a.reason}`;
  }
}

​

Your positions live in one account