Prediction Markets (Polymarket)

export const polymarketBalanceStore = createQueryStore({
  fetcher: async ({ proxyAddress }) => {
    const balance = await getUSDCBalance(proxyAddress);
    return { balance };
  },
  params: {
    proxyAddress: $ => $(usePolymarketClients).proxyAddress,
  },
  staleTime: time.seconds(30),
});

const categories = [
  'Politics',
  'Sports',
  'Crypto',
  'Pop Culture',
  'Business',
  'Science',
];

<PolymarketEventsList
  events={events}
  onSelectEvent={navigateToEvent}
/>

type SportsMarket = {
  gameId: string;
  teams: TeamInfo[];
  betType: 'moneyline' | 'spread' | 'total' | 'prop';
  outcomes: string[];
};

export function calculateOrderExecution({
  tokenId,
  amount,
  orderBook,
}: {
  tokenId: string;
  amount: string;
  orderBook: OrderBook;
}) {
  const asks = orderBook[tokenId]?.asks || [];
  
  let remainingAmount = Number(amount);
  let totalCost = 0;
  let totalShares = 0;
  
  for (const ask of asks) {
    if (remainingAmount <= 0) break;
    
    const fillSize = Math.min(remainingAmount, ask.size);
    totalCost += fillSize * ask.price;
    totalShares += fillSize;
    remainingAmount -= fillSize;
  }
  
  return {
    averagePrice: totalCost / totalShares,
    shares: totalShares,
    worstPrice: asks[asks.length - 1]?.price,
    bestPrice: asks[0]?.price,
  };
}

export async function marketBuyToken({
  tokenId,
  amount,
  price,
}: {
  tokenId: string;
  amount: string;
  price: string;
}) {
  const orderArgs = {
    tokenId,
    amount,
    price,
    side: 'BUY',
    feeRateBps: '0',  // No fee for market orders
  };
  
  return await clobClient.createMarketOrder(orderArgs);
}

export const usePolymarketPositionsStore = createQueryStore({
  fetcher: fetchPolymarketPositions,
  params: { address: $ => $(usePolymarketClients).proxyAddress },
  staleTime: time.seconds(30),
});

type PolymarketPosition = {
  eventId: string;
  marketSlug: string;
  outcome: string;
  size: string;           // Shares owned
  averagePrice: string;   // Average buy price
  currentPrice: string;   // Current market price
  currentValue: string;   // size * currentPrice
  unrealizedPnl: string;  // Current profit/loss
  redeemable: boolean;    // Can redeem for $1/share?
};

<PolymarketSellPositionSheet
  position={position}
  market={market}
/>

export async function redeemPosition({
  tokenId,
  amount,
}: {
  tokenId: string;
  amount: string;
}) {
  // Redeem conditional tokens for USDC
  await conditionalTokensContract.redeemPositions({
    tokenId,
    amount,
  });
}

export const polymarketLiveGameStore = createQueryStore({
  fetcher: async ({ gameId }) => {
    const client = polymarketSportsWsClient;
    return await client.subscribeToGame(gameId);
  },
  staleTime: time.seconds(10),  // Update every 10 seconds
});

<GameBoxScore
  teams={teams}
  score={liveGame.score}
  period={liveGame.period}
  clock={liveGame.clock}
/>

const TRADE_FEE_BPS = 200;  // 2%

export function calculateTradeFee(profit: string): string {
  return mulWorklet(profit, divWorklet(TRADE_FEE_BPS.toString(), '10000'));
}

export const polymarketOrderBookStore = createQueryStore({
  fetcher: async ({ tokenId }) => {
    const client = getPolymarketClobDataClient();
    return await client.getOrderBook({ tokenId });
  },
  staleTime: time.seconds(5),
});

export function useOrderValidation({ tokenId, amount }) {
  const orderBook = usePolymarketOrderBookStore(
    state => state.getData()?.[tokenId]
  );
  
  const hasNoLiquidity = orderBook?.asks?.length === 0;
  const totalLiquidity = orderBook?.asks?.reduce(
    (sum, ask) => sum + ask.size,
    0
  );
  const hasInsufficientLiquidity = totalLiquidity < Number(amount);
  
  return {
    hasNoLiquidity,
    hasInsufficientLiquidity,
    canTrade: !hasNoLiquidity && !hasInsufficientLiquidity,
  };
}

<PolymarketNoLiquidityCard
  title="No liquidity available"
  description="This market doesn't have enough orders to fill your bet."
/>

export function classifyMarket(market: PolymarketMarket) {
  if (market.tags.includes('sports')) {
    return 'sports';
  }
  if (market.tags.includes('politics')) {
    return 'politics';
  }
  if (market.tags.includes('crypto')) {
    return 'crypto';
  }
  return 'other';
}

export function trackPolymarketOrder({
  orderResult,
  context,
}: {
  orderResult: OrderResult;
  context: OrderContext;
}) {
  analytics.track(analytics.event.predictionsPlaceOrder, {
    eventSlug: context.eventSlug,
    marketSlug: context.marketSlug,
    outcome: context.outcome,
    orderAmountUsd: Number(context.amount),
    orderPriceUsd: Number(context.price),
    tokenId: context.tokenId,
    side: context.side,
  });
}