@catalyst-team/poly-sdk 0.1.0

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

@@ -0,0 +1,194 @@
+/**
+ * Data 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 { DataApiClient } from '../../clients/data-api.js';
+import { RateLimiter } from '../../core/rate-limiter.js';
+import { createUnifiedCache } from '../../core/unified-cache.js';
+
+describe('DataApiClient Integration', () => {
+  let client: DataApiClient;
+
+  beforeAll(() => {
+    client = new DataApiClient(new RateLimiter(), createUnifiedCache());
+  });
+
+  describe('getLeaderboard', () => {
+    it('should fetch leaderboard entries', async () => {
+      const leaderboard = await client.getLeaderboard({ limit: 10 });
+
+      expect(Array.isArray(leaderboard.entries)).toBe(true);
+      expect(leaderboard.entries.length).toBeGreaterThan(0);
+      expect(leaderboard.entries.length).toBeLessThanOrEqual(10);
+
+      // Verify entry structure
+      for (const entry of leaderboard.entries) {
+        expect(typeof entry.address).toBe('string');
+        expect(entry.address.length).toBeGreaterThan(0);
+        expect(typeof entry.rank).toBe('number');
+        expect(entry.rank).toBeGreaterThan(0);
+        expect(typeof entry.pnl).toBe('number');
+        expect(typeof entry.volume).toBe('number');
+      }
+
+      // Verify ranks are in order
+      for (let i = 1; i < leaderboard.entries.length; i++) {
+        expect(leaderboard.entries[i].rank).toBeGreaterThan(leaderboard.entries[i - 1].rank);
+      }
+
+      console.log(`✓ Leaderboard fetched: ${leaderboard.entries.length} entries`);
+      console.log(`  #1: ${leaderboard.entries[0].address.slice(0, 10)}... PnL: $${leaderboard.entries[0].pnl.toLocaleString()}`);
+    }, 30000);
+
+    it('should handle pagination', async () => {
+      const page1 = await client.getLeaderboard({ limit: 5, offset: 0 });
+      const page2 = await client.getLeaderboard({ limit: 5, offset: 5 });
+
+      // Ranks should be continuous
+      if (page1.entries.length > 0 && page2.entries.length > 0) {
+        const lastRankPage1 = page1.entries[page1.entries.length - 1].rank;
+        const firstRankPage2 = page2.entries[0].rank;
+        expect(firstRankPage2).toBe(lastRankPage1 + 1);
+      }
+
+      console.log('✓ Pagination verified');
+    }, 30000);
+  });
+
+  describe('getTrades', () => {
+    it('should fetch recent trades', async () => {
+      const trades = await client.getTrades({ limit: 20 });
+
+      expect(Array.isArray(trades)).toBe(true);
+
+      if (trades.length > 0) {
+        // Verify trade structure
+        for (const trade of trades) {
+          expect(typeof trade.id).toBe('string');
+          expect(['BUY', 'SELL']).toContain(trade.side);
+          expect(typeof trade.price).toBe('number');
+          expect(trade.price).toBeGreaterThanOrEqual(0);
+          expect(trade.price).toBeLessThanOrEqual(1);
+          expect(typeof trade.size).toBe('number');
+          expect(trade.size).toBeGreaterThan(0);
+          expect(typeof trade.timestamp).toBe('number');
+        }
+
+        console.log(`✓ Fetched ${trades.length} recent trades`);
+        console.log(`  Latest: ${trades[0].side} ${trades[0].size} @ ${trades[0].price}`);
+      } else {
+        console.log('✓ No recent trades found (this is ok)');
+      }
+    }, 30000);
+
+    it('should fetch trades for specific market', async () => {
+      // Get a trending market first
+      const response = await fetch(
+        'https://gamma-api.polymarket.com/markets?active=true&limit=1&order=volume24hr&ascending=false'
+      );
+      const markets = await response.json() as Array<{ conditionId: string }>;
+
+      if (markets.length === 0) {
+        console.log('No markets found, skipping test');
+        return;
+      }
+
+      const trades = await client.getTradesByMarket(markets[0].conditionId, 10);
+
+      expect(Array.isArray(trades)).toBe(true);
+
+      // All trades should be for this market
+      for (const trade of trades) {
+        expect(trade.market).toBe(markets[0].conditionId);
+      }
+
+      console.log(`✓ Fetched ${trades.length} trades for specific market`);
+    }, 30000);
+  });
+
+  describe('getPositions', () => {
+    it('should fetch positions for a known active wallet', async () => {
+      // Get top trader from leaderboard
+      const leaderboard = await client.getLeaderboard({ limit: 1 });
+
+      if (leaderboard.entries.length === 0) {
+        console.log('No leaderboard entries, skipping test');
+        return;
+      }
+
+      const address = leaderboard.entries[0].address;
+      const positions = await client.getPositions(address);
+
+      expect(Array.isArray(positions)).toBe(true);
+
+      if (positions.length > 0) {
+        // Verify position structure
+        for (const pos of positions) {
+          expect(typeof pos.asset).toBe('string');
+          expect(typeof pos.conditionId).toBe('string');
+          // Polymarket has multi-outcome markets, not just Yes/No
+          expect(typeof pos.outcome).toBe('string');
+          expect(pos.outcome.length).toBeGreaterThan(0);
+          expect(typeof pos.size).toBe('number');
+          expect(typeof pos.avgPrice).toBe('number');
+          expect(typeof pos.title).toBe('string');
+        }
+
+        console.log(`✓ Fetched ${positions.length} positions for ${address.slice(0, 10)}...`);
+      } else {
+        console.log(`✓ Top trader has no current positions (this is ok)`);
+      }
+    }, 30000);
+
+    it('should return empty array for wallet with no positions', async () => {
+      // Use a random address that probably has no positions
+      const positions = await client.getPositions('0x0000000000000000000000000000000000000001');
+
+      expect(Array.isArray(positions)).toBe(true);
+      // Might be empty or have some positions, both are valid
+      console.log(`✓ Returned ${positions.length} positions for test address`);
+    }, 30000);
+  });
+
+  describe('getActivity', () => {
+    it('should fetch activity for an active wallet', async () => {
+      // Get top trader
+      const leaderboard = await client.getLeaderboard({ limit: 1 });
+
+      if (leaderboard.entries.length === 0) {
+        console.log('No leaderboard entries, skipping test');
+        return;
+      }
+
+      const address = leaderboard.entries[0].address;
+      const activity = await client.getActivity(address, { limit: 20 });
+
+      expect(Array.isArray(activity)).toBe(true);
+
+      if (activity.length > 0) {
+        // Verify activity structure
+        for (const act of activity) {
+          // Polymarket has various activity types including YIELD for rewards
+          expect(['TRADE', 'SPLIT', 'MERGE', 'REDEEM', 'CONVERSION', 'YIELD']).toContain(act.type);
+          // Side might be null for non-trade activities
+          if (act.type === 'TRADE') {
+            expect(['BUY', 'SELL']).toContain(act.side);
+          }
+          expect(typeof act.size).toBe('number');
+          expect(typeof act.price).toBe('number');
+          expect(typeof act.timestamp).toBe('number');
+          expect(act.timestamp).toBeGreaterThan(0);
+        }
+
+        console.log(`✓ Fetched ${activity.length} activities for ${address.slice(0, 10)}...`);
+      } else {
+        console.log('✓ No recent activity found (this is ok)');
+      }
+    }, 30000);
+  });
+});

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

@@ -0,0 +1,206 @@
+/**
+ * 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

@@ -0,0 +1,170 @@
+/**
+ * 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));
+}