Seesaw Trading Skill#

PENDING → CREATED → TRADING → SETTLING → RESOLVED → CLOSED

// docs-check: semantic
// Calculate market boundaries from any timestamp
const EPOCH_DURATION = 900; // default 15 minutes; configurable per market (60–604800)

function getMarketId(timestamp: number): bigint {
  return BigInt(Math.floor(timestamp / EPOCH_DURATION));
}

function getMarketTimes(marketId: bigint) {
  const tStart = Number(marketId) * EPOCH_DURATION;
  const tEnd = tStart + EPOCH_DURATION;
  return { tStart, tEnd };
}

// Example: Get current market
const now = Math.floor(Date.now() / 1000);
const currentMarketId = getMarketId(now);
const { tStart, tEnd } = getMarketTimes(currentMarketId);

// docs-check: semantic
const PYTH_FEED_IDS = {
  'BTC/USD': '0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43',
  'ETH/USD': '0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace',
  'SOL/USD': '0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d',
  'AVAX/USD': '0x93da3352f9f1d105fdfe4971cfa80e9dd777bfc5d0f683ebb6e1294b92137bb7',
  'LINK/USD': '0x8ac0c70fff57e9aefdf5edf44b51d62c2d433653cbb2cf5cc06bb115af04d221',
  'ARB/USD': '0x3fa4252848f9f0a1480be62745a4629d9eb1322aebab8a791e344b3b9c1adcf5',
  'OP/USD': '0x385f64d993f7b77d8182ed5003d97c60aa3361f3cecfe711544d2d59165e9bdf',
};

// docs-check: semantic
const STREAM_FEED_IDS = {
  'BTC/USD': '0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43',
} as const;

interface PythStreamPriceUpdate {
  price: {
    price: string;
    expo: number;
    publish_time: number;
  };
}

interface PythStreamMessage {
  parsed?: PythStreamPriceUpdate[];
}

function buildPythStreamProxyUrl(feedId: string): string {
  const url = new URL('/api/pyth/stream', 'https://api.seesaw.markets');
  url.searchParams.set('ids[]', feedId);
  return url.toString();
}

// Browser/EventSource paths should use a configured app proxy that injects
// PYTH_API_KEY server-side. Do not hard-code indexer REST aliases here.
const feedId = STREAM_FEED_IDS['BTC/USD'].replace(/^0x/, '');
const url = buildPythStreamProxyUrl(feedId);

const eventSource = new EventSource(url);

eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data) as PythStreamMessage;

  if (data.parsed && Array.isArray(data.parsed)) {
    for (const update of data.parsed) {
      const price = parseFloat(update.price.price);
      const expo = update.price.expo;
      const actualPrice = price * Math.pow(10, expo);
      const publishTime = update.price.publish_time;

      console.log(`Price: $${actualPrice.toFixed(2)} at ${publishTime}`);
    }
  }
};

// docs-check: semantic
interface HermesPriceUpdate {
  price: {
    price: string;
    expo: number;
  };
}

interface HermesLatestPriceResponse {
  parsed?: HermesPriceUpdate[];
}

async function fetchCurrentPrice(feedId: string): Promise<number> {
  const id = feedId.replace(/^0x/, '');
  const url = `https://pyth.dourolabs.app/hermes/v2/updates/price/latest?ids[]=${id}&parsed=true`;

  const response = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.PYTH_API_KEY}` },
  });
  const data = (await response.json()) as HermesLatestPriceResponse;

  if (data.parsed && data.parsed.length > 0) {
    const update = data.parsed[0];
    const price = parseFloat(update.price.price);
    const expo = update.price.expo;
    return price * Math.pow(10, expo);
  }

  throw new Error('No price data available');
}

Price in bps → Implied probability
6000 bps = 60% probability of UP
4000 bps = 40% probability of UP (or 60% probability of DOWN)

Collateral calculation:
collateral = (price_bps * quantity) / 10000

Example: Buy 100 YES shares at 6000 bps
collateral = (6000 * 100) / 10000 = 60 USDT

// docs-check: semantic
function roundToTick(price: number, tickSize: number, side: 'bid' | 'ask'): number {
  if (side === 'bid') {
    return Math.floor(price / tickSize) * tickSize;
  } else {
    const remainder = price % tickSize;
    return remainder > 0 ? price + (tickSize - remainder) : price;
  }
}

// Examples:
roundToTick(6050, 100, 'bid'); // → 6000
roundToTick(6050, 100, 'ask'); // → 6100

// docs-check: semantic
import type { Address } from '@solana/addresses';
import { OrderSide, OrderType } from '@seesaw/core';

interface PlaceOrderParams {
  market: Address; // Market account PDA
  side: OrderSide; // 0=BuyYes, 1=SellYes, 2=BuyNo, 3=SellNo
  priceBps: number; // Price in basis points [1, 9999]
  quantity: bigint; // Number of shares
  orderType: OrderType; // 0=Limit, 1=PostOnly, 2=ImmediateOrCancel
}

// docs-check: semantic
import type { Address } from '@solana/addresses';

interface CancelOrderParams {
  market: Address;
  orderId: bigint; // The order's unique u64 id (from placement or the on-chain book)
}

// docs-check: semantic
import type { Address } from '@solana/addresses';

interface RedeemParams {
  market: Address;
  amount: bigint; // Amount of tokens to redeem
  tokenType: 'yes' | 'no'; // Which token to redeem (0=Yes, 1=No)
}

// Payout calculation:
// if outcome == UP:  burn YES tokens → receive USDT 1:1
// if outcome == DOWN: burn NO tokens → receive USDT 1:1
// if outcome == EXPIRED: burn either → receive USDT at 50%

GET /api/v1/markets?state={state}&limit={limit}&offset={offset}

{
  "markets": [
    {
      "address": "...",
      "marketId": "1234567",
      "pythFeed": "...",
      "state": 1,
      "outcome": null,
      "tStart": "2024-01-15T10:00:00Z",
      "tEnd": "2024-01-15T10:15:00Z",
      "startPrice": "68543210000",
      "totalVolume": "1000000",
      "totalTrades": 42
    }
  ],
  "total": 100,
  "limit": 50,
  "offset": 0
}

GET /api/v1/markets/current

{
  "market": {
    "id": "BTC-1H-2026-07-04T15:00Z",
    "question": "Will BTC close above $110,000?"
  },
  "status": "trading"
}

GET /api/v1/markets/{marketId}

{
  "market": {
    "id": "BTC-1H-2026-07-04T15:00Z",
    "question": "Will BTC close above $110,000?"
  },
  "orderbook": {
    "bids": [{ "price": 6000, "quantity": "1000", "orders": 3 }],
    "asks": [{ "price": 6100, "quantity": "500", "orders": 2 }]
  }
}

// docs-check: semantic
interface MarketPosition {
  delta: number; // currentPrice - startPrice
  deltaPct: number; // Percentage change
  status: 'above' | 'below' | 'at';
  distanceToFlip: number;
  isAbove: boolean;
  isBelow: boolean;
}

function computeMarketPosition(startPrice: number, currentPrice: number): MarketPosition {
  const delta = currentPrice - startPrice;
  const deltaPct = delta / startPrice;

  const status = deltaPct > 0.0001 ? 'above' : deltaPct < -0.0001 ? 'below' : 'at';

  return {
    delta,
    deltaPct,
    status,
    distanceToFlip: Math.abs(delta),
    isAbove: status === 'above',
    isBelow: status === 'below',
  };
}

const samplePosition = computeMarketPosition(100, 101);
console.log(samplePosition.status, samplePosition.distanceToFlip);

// docs-check: semantic
interface MarketPosition {
  delta: number;
  deltaPct: number;
  status: 'above' | 'below' | 'at';
  distanceToFlip: number;
  isAbove: boolean;
  isBelow: boolean;
}

function computeImpliedProbability(
  position: MarketPosition,
  volatilityFactor: number = 0.02
): number {
  // Logistic function centered at start price
  const k = 1 / volatilityFactor;
  const probability = 1 / (1 + Math.exp(-k * position.deltaPct));
  return Math.max(0.01, Math.min(0.99, probability));
}

const probability = computeImpliedProbability({
  delta: 1,
  deltaPct: 0.01,
  status: 'above',
  distanceToFlip: 1,
  isAbove: true,
  isBelow: false,
});
console.log(probability);

// docs-check: semantic
interface MarketPosition {
  delta: number;
  deltaPct: number;
  status: 'above' | 'below' | 'at';
  distanceToFlip: number;
  isAbove: boolean;
  isBelow: boolean;
}

interface TradingSignal {
  action: 'buy_yes' | 'buy_no' | 'hold';
  confidence: number;
  reason: string;
  suggestedPrice: number;
  suggestedQuantity: number;
}

function computeMarketPosition(startPrice: number, currentPrice: number): MarketPosition {
  const delta = currentPrice - startPrice;
  const deltaPct = delta / startPrice;
  const status = deltaPct > 0.0001 ? 'above' : deltaPct < -0.0001 ? 'below' : 'at';
  return {
    delta,
    deltaPct,
    status,
    distanceToFlip: Math.abs(delta),
    isAbove: status === 'above',
    isBelow: status === 'below',
  };
}

function computeImpliedProbability(
  position: MarketPosition,
  volatilityFactor: number = 0.02
): number {
  const k = 1 / volatilityFactor;
  const probability = 1 / (1 + Math.exp(-k * position.deltaPct));
  return Math.max(0.01, Math.min(0.99, probability));
}

function analyzeTradeOpportunity(
  startPrice: number,
  currentPrice: number,
  marketBestBid: number, // Best YES bid in bps
  marketBestAsk: number, // Best YES ask in bps
  timeRemainingSeconds: number,
  volatilityEstimate: number = 0.02
): TradingSignal {
  const position = computeMarketPosition(startPrice, currentPrice);
  const impliedProb = computeImpliedProbability(position, volatilityEstimate);

  // Convert to basis points
  const impliedPriceBps = Math.round(impliedProb * 10000);

  // Market mid price
  const marketMid = (marketBestBid + marketBestAsk) / 2;

  // Look for mispricing
  const priceDiff = impliedPriceBps - marketMid;
  const threshold = 200; // 2% edge threshold

  // Time decay factor - less aggressive near end
  const timeFactor = Math.max(0.3, timeRemainingSeconds / 900);

  if (priceDiff > threshold * timeFactor) {
    // Market underpricing YES (or overpricing NO)
    // Buy YES below our fair value
    return {
      action: 'buy_yes',
      confidence: Math.min(1, Math.abs(priceDiff) / 500),
      reason: `YES underpriced by ${priceDiff} bps`,
      suggestedPrice: Math.min(impliedPriceBps - 50, marketBestAsk),
      suggestedQuantity: calculatePositionSize(priceDiff, timeFactor),
    };
  } else if (priceDiff < -threshold * timeFactor) {
    // Market overpricing YES (or underpricing NO)
    // Buy NO
    return {
      action: 'buy_no',
      confidence: Math.min(1, Math.abs(priceDiff) / 500),
      reason: `NO underpriced by ${-priceDiff} bps`,
      suggestedPrice: 10000 - Math.max(impliedPriceBps + 50, marketBestBid),
      suggestedQuantity: calculatePositionSize(-priceDiff, timeFactor),
    };
  }

  return {
    action: 'hold',
    confidence: 0,
    reason: 'No significant mispricing detected',
    suggestedPrice: 0,
    suggestedQuantity: 0,
  };
}

function calculatePositionSize(edgeBps: number, timeFactor: number): number {
  // Kelly-inspired sizing: bet more when edge is larger
  // Scale down near market end (timeFactor)
  const baseSize = 100; // Base position in shares
  const edgeFactor = Math.min(3, Math.abs(edgeBps) / 100);
  return Math.floor(baseSize * edgeFactor * timeFactor);
}

const signal = analyzeTradeOpportunity(100, 101, 5_800, 6_100, 600);
console.log(signal.action, signal.suggestedQuantity);

fee_bps(p) = min(fee_cap_bps, decay_rate_bps × (10_000 − p) / 10_000)

// docs-check: semantic
import { DEFAULT_FEE_SPLIT, computeAndSplit } from '@seesaw/core';

function calculateFees(
  notional: bigint,
  priceBps: number,
  isTaker: boolean,
  hasReferrer: boolean,
  feeCapBps: number = 200,
  decayRateBps: number = 600
): {
  total: bigint;
  protocolFee: bigint;
  creatorFee: bigint;
  referralFee: bigint;
} {
  if (!isTaker) {
    return { total: 0n, protocolFee: 0n, creatorFee: 0n, referralFee: 0n };
  }

  // Matches on-chain rounding: total fee rounds up, creator/referral shares
  // round down, and all dust stays with protocol.
  const split = computeAndSplit(notional, priceBps, feeCapBps, decayRateBps, DEFAULT_FEE_SPLIT);

  // If taker has no referrer, the 40% referral share flows to protocol treasury
  const protocolFee = hasReferrer ? split.protocol : split.protocol + split.referral;
  const referralFee = hasReferrer ? split.referral : 0n;

  return {
    total: split.total,
    protocolFee,
    creatorFee: split.creator,
    referralFee,
  };
}

// docs-check: semantic
import { address } from '@solana/addresses';
import {
  deriveMarketPda,
  deriveOrderbookPda,
  deriveVaultPda,
  derivePositionPda,
  deriveConfigPda,
  deriveAssetPda,
  deriveYesMintPda,
  deriveNoMintPda,
} from '@seesaw/core';

const pythFeedId = new Uint8Array(32);
const durationSeconds = 900n;
const marketId = 1n;
const creatorAddress = address('11111111111111111111111111111111');
const userAddress = address('SysvarC1ock11111111111111111111111111111111');

// Market PDA uses 6 seeds:
// ["seesaw", "market", pyth_feed_id(32), duration_seconds(8 LE), market_id(8 LE), creator(32)]
const [marketPda] = await deriveMarketPda(pythFeedId, durationSeconds, marketId, creatorAddress);
const [orderbookPda] = await deriveOrderbookPda(marketPda);
const [vaultPda] = await deriveVaultPda(marketPda);
const [positionPda] = await derivePositionPda(marketPda, userAddress);

// Additional PDA derivations
const [configPda] = await deriveConfigPda();
const [assetPda] = await deriveAssetPda(pythFeedId);
const [yesMintPda] = await deriveYesMintPda(marketPda);
const [noMintPda] = await deriveNoMintPda(marketPda);

console.log({ orderbookPda, vaultPda, positionPda, configPda, assetPda, yesMintPda, noMintPda });

// docs-check: semantic
interface TradingFlowMarket {
  address: string;
  pythFeed: string;
  startPrice: string;
  startPriceExpo: number;
  tEnd: string;
}

interface TradingFlowOrderbook {
  bids: Array<{ price: number }>;
  asks: Array<{ price: number }>;
}

interface TradingSignal {
  action: 'buy_yes' | 'buy_no' | 'hold';
  confidence: number;
  reason: string;
  suggestedPrice: number;
  suggestedQuantity: number;
}

interface PythLatestPriceResponse {
  parsed: Array<{
    price: {
      price: string;
      expo: number;
    };
  }>;
}

function analyzeTradeOpportunity(
  startPrice: number,
  currentPrice: number,
  bestBid: number,
  bestAsk: number,
  timeRemainingSeconds: number
): TradingSignal {
  const midpoint = Math.floor((bestBid + bestAsk) / 2);
  if (timeRemainingSeconds < 60) {
    return {
      action: 'hold',
      confidence: 0.2,
      reason: 'market is near expiry',
      suggestedPrice: midpoint,
      suggestedQuantity: 0,
    };
  }
  return {
    action: currentPrice >= startPrice ? 'buy_yes' : 'buy_no',
    confidence: 0.6,
    reason:
      currentPrice >= startPrice ? 'current price is above start' : 'current price is below start',
    suggestedPrice: midpoint,
    suggestedQuantity: 1_000_000,
  };
}

async function executeTradingStrategy() {
  // 1. Get current market
  const marketResponse = await fetch('/api/v1/markets/current');
  const { market, status } = (await marketResponse.json()) as {
    market: TradingFlowMarket;
    status: string;
  };

  if (status !== 'trading') {
    console.log('No active market, waiting...');
    return;
  }

  // 2. Stream live price
  const feedId = market.pythFeed.replace(/^0x/, '');
  const priceUrl = `https://pyth.dourolabs.app/hermes/v2/updates/price/latest?ids[]=${feedId}&parsed=true`;
  const priceResponse = await fetch(priceUrl, {
    headers: { Authorization: `Bearer ${process.env.PYTH_API_KEY}` },
  });
  const priceData = (await priceResponse.json()) as PythLatestPriceResponse;

  const currentPrice =
    parseFloat(priceData.parsed[0].price.price) * Math.pow(10, priceData.parsed[0].price.expo);

  // 3. Parse market data
  const startPrice = Number(market.startPrice) * Math.pow(10, market.startPriceExpo);
  const tEnd = new Date(market.tEnd).getTime() / 1000;
  const now = Date.now() / 1000;
  const timeRemaining = tEnd - now;

  // 4. Get orderbook
  const obResponse = await fetch(`/api/v1/markets/${market.address}`);
  const { orderbook } = (await obResponse.json()) as { orderbook: TradingFlowOrderbook };

  const bestBid = orderbook.bids[0]?.price || 0;
  const bestAsk = orderbook.asks[0]?.price || 10000;

  // 5. Analyze opportunity
  const signal = analyzeTradeOpportunity(startPrice, currentPrice, bestBid, bestAsk, timeRemaining);

  console.log('Trading signal:', signal);

  // 6. Execute if confident
  if (signal.action !== 'hold' && signal.confidence > 0.5) {
    // Build and send transaction...
    console.log(`Executing: ${signal.action} at ${signal.suggestedPrice} bps`);
  }
}

// Run every 30 seconds during active markets
const strategyTimer = setInterval(() => void executeTradingStrategy(), 30_000);
clearInterval(strategyTimer);