Read the protocol

import { Connection, PublicKey } from '@solana/web3.js';
import {
  assetId,
  chainNowSeconds,
  configPda,
  decodeConfig,
  decodeMarket,
  decodeVault,
  marketPda,
  vaultGauges,
  vaultPda,
  type ConfigView,
  type MarketView,
  type VaultGauges,
  type VaultView,
} from '@rekt/1000x';

export interface Protocol {
  config: ConfigView;
  vault: VaultView;
  gauges: VaultGauges;
  market: MarketView;
  nowUnix: bigint;
  nowSlot: bigint;
}

async function mustRead(connection: Connection, address: PublicKey, what: string) {
  const info = await connection.getAccountInfo(address, 'confirmed');
  if (!info) throw new Error(`${what} does not exist at ${address.toBase58()}`);
  return new Uint8Array(info.data);
}

export async function readProtocol(connection: Connection, symbol: string): Promise<Protocol> {
  const config = decodeConfig(await mustRead(connection, configPda().address, 'the config'));
  const vault = decodeVault(await mustRead(connection, vaultPda().address, 'the vault'));
  const market = decodeMarket(
    await mustRead(connection, marketPda(assetId(symbol)).address, `the ${symbol} market`),
  );

  // The pool's gauges need the vault's own token balance, read from the account the vault names.
  const vaultToken = new PublicKey(Buffer.from(vault.tokenAccount, 'hex'));
  const balance = await connection.getTokenAccountBalance(vaultToken, 'confirmed');

  const nowSlot = await connection.getSlot('confirmed');
  // The chain's clock, never this machine's: the program judges against `Clock.unix_timestamp`.
  // `getBlockTime` on one recent slot can answer null or throw; `chainNowSeconds` walks back to a
  // slot that answers.
  const nowUnix = BigInt(await chainNowSeconds(connection));

  return {
    config,
    vault,
    gauges: vaultGauges(vault, BigInt(balance.value.amount)),
    market,
    nowUnix,
    nowSlot: BigInt(nowSlot),
  };
}

import { benchmarkSourceFloor, settlementIdentity, type MarketView } from '@rekt/1000x';

export function oracleShape(market: MarketView) {
  const identity = settlementIdentity(market);
  return {
    // 'benchmark' with `pull: true`: the price rides in the caller's own transaction.
    vendor: identity.vendor,
    pull: identity.pull,
    // The fewest distinct oracle signatures a quote must carry.
    minSignatures: market.minSignatures,
    // The fewest sources a quote must aggregate to settle.
    settleSources: benchmarkSourceFloor(market, 'settle'),
    // How many slots old a quote may be when the program reads it.
    maxAgeSlots: market.maxOracleAgeSlots,
  };
}

import { openPreview, type ConfigView, type MarketView } from '@rekt/1000x';

export function quote(config: ConfigView, market: MarketView, nowUnix: bigint) {
  // The fourth argument is the rung in basis points of stake: 20_000 is 2.00x, the floor below
  // which the protocol will not price a take-profit. A bare `2` here asks for 2 bps and refuses.
  const preview = openPreview(config, market, 1_000_000n, 20_000, nowUnix);

  return {
    collateral: preview.collateral,   // what is at risk
    entryFee: preview.entryFee,       // taken from inside the budget; 0 at an entry fee of 0
    totalDebit: preview.totalDebit,   // what actually leaves the wallet
    maxPayout: preview.maxPayout,     // the gross payout at the target, before the exit fee and the share of the gain the terms withhold
    reserved: preview.reserved,       // its maximum payout and closing fee; the pool sets aside only the stake
    barrierPayout: preview.barrierPayout, // what the trader receives at the barrier
    barrierMicroBp: preview.barrierMicroBp,
    takeProfitMicroBp: preview.takeProfitMicroBp,
  };
}

import { openGates, type GateReport, type OpenContext, type OpenRequest } from '@rekt/1000x';

export function whatWouldRefuse(ctx: OpenContext, req: OpenRequest): GateReport {
  const report = openGates(ctx, req);

  if (report.refusal) {
    // `value` and `threshold` are already formatted for a human:
    //   "stake $0.10" against "at least $0.20"
    console.log(`${report.refusal.label}: ${report.refusal.value} / ${report.refusal.threshold}`);
    console.log(report.refusal.detail);
  }
  return report;
}

import { Connection } from '@solana/web3.js';
import { openPreview } from '@rekt/1000x';
import { readProtocol } from './read-protocol';
import { oracleShape } from './read-oracle';

export async function summary(symbol: string): Promise<string> {
  const url = process.env['SOLANA_RPC_URL'];
  if (!url) throw new Error('SOLANA_RPC_URL is not set');
  const connection = new Connection(url, 'confirmed');

  const p = await readProtocol(connection, symbol);
  const oracle = oracleShape(p.market);
  const preview = openPreview(p.config, p.market, p.config.params.minCollateral, 20_000, p.nowUnix);

  return [
    `${symbol}: priced by ${oracle.vendor}, a settle needs ${oracle.settleSources} sources and ${oracle.minSignatures} signatures`,
    `pool: openable ${p.gauges.openable}, withdrawable ${p.gauges.withdrawable}`,
    `open at minimum stake: debit ${preview.totalDebit}, max payout ${preview.maxPayout}`,
  ].join('\n');
}