Reading positions

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

// { trader: string; slot: number; seq: bigint }
export function describe(ref: PositionRef): string {
  return `${ref.trader.slice(0, 8)} slot ${ref.slot} seq ${ref.seq}`;
}

import { Connection, PublicKey } from '@solana/web3.js';
import {
  INITIAL_POSITION_SLOTS,
  decodeTraderAccount,
  freeSlots,
  heldPositions,
  slotCapacity,
  traderPda,
  type HeldPosition,
} from '@rekt/1000x';

export interface Book {
  positions: HeldPosition[];
  free: number;
  capacity: number;
  /** A payout already settled but not yet claimed, and when it becomes sweepable. */
  pendingPayout: bigint;
  pendingSince: bigint | null;
}

export async function readBook(connection: Connection, owner: PublicKey): Promise<Book> {
  const info = await connection.getAccountInfo(traderPda(owner).address, 'confirmed');

  // A trader who has never traded has no account. That is a state, not an error.
  if (!info) {
    return {
      positions: [],
      free: INITIAL_POSITION_SLOTS,
      capacity: INITIAL_POSITION_SLOTS,
      pendingPayout: 0n,
      pendingSince: null,
    };
  }

  const account = decodeTraderAccount(new Uint8Array(info.data));
  // Capacity comes from the account's ALLOCATION, not from `slots.length` — the vector holds only
  // as many entries as have ever been used, so a four-slot account reports 1 after its first close.
  const capacity = slotCapacity(info.data.length);

  return {
    positions: heldPositions(owner.toBase58(), account),
    free: freeSlots(account, capacity),
    capacity,
    pendingPayout: account.pendingPayout,
    pendingSince: account.pendingPayout > 0n ? account.pendingSince : null,
  };
}

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

export function lines(position: PositionView): { barrier: bigint; takeProfit: bigint | null } {
  const l = levels(position);
  return {
    barrier: l.barrierPrice,
    // null when the position has no rung set, or the level would be a zero price.
    takeProfit: l.takeProfitPrice,
  };
}

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

export function countdown(position: PositionView, nowUnix: bigint) {
  const d = deadlines(position);
  // A position that froze the indefinite tenor has no protocol clock: show "no limit", never a date.
  const noTenor = isIndefiniteTenor(position.tMaxSeconds);
  return {
    // The protocol's tenor, from the position's own frozen value. null means no limit.
    tenorIn: noTenor ? null : d.tenorExpiresAt - nowUnix,
    // The trader's own timer, if they set one.
    userIn: d.userExpiresAt === null ? null : d.userExpiresAt - nowUnix,
    // The earlier of the two: when a stranger may first close this position. Under the indefinite
    // tenor it is your own timer, or null when you set none.
    closableBy: noTenor ? d.userExpiresAt : d.firstExpiryAt,
  };
}

import {
  settlePreview,
  type CloseReasonName,
  type ConfigView,
  type PositionView,
  type SettlePreview,
} from '@rekt/1000x';

export function preview(
  position: PositionView,
  config: ConfigView,
  exitPrice: bigint,
  nowUnix: bigint,
  signer: string,
  owner: string,
): SettlePreview {
  const out = settlePreview(position, config, exitPrice, nowUnix, signer, owner);

  // How far the move has travelled toward the barrier, 0 to 1. Above 1 means knocked out.
  console.log(`barrier fraction ${out.barrierFraction.toFixed(3)}`);
  console.log(out.knockedOut ? 'knocked out' : out.takeProfitReached ? 'rung reached' : 'live');

  for (const r of out.reasons) {
    const name: CloseReasonName = r.reason;
    console.log(
      r.legal
        // `payouts.liquidator` reads 0n on every settlement: nobody is paid to submit a close.
        ? `${name}: trader ${r.payouts?.trader}, protocol ${r.payouts?.protocol}${r.capped ? ' (CAPPED)' : ''}`
        : `${name}: not legal: ${r.why}`,
    );
  }

  // `out.suggested` is the reason a keeper would submit, or null when none is legal yet.
  return out;
}

import { ix, toHex, traderPda, vaultPda, type BuiltInstruction } from '@rekt/1000x';
import { PublicKey } from '@solana/web3.js';

export function buildSetDestination(args: {
  owner: PublicKey;
  vaultToken: PublicKey;
  newDestination: PublicKey;
}): BuiltInstruction {
  return ix.setPayoutDestination({
    owner: toHex(args.owner),
    positions: toHex(traderPda(args.owner).address),
    vault: toHex(vaultPda().address),
    vault_token: toHex(args.vaultToken),
    payout_destination: toHex(args.newDestination),
  });
}

import { ix, toHex, traderPda, vaultPda, type BuiltInstruction } from '@rekt/1000x';
import { PublicKey } from '@solana/web3.js';

export function buildClaim(args: {
  payer: PublicKey;
  owner: PublicKey;
  ownerToken: PublicKey;
  vaultToken: PublicKey;
}): BuiltInstruction {
  return ix.claimPayout({
    payer: toHex(args.payer),
    owner_token: toHex(args.ownerToken),
    positions: toHex(traderPda(args.owner).address),
    vault: toHex(vaultPda().address),
    vault_token: toHex(args.vaultToken),
  });
}