Reading gates

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

export function render(gate: Gate): string {
  return [
    gate.ok ? 'PASS' : 'FAIL',
    gate.label,             // a short name for the rule
    gate.value,             // what was measured, already formatted for a human
    gate.threshold,         // what it had to clear
    gate.error ?? '',       // the ErrorCode name the program raises when this gate fails
    gate.detail,            // one sentence on what this gate is protecting
  ].join('  ');
}

import { APPROACHING, approaching, headroom, type Gate } from '@rekt/1000x';

export function bar(gate: Gate): { fill: number | null; warn: boolean } {
  return {
    // null on a categorical gate: draw a tick or a cross, not a bar.
    fill: headroom(gate),
    // Still passing, but inside the last APPROACHING of its room. Paint it.
    warn: approaching(gate),
  };
}

export const warnBand = APPROACHING;

import { Connection, PublicKey } from '@solana/web3.js';
import {
  INITIAL_POSITION_SLOTS,
  decodeTraderAccount,
  openGates,
  slotCapacity,
  traderPda,
  type ConfigView,
  type GateReport,
  type MarketView,
  type OpenRequest,
  type PriceReport,
  type TraderAccountView,
  type VaultGauges,
  type VaultView,
} from '@rekt/1000x';

export async function gatesForOpen(
  connection: Connection,
  state: {
    config: ConfigView;
    market: MarketView;
    vault: VaultView;
    gauges: VaultGauges;
    price: PriceReport;
    nowUnix: bigint;
  },
  owner: PublicKey,
  traderToken: PublicKey,
  req: OpenRequest,
): Promise<GateReport> {
  const traderAddress = traderPda(owner).address;
  const info = await connection.getAccountInfo(traderAddress, 'confirmed');

  // `null` is a legitimate state: a trader who has never traded. It is not an error.
  const trader: TraderAccountView | null = info
    ? decodeTraderAccount(new Uint8Array(info.data))
    : null;

  const balance = await connection.getTokenAccountBalance(traderToken, 'confirmed');

  return openGates(
    {
      config: state.config,
      market: state.market,
      vault: state.vault,
      gauges: state.gauges,
      // The quotes the price report admitted, plus the ones it did not — pass what you read. The
      // price rows do not decide an order: the fill judges the price.
      quotes: state.price.admitted,
      trader,
      // The account's ALLOCATION, not the length of its position vector. They differ the moment
      // anything settles, and using the vector's length refuses opens the program would admit.
      slotCapacity: info ? slotCapacity(info.data.length) : INITIAL_POSITION_SLOTS,
      traderBalance: BigInt(balance.value.amount),
      nowUnix: state.nowUnix,
      // True when the pool is on (`capitalActive`): the capacity and directional-cap rows are then
      // left out, because the fill admits cover.
      capitalMode: true,
    },
    req,
  );
}

import { approaching, headroom, type GateReport } from '@rekt/1000x';

export function table(report: GateReport): string[] {
  return report.gates.map((g) => {
    const room = headroom(g);
    const mark = !g.ok ? 'x' : approaching(g) ? '!' : '.';
    const pct = room === null ? '' : ` ${Math.round(room * 100)}% room`;
    return `${mark} ${g.label.padEnd(38)} ${g.value} / ${g.threshold}${pct}`;
  });
}