Constants#

const MIN_DURATION_SECONDS = 60; // 1 minute
const MAX_DURATION_SECONDS = 604_800; // 7 days
const DEFAULT_DURATION_SECONDS = 900; // 15 minutes

// Market ID from timestamp and duration
function getMarketId(timestamp: number, durationSeconds: number): bigint {
  return BigInt(Math.floor(timestamp / durationSeconds));
}

// Market boundaries
function getMarketTimes(
  marketId: bigint,
  durationSeconds: number
): { tStart: number; tEnd: number } {
  const tStart = Number(marketId) * durationSeconds;
  const tEnd = tStart + durationSeconds;
  return { tStart, tEnd };
}

// Current market ID (for a 15-minute market)
const now = Math.floor(Date.now() / 1000);
const currentMarketId = getMarketId(now, 900); // e.g., 1892160n

const PRICE_SCALE = 10_000; // 100% = 10,000 bps
const MIN_PRICE_BPS = 1; // 0.01%
const MAX_PRICE_BPS = 9_999; // 99.99%
const DEFAULT_TICK_SIZE_BPS = 100; // 1%

// Basis points to percentage
function bpsToPercent(bps: number): number {
  return bps / 100; // 6000 bps = 60%
}

// Percentage to basis points
function percentToBps(percent: number): number {
  return percent * 100; // 60% = 6000 bps
}

// Basis points to decimal
function bpsToDecimal(bps: number): number {
  return bps / PRICE_SCALE; // 6000 bps = 0.60
}

// NO price from YES price
function noFromYes(yesPriceBps: number): number {
  return PRICE_SCALE - yesPriceBps; // 6000 -> 4000
}

const TICK_SIZE = 100; // 1%

// Round bid down
function roundBid(priceBps: number): number {
  return Math.floor(priceBps / TICK_SIZE) * TICK_SIZE;
}

// Round ask up
function roundAsk(priceBps: number): number {
  const remainder = priceBps % TICK_SIZE;
  return remainder === 0 ? priceBps : priceBps + (TICK_SIZE - remainder);
}

// Examples
roundBid(6050); // 6000
roundAsk(6050); // 6100

const MAX_ORDERS_PER_SIDE = 63; // 63 bids + 63 asks
const MAX_FILLS_PER_TX = 10; // Compute budget limit
const ORDER_SIZE_BYTES = 48; // Per order storage

// Order IDs are monotonically increasing per orderbook
const ORDER_ID_BITS = 64;
const MAX_ORDER_ID = BigInt(2) ** BigInt(64) - BigInt(1);

const TAKER_FEE_BPS = 200; // 2.0% (configurable)
const PROTOCOL_FEE_BPS = 150; // 1.5% — portion of taker fee to treasury
const CREATOR_FEE_BPS = 50; // 0.5% — portion of taker fee to market creator
const MAX_TAKER_FEE_BPS = 500; // Maximum: 5%

// Calculate taker fee (rounds UP)
function calculateTakerFee(amount: bigint, feeBps: number): bigint {
  const fee = amount * BigInt(feeBps);
  return (fee + BigInt(9999)) / BigInt(10000); // Ceiling division
}

// Example: 1000 USDC trade at 2.0% taker fee
const tradeAmount = 1000_000_000n; // 1000 USDC (6 decimals)
const takerFee = calculateTakerFee(tradeAmount, TAKER_FEE_BPS); // 20_000_000 (20 USDC)
// Protocol receives: 15 USDC (1.5%)
// Creator receives:   5 USDC (0.5%)

const DEFAULT_CLOSER_REWARD_LAMPORTS = 5_000; // 0.000005 SOL
const CLOSER_REWARDS_PER_MARKET = 2; // Two rewards per market lifecycle

const MARKET_ACCOUNT_SIZE = 512;
const ORDERBOOK_ACCOUNT_SIZE = 10240;
const POSITION_ACCOUNT_SIZE = 256;
const CONFIG_ACCOUNT_SIZE = 256;

// Approximate rent-exempt minimums (varies by Solana runtime)
const MARKET_RENT_LAMPORTS = 2_600_000; // ~0.0026 SOL
const ORDERBOOK_RENT_LAMPORTS = 57_000_000; // ~0.057 SOL
const POSITION_RENT_LAMPORTS = 1_900_000; // ~0.0019 SOL

const SEED_PREFIX = 'seesaw';
const SEED_CONFIG = 'config';
const SEED_MARKET = 'market';
const SEED_ORDERBOOK = 'orderbook';
const SEED_VAULT = 'vault';
const SEED_POSITION = 'position';

import { PublicKey } from '@solana/web3.js';

// Config PDA
function deriveConfigPda(programId: PublicKey): [PublicKey, number] {
  return PublicKey.findProgramAddressSync(
    [Buffer.from(SEED_PREFIX), Buffer.from(SEED_CONFIG)],
    programId
  );
}

// Market PDA (includes feed, duration, market ID, and creator)
function deriveMarketPda(
  pythFeedId: Uint8Array, // 32-byte feed ID
  durationSeconds: bigint,
  marketId: bigint,
  creatorPubkey: PublicKey,
  programId: PublicKey
): [PublicKey, number] {
  const durationBuffer = Buffer.alloc(8);
  durationBuffer.writeBigUInt64LE(durationSeconds);
  const marketIdBuffer = Buffer.alloc(8);
  marketIdBuffer.writeBigUInt64LE(marketId);

  return PublicKey.findProgramAddressSync(
    [
      Buffer.from(SEED_PREFIX),
      Buffer.from(SEED_MARKET),
      pythFeedId,
      durationBuffer,
      marketIdBuffer,
      creatorPubkey.toBuffer(),
    ],
    programId
  );
}

// Orderbook PDA
function deriveOrderbookPda(marketPda: PublicKey, programId: PublicKey): [PublicKey, number] {
  return PublicKey.findProgramAddressSync(
    [Buffer.from(SEED_PREFIX), Buffer.from(SEED_ORDERBOOK), marketPda.toBuffer()],
    programId
  );
}

// Vault PDA
function deriveVaultPda(marketPda: PublicKey, programId: PublicKey): [PublicKey, number] {
  return PublicKey.findProgramAddressSync(
    [Buffer.from(SEED_PREFIX), Buffer.from(SEED_VAULT), marketPda.toBuffer()],
    programId
  );
}

// Position PDA
function derivePositionPda(
  marketPda: PublicKey,
  userPubkey: PublicKey,
  programId: PublicKey
): [PublicKey, number] {
  return PublicKey.findProgramAddressSync(
    [
      Buffer.from(SEED_PREFIX),
      Buffer.from(SEED_POSITION),
      marketPda.toBuffer(),
      userPubkey.toBuffer(),
    ],
    programId
  );
}

const DISCRIMINATORS = {
  INITIALIZE_CONFIG: 0x00,
  CREATE_MARKET: 0x01,
  SNAPSHOT_END: 0x02,
  RESOLVE_MARKET: 0x03,
  EXPIRE_MARKET: 0x04,
  PLACE_ORDER: 0x05,
  CANCEL_ORDER: 0x06,
  MINT_SHARES: 0x07,
  REDEEM: 0x08,
  WITHDRAW_SHARES: 0x09,
  PAUSE: 0x0a,
  UNPAUSE: 0x0b,
  UPDATE_FEES: 0x0c,
  UPDATE_TICK_SIZE: 0x0d,
  FORCE_CLOSE: 0x0e,
  CLOSE_MARKET: 0x0f,
} as const;

// Pyth program ID (mainnet)
const PYTH_PROGRAM_ID = new PublicKey('FsJ3A3u2vn5cTVofAjvy6y5kwABJAqYWpe4975bi2epH');

// Common feed IDs
const PYTH_FEEDS = {
  BTC_USD: 'e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43',
  ETH_USD: 'ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace',
  SOL_USD: 'ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d',
};

// Confidence ratio (optional gating)
const MAX_CONFIDENCE_RATIO = 100; // 1% = conf/price <= 0.01

const COMPUTE_ESTIMATES = {
  PLACE_ORDER_NO_MATCH: 15_000,
  PLACE_ORDER_ONE_FILL: 25_000,
  PLACE_ORDER_MAX_FILLS: 60_000,
  CANCEL_ORDER: 10_000,
  REDEEM: 20_000,
  RESOLVE_MARKET: 30_000,
};

// Recommended CU limits
const RECOMMENDED_CU = {
  SIMPLE_OPERATION: 100_000,
  COMPLEX_OPERATION: 200_000,
  MAX_FILLS_OPERATION: 400_000,
};

// Public endpoints
const RPC_ENDPOINTS = {
  MAINNET: 'https://api.mainnet-beta.solana.com',
  DEVNET: 'https://api.devnet.solana.com',
};

// WebSocket endpoints
const WS_ENDPOINTS = {
  MAINNET: 'wss://api.mainnet-beta.solana.com',
  DEVNET: 'wss://api.devnet.solana.com',
};