@catalyst-team/poly-sdk 0.2.0 → 0.2.1

package/src/__tests__/integration/gamma-api.integration.test.ts

@@ -1,206 +0,0 @@
-/**
- * Gamma API Client Integration Tests
- *
- * These tests make REAL API calls to Polymarket.
- *
- * Run with: pnpm test:integration
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import { GammaApiClient } from '../../clients/gamma-api.js';
-import { RateLimiter } from '../../core/rate-limiter.js';
-import { createUnifiedCache } from '../../core/unified-cache.js';
-
-describe('GammaApiClient Integration', () => {
-  let client: GammaApiClient;
-
-  beforeAll(() => {
-    client = new GammaApiClient(new RateLimiter(), createUnifiedCache());
-  });
-
-  describe('getMarkets', () => {
-    it('should fetch active markets sorted by volume', async () => {
-      const markets = await client.getMarkets({
-        active: true,
-        closed: false,
-        order: 'volume24hr',
-        ascending: false,
-        limit: 10,
-      });
-
-      expect(Array.isArray(markets)).toBe(true);
-      expect(markets.length).toBeGreaterThan(0);
-      expect(markets.length).toBeLessThanOrEqual(10);
-
-      // Verify each market structure
-      for (const market of markets) {
-        expect(typeof market.id).toBe('string');
-        expect(typeof market.conditionId).toBe('string');
-        expect(typeof market.question).toBe('string');
-        expect(market.question.length).toBeGreaterThan(0);
-        expect(Array.isArray(market.outcomes)).toBe(true);
-        expect(Array.isArray(market.outcomePrices)).toBe(true);
-        expect(typeof market.volume).toBe('number');
-        expect(typeof market.active).toBe('boolean');
-        expect(market.active).toBe(true);  // We filtered for active
-      }
-
-      // Verify volume24hr is sorted descending
-      for (let i = 1; i < markets.length; i++) {
-        const prev = markets[i - 1].volume24hr ?? 0;
-        const curr = markets[i].volume24hr ?? 0;
-        expect(prev).toBeGreaterThanOrEqual(curr);
-      }
-
-      console.log(`✓ Fetched ${markets.length} active markets sorted by 24h volume`);
-      console.log(`  Top market: "${markets[0].question.slice(0, 50)}..."`);
-      console.log(`  24h volume: $${markets[0].volume24hr?.toLocaleString()}`);
-    }, 30000);
-
-    it('should return correct outcome prices', async () => {
-      const markets = await client.getMarkets({
-        active: true,
-        limit: 5,
-      });
-
-      for (const market of markets) {
-        // Outcome prices should be between 0 and 1
-        for (const price of market.outcomePrices) {
-          expect(price).toBeGreaterThanOrEqual(0);
-          expect(price).toBeLessThanOrEqual(1);
-        }
-
-        // For binary markets, prices should roughly sum to 1
-        // But some markets might have no liquidity (0 prices)
-        if (market.outcomes.length === 2) {
-          const sum = market.outcomePrices.reduce((a, b) => a + b, 0);
-          // Allow for no liquidity (0) or normal spread
-          if (sum > 0) {
-            expect(sum).toBeGreaterThan(0.8);
-            expect(sum).toBeLessThan(1.2);
-          }
-        }
-      }
-
-      console.log('✓ Outcome prices validated for all markets');
-    }, 30000);
-
-    it('should handle pagination correctly', async () => {
-      const page1 = await client.getMarkets({
-        active: true,
-        limit: 5,
-        offset: 0,
-      });
-
-      const page2 = await client.getMarkets({
-        active: true,
-        limit: 5,
-        offset: 5,
-      });
-
-      // Pages should have different markets
-      const page1Ids = new Set(page1.map(m => m.id));
-      const page2Ids = new Set(page2.map(m => m.id));
-
-      for (const id of page2Ids) {
-        expect(page1Ids.has(id)).toBe(false);
-      }
-
-      console.log(`✓ Pagination works: page1 has ${page1.length} markets, page2 has ${page2.length} markets`);
-    }, 30000);
-  });
-
-  describe('getTrendingMarkets', () => {
-    it('should return trending markets by 24h volume', async () => {
-      const trending = await client.getTrendingMarkets(10);
-
-      expect(trending.length).toBeGreaterThan(0);
-
-      // Should all be active and not closed
-      for (const market of trending) {
-        expect(market.active).toBe(true);
-        expect(market.closed).toBe(false);
-      }
-
-      // Should be sorted by volume24hr descending
-      for (let i = 1; i < trending.length; i++) {
-        const prev = trending[i - 1].volume24hr ?? 0;
-        const curr = trending[i].volume24hr ?? 0;
-        expect(prev).toBeGreaterThanOrEqual(curr);
-      }
-
-      console.log(`✓ Top ${trending.length} trending markets retrieved`);
-    }, 30000);
-  });
-
-  describe('getEvents', () => {
-    it('should fetch events with associated markets', async () => {
-      const events = await client.getEvents({
-        active: true,
-        limit: 5,
-      });
-
-      expect(Array.isArray(events)).toBe(true);
-
-      if (events.length > 0) {
-        const event = events[0];
-
-        expect(typeof event.id).toBe('string');
-        expect(typeof event.title).toBe('string');
-        expect(event.title.length).toBeGreaterThan(0);
-        expect(Array.isArray(event.markets)).toBe(true);
-
-        console.log(`✓ Fetched ${events.length} events`);
-        console.log(`  First event: "${event.title}"`);
-        console.log(`  Markets in event: ${event.markets.length}`);
-      } else {
-        console.log('✓ No active events found (this is ok)');
-      }
-    }, 30000);
-  });
-
-  describe('getMarketBySlug', () => {
-    it('should find market by slug', async () => {
-      // First get a market to know its slug
-      const markets = await client.getMarkets({ active: true, limit: 1 });
-
-      if (markets.length === 0) {
-        console.log('No markets found, skipping test');
-        return;
-      }
-
-      const slug = markets[0].slug;
-      const market = await client.getMarketBySlug(slug);
-
-      expect(market).not.toBeNull();
-      expect(market?.slug).toBe(slug);
-      expect(market?.question).toBe(markets[0].question);
-
-      console.log(`✓ Found market by slug: "${slug}"`);
-    }, 30000);
-
-    it('should return null for non-existent slug', async () => {
-      const market = await client.getMarketBySlug('this-market-definitely-does-not-exist-12345');
-      expect(market).toBeNull();
-    }, 30000);
-  });
-
-  describe('getMarketByConditionId', () => {
-    it('should find market by condition ID', async () => {
-      const markets = await client.getMarkets({ active: true, limit: 1 });
-
-      if (markets.length === 0) {
-        console.log('No markets found, skipping test');
-        return;
-      }
-
-      const conditionId = markets[0].conditionId;
-      const market = await client.getMarketByConditionId(conditionId);
-
-      expect(market).not.toBeNull();
-      expect(market?.conditionId).toBe(conditionId);
-
-      console.log(`✓ Found market by conditionId: "${conditionId.slice(0, 20)}..."`);
-    }, 30000);
-  });
-});

package/src/__tests__/test-utils.ts

@@ -1,170 +0,0 @@
-/**
- * Test Utilities for poly-sdk
- *
- * Provides mock implementations and test helpers for unit testing.
- */
-
-import { vi } from 'vitest';
-
-// ===== Mock Data =====
-
-export const mockClobMarket = {
-  conditionId: '0x82ace55cdcba920112a2b3548f21e6e117730144db4dd580456aaecf1a2ad751',
-  question: 'Will BTC reach $100k by end of 2024?',
-  description: 'This market resolves YES if Bitcoin reaches $100,000 USD.',
-  marketSlug: 'will-btc-reach-100k',
-  tokens: [
-    {
-      tokenId: '21742633143463906290569050155826241533067272736897614950488156847949938836455',
-      outcome: 'Yes',
-      price: 0.65,
-    },
-    {
-      tokenId: '79707176503087022804581743747659199568535926050896809695934676056217229461419',
-      outcome: 'No',
-      price: 0.35,
-    },
-  ],
-  acceptingOrders: true,
-  endDateIso: '2024-12-31T23:59:59Z',
-  active: true,
-  closed: false,
-};
-
-export const mockOrderbook = {
-  bids: [
-    { price: 0.55, size: 1000 },
-    { price: 0.54, size: 500 },
-    { price: 0.53, size: 750 },
-  ],
-  asks: [
-    { price: 0.57, size: 800 },
-    { price: 0.58, size: 600 },
-    { price: 0.59, size: 400 },
-  ],
-  timestamp: Date.now(),
-};
-
-export const mockNoOrderbook = {
-  bids: [
-    { price: 0.43, size: 900 },
-    { price: 0.42, size: 450 },
-  ],
-  asks: [
-    { price: 0.45, size: 700 },
-    { price: 0.46, size: 500 },
-  ],
-  timestamp: Date.now(),
-};
-
-export const mockGammaMarket = {
-  id: '12345',
-  conditionId: '0x82ace55cdcba920112a2b3548f21e6e117730144db4dd580456aaecf1a2ad751',
-  slug: 'will-btc-reach-100k',
-  question: 'Will BTC reach $100k by end of 2024?',
-  outcomes: ['Yes', 'No'],
-  outcomePrices: [0.65, 0.35],
-  volume: 5000000,
-  volume24hr: 250000,
-  liquidity: 100000,
-  spread: 0.02,
-  endDate: new Date('2024-12-31T23:59:59Z'),
-  active: true,
-  closed: false,
-};
-
-export const mockPosition = {
-  asset: '21742633143463906290569050155826241533067272736897614950488156847949938836455',
-  conditionId: '0x82ace55cdcba920112a2b3548f21e6e117730144db4dd580456aaecf1a2ad751',
-  outcome: 'Yes',
-  outcomeIndex: 0,
-  size: 100,
-  avgPrice: 0.50,
-  curPrice: 0.65,
-  cashPnl: 15,
-  percentPnl: 0.30,
-  title: 'Will BTC reach $100k?',
-};
-
-// ===== Mock RateLimiter =====
-
-export class MockRateLimiter {
-  async execute<T>(_apiType: string, fn: () => Promise<T>): Promise<T> {
-    return fn();
-  }
-}
-
-// ===== Mock Cache =====
-
-export class MockCache {
-  private cache = new Map<string, { value: unknown; expires: number }>();
-
-  async getOrSet<T>(
-    key: string,
-    ttl: number,
-    fn: () => Promise<T>
-  ): Promise<T> {
-    const cached = this.cache.get(key);
-    if (cached && cached.expires > Date.now()) {
-      return cached.value as T;
-    }
-    const value = await fn();
-    this.cache.set(key, { value, expires: Date.now() + ttl });
-    return value;
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-}
-
-// ===== Mock Fetch =====
-
-export function createMockFetch(responses: Record<string, unknown>) {
-  return vi.fn(async (url: string) => {
-    const urlObj = new URL(url);
-    const path = urlObj.pathname;
-
-    for (const [pattern, response] of Object.entries(responses)) {
-      if (path.includes(pattern)) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => response,
-        };
-      }
-    }
-
-    return {
-      ok: false,
-      status: 404,
-      json: async () => ({ error: 'Not found' }),
-    };
-  });
-}
-
-// ===== Assertion Helpers =====
-
-export function expectOrderbookSorted(orderbook: {
-  bids: Array<{ price: number }>;
-  asks: Array<{ price: number }>;
-}): void {
-  // Bids should be descending
-  for (let i = 1; i < orderbook.bids.length; i++) {
-    if (orderbook.bids[i].price > orderbook.bids[i - 1].price) {
-      throw new Error('Bids are not sorted descending');
-    }
-  }
-  // Asks should be ascending
-  for (let i = 1; i < orderbook.asks.length; i++) {
-    if (orderbook.asks[i].price < orderbook.asks[i - 1].price) {
-      throw new Error('Asks are not sorted ascending');
-    }
-  }
-}
-
-// ===== Time Helpers =====
-
-export async function waitFor(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}