AI Agent Integration#

https://seesaw.markets/en/docs/sdk/seesaw-trading-skill

# Create skill directory
mkdir -p ~/.claude/skills/seesaw-trading

# Download skill file
curl -o ~/.claude/skills/seesaw-trading/SKILL.md \
  https://seesaw.markets/en/docs/sdk/seesaw-trading-skill

{
  "skills": {
    "seesaw-trading": {
      "url": "https://seesaw.markets/en/docs/sdk/seesaw-trading-skill"
    }
  }
}

from langchain.document_loaders import UnstructuredMarkdownLoader

loader = UnstructuredMarkdownLoader(
    "https://seesaw.markets/en/docs/sdk/seesaw-trading-skill"
)
docs = loader.load()

# Add to your agent's knowledge base
agent.add_documents(docs)

// docs-check: semantic
const skillUrl = 'https://seesaw.markets/en/docs/sdk/seesaw-trading-skill';

async function loadTradingSkill(): Promise<string> {
  const response = await fetch(skillUrl);
  return response.text();
}

// Add to agent's system prompt or knowledge base
async function main() {
  const skill = await loadTradingSkill();
  const agent = { addContext: (context: string) => console.log(context.length) };
  agent.addContext(skill);
}

void main();

// docs-check: semantic
const PYTH_FEED_IDS = {
  'BTC/USD': '0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43',
  'ETH/USD': '0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace',
  'SOL/USD': '0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d',
} as const;

type FeedSymbol = keyof typeof PYTH_FEED_IDS;

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

const feedSymbol: FeedSymbol = 'SOL/USD';
const feedId = PYTH_FEED_IDS[feedSymbol];

// Browser-native EventSource cannot attach the private Pyth bearer token.
// Use a configured app proxy that injects PYTH_API_KEY server-side and reconnect
// before the 24-hour Pyth stream limit. Do not hard-code indexer REST aliases.
const streamUrl = buildPythStreamProxyUrl(feedId);
console.log(streamUrl);

// docs-check: semantic
interface MarketPosition {
  delta: number; // currentPrice - startPrice
  deltaPct: number; // Percentage change
  status: 'above' | 'below' | 'at';
  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,
    isAbove: status === 'above',
    isBelow: status === 'below',
  };
}

const position = computeMarketPosition(100, 101);
console.log(position.status, position.deltaPct);

// docs-check: semantic
interface TradingSignal {
  action: 'buy_yes' | 'buy_no' | 'hold';
  confidence: number;
  reason: string;
  suggestedPrice: number;
  suggestedQuantity: number;
}

// See full implementation in the skill file
function analyzeTradeOpportunity(
  startPrice: number,
  currentPrice: number,
  marketBestBid: number,
  marketBestAsk: number,
  timeRemainingSeconds: number
): TradingSignal;

function analyzeTradeOpportunity(
  startPrice: number,
  currentPrice: number,
  marketBestBid: number,
  marketBestAsk: number,
  timeRemainingSeconds: number
): TradingSignal {
  const priceIsAboveStart = currentPrice > startPrice;
  const midPriceBps = Math.floor((marketBestBid + marketBestAsk) / 2);
  const enoughTime = timeRemainingSeconds > 60;

  if (!enoughTime) {
    return {
      action: 'hold',
      confidence: 0.2,
      reason: 'market is close to expiry',
      suggestedPrice: midPriceBps,
      suggestedQuantity: 0,
    };
  }

  return {
    action: priceIsAboveStart ? 'buy_yes' : 'buy_no',
    confidence: 0.6,
    reason: priceIsAboveStart ? 'current price is above start' : 'current price is below start',
    suggestedPrice: midPriceBps,
    suggestedQuantity: 1_000_000,
  };
}

const signal = analyzeTradeOpportunity(100, 101, 4_900, 5_100, 300);
console.log(signal.action, signal.suggestedPrice);

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

const side = OrderSide.BuyYes; // bullish on price going up
const orderType = OrderType.Limit; // match then rest on book

console.log({ side, orderType });

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

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

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

function analyzeTradeOpportunity(
  startPrice: number,
  currentPrice: number,
  marketBestBid: number,
  marketBestAsk: number,
  timeRemainingSeconds: number
): TradingSignal {
  const midPrice = Math.floor((marketBestBid + marketBestAsk) / 2);
  if (timeRemainingSeconds < 60) {
    return {
      action: 'hold',
      confidence: 0.2,
      reason: 'market is near expiry',
      suggestedPrice: midPrice,
      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: midPrice,
    suggestedQuantity: 1_000_000,
  };
}

async function fetchCurrentMarket(): Promise<{ market: AgentMarket }> {
  return fetch('/api/v1/markets/current').then((r) => r.json() as Promise<{ market: AgentMarket }>);
}

async function fetchMarketOrderbook(marketAddress: string): Promise<{ orderbook: AgentOrderbook }> {
  return fetch(`/api/v1/markets/${marketAddress}`).then(
    (r) => r.json() as Promise<{ orderbook: AgentOrderbook }>
  );
}

async function fetchPythPrice(_pythFeed: string): Promise<number> {
  return 101;
}

async function executeOrder(_market: AgentMarket, _signal: TradingSignal): Promise<void> {
  // Build, simulate, sign, and submit the order transaction here.
}

async function agentTradingLoop() {
  // 1. Get current market
  const { market } = await fetchCurrentMarket();

  // 2. Get live price
  const currentPrice = await fetchPythPrice(market.pythFeed);

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

  // 4. Get orderbook
  const { orderbook } = await fetchMarketOrderbook(market.address);

  // 5. Generate signal
  const signal = analyzeTradeOpportunity(
    startPrice,
    currentPrice,
    orderbook.bids[0]?.price || 0,
    orderbook.asks[0]?.price || 10000,
    timeRemaining
  );

  // 6. Execute if confident
  if (signal.action !== 'hold' && signal.confidence > 0.5) {
    await executeOrder(market, signal);
  }
}

// Run every 30 seconds
const loopTimer = setInterval(() => void agentTradingLoop(), 30_000);
clearInterval(loopTimer);

// docs-check: semantic
import { address } from '@solana/addresses';
import { resolveReferrer } from '@seesaw/core';

const agentWallet = address(process.env.SEESAW_WALLET_ADDRESS!);
const pendingReferrer = process.env.SEESAW_REFERRER
  ? address(process.env.SEESAW_REFERRER)
  : undefined;

// This offline example has no indexed lock. Production adapters must read
// authoritative referral state and refresh expiry before constructing orders.
const resolution = await resolveReferrer({
  wallet: agentWallet,
  indexerClient: {
    async getReferral() {
      return null;
    },
  },
  pendingReferrer,
});
// A pending result is only a candidate: it must be locked before its PDA is supplied.
// The resolver does not construct order accounts or inspect the position cache.
console.log(resolution.source, resolution.address, resolution.isLocked);