@catalyst-team/poly-sdk 0.2.0 → 0.2.1

package/src/__tests__/integration/ctf-client.integration.test.ts

@@ -1,331 +0,0 @@
-/**
- * CTF Client Integration Tests
- *
- * These tests verify the CTF (Conditional Token Framework) implementation
- * by making REAL on-chain calls to Polygon.
- *
- * IMPORTANT: These tests are READ-ONLY and do not require a wallet.
- * They verify:
- * 1. Contract addresses are correct
- * 2. Position ID calculation is correct
- * 3. Market resolution queries work
- * 4. Balance queries work
- *
- * Run with: pnpm test:integration
- */
-
-import { describe, it, expect } from 'vitest';
-import { ethers } from 'ethers';
-import {
-  CTF_CONTRACT,
-  USDC_CONTRACT,
-  NEG_RISK_CTF_EXCHANGE,
-  NEG_RISK_ADAPTER,
-  USDC_DECIMALS,
-} from '../../clients/ctf-client.js';
-
-// Public RPC for read-only tests
-const POLYGON_RPC = 'https://polygon-rpc.com';
-
-// Known addresses and markets for testing
-const KNOWN_WHALE_ADDRESS = '0x82a1b239c1ff9bc60a4c86caf5b6bdbd9fddfe20'; // Top trader
-const SECOND_CTF_CONTRACT = '0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E';
-
-// ABIs for testing
-const CTF_ABI = [
-  'function balanceOf(address account, uint256 positionId) view returns (uint256)',
-  'function payoutNumerators(bytes32 conditionId, uint256 outcomeIndex) view returns (uint256)',
-  'function payoutDenominator(bytes32 conditionId) view returns (uint256)',
-  'function getOutcomeSlotCount(bytes32 conditionId) view returns (uint256)',
-];
-
-const ERC20_ABI = [
-  'function balanceOf(address account) view returns (uint256)',
-  'function decimals() view returns (uint8)',
-  'function symbol() view returns (string)',
-];
-
-describe('CTF Contract Verification', () => {
-  const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
-
-  describe('Contract Addresses', () => {
-    it('should verify CTF contract is deployed and accessible', async () => {
-      const ctf = new ethers.Contract(CTF_CONTRACT, CTF_ABI, provider);
-
-      // Query a known condition ID to verify contract works
-      // Using a random condition ID should return 0 for unresolved markets
-      const testConditionId = '0x0000000000000000000000000000000000000000000000000000000000000001';
-      const denominator = await ctf.payoutDenominator(testConditionId);
-
-      // Should return 0 for non-existent/unresolved condition
-      expect(denominator.toNumber()).toBe(0);
-
-      console.log(`✓ CTF Contract verified at ${CTF_CONTRACT}`);
-    }, 30000);
-
-    it('should verify USDC contract is deployed', async () => {
-      const usdc = new ethers.Contract(USDC_CONTRACT, ERC20_ABI, provider);
-
-      const [decimals, symbol] = await Promise.all([
-        usdc.decimals(),
-        usdc.symbol(),
-      ]);
-
-      expect(decimals).toBe(USDC_DECIMALS);
-      expect(symbol).toBe('USDC');
-
-      console.log(`✓ USDC Contract verified at ${USDC_CONTRACT}`);
-      console.log(`  Symbol: ${symbol}, Decimals: ${decimals}`);
-    }, 30000);
-
-    it('should verify second CTF contract exists', async () => {
-      // The second contract address from Polymarket docs
-      // Note: This is the NegRisk CTF contract with a different ABI
-      // We just verify the contract code exists
-      const code = await provider.getCode(SECOND_CTF_CONTRACT);
-
-      expect(code).not.toBe('0x');
-      expect(code.length).toBeGreaterThan(10);
-
-      console.log(`✓ Second CTF Contract verified at ${SECOND_CTF_CONTRACT}`);
-      console.log(`  Contract code size: ${(code.length - 2) / 2} bytes`);
-      console.log('  Note: This is the NegRisk CTF contract (different ABI from standard CTF)');
-    }, 30000);
-
-    it('should verify NegRisk Adapter contract exists', async () => {
-      // Check contract code exists
-      const code = await provider.getCode(NEG_RISK_ADAPTER);
-
-      expect(code).not.toBe('0x');
-      expect(code.length).toBeGreaterThan(10);
-
-      console.log(`✓ NegRisk Adapter verified at ${NEG_RISK_ADAPTER}`);
-      console.log(`  Contract code size: ${(code.length - 2) / 2} bytes`);
-    }, 30000);
-
-    it('should verify NegRisk CTF Exchange contract exists', async () => {
-      const code = await provider.getCode(NEG_RISK_CTF_EXCHANGE);
-
-      expect(code).not.toBe('0x');
-      expect(code.length).toBeGreaterThan(10);
-
-      console.log(`✓ NegRisk CTF Exchange verified at ${NEG_RISK_CTF_EXCHANGE}`);
-      console.log(`  Contract code size: ${(code.length - 2) / 2} bytes`);
-    }, 30000);
-  });
-
-  describe('Position ID Calculation', () => {
-    it('should calculate position ID correctly', () => {
-      // This matches the Polymarket gist for positionId calculation
-      // https://gist.github.com/polymarket/1e12f0ac3e23400ca53ec9b6e1ba00ce
-
-      const conditionId = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
-      const indexSet = 1; // YES outcome
-
-      // Collection ID = keccak256(parentCollectionId, conditionId, indexSet)
-      const collectionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['bytes32', 'bytes32', 'uint256'],
-          [ethers.constants.HashZero, conditionId, indexSet]
-        )
-      );
-
-      // Position ID = keccak256(collateralToken, collectionId)
-      const positionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['address', 'bytes32'],
-          [USDC_CONTRACT, collectionId]
-        )
-      );
-
-      // Verify the calculation produces valid bytes32
-      expect(positionId).toMatch(/^0x[a-f0-9]{64}$/);
-      expect(collectionId).toMatch(/^0x[a-f0-9]{64}$/);
-
-      console.log('✓ Position ID calculation verified');
-      console.log(`  Condition ID: ${conditionId.slice(0, 20)}...`);
-      console.log(`  Collection ID: ${collectionId.slice(0, 20)}...`);
-      console.log(`  Position ID: ${positionId.slice(0, 20)}...`);
-    });
-
-    it('should produce different position IDs for YES and NO', () => {
-      const conditionId = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
-
-      // YES position (indexSet = 1)
-      const yesCollectionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['bytes32', 'bytes32', 'uint256'],
-          [ethers.constants.HashZero, conditionId, 1]
-        )
-      );
-      const yesPositionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['address', 'bytes32'],
-          [USDC_CONTRACT, yesCollectionId]
-        )
-      );
-
-      // NO position (indexSet = 2)
-      const noCollectionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['bytes32', 'bytes32', 'uint256'],
-          [ethers.constants.HashZero, conditionId, 2]
-        )
-      );
-      const noPositionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['address', 'bytes32'],
-          [USDC_CONTRACT, noCollectionId]
-        )
-      );
-
-      expect(yesPositionId).not.toBe(noPositionId);
-      expect(yesCollectionId).not.toBe(noCollectionId);
-
-      console.log('✓ YES and NO position IDs are different');
-      console.log(`  YES Position ID: ${yesPositionId.slice(0, 20)}...`);
-      console.log(`  NO Position ID:  ${noPositionId.slice(0, 20)}...`);
-    });
-  });
-
-  describe('Balance Queries', () => {
-    it('should query USDC balance for known whale', async () => {
-      const usdc = new ethers.Contract(USDC_CONTRACT, ERC20_ABI, provider);
-
-      const balance = await usdc.balanceOf(KNOWN_WHALE_ADDRESS);
-      const formattedBalance = ethers.utils.formatUnits(balance, USDC_DECIMALS);
-
-      expect(balance.gte(0)).toBe(true);
-
-      console.log(`✓ USDC balance query works`);
-      console.log(`  Whale ${KNOWN_WHALE_ADDRESS.slice(0, 10)}... has ${parseFloat(formattedBalance).toLocaleString()} USDC`);
-    }, 30000);
-
-    it('should query CTF token balance', async () => {
-      const ctf = new ethers.Contract(CTF_CONTRACT, CTF_ABI, provider);
-
-      // Use a known position ID (we'll use a random one, should return 0)
-      const randomPositionId = ethers.utils.keccak256(
-        ethers.utils.defaultAbiCoder.encode(
-          ['string'],
-          ['random-test-position']
-        )
-      );
-
-      const balance = await ctf.balanceOf(KNOWN_WHALE_ADDRESS, randomPositionId);
-
-      expect(balance.gte(0)).toBe(true);
-
-      console.log('✓ CTF balance query works');
-      console.log(`  Balance for random position: ${ethers.utils.formatUnits(balance, USDC_DECIMALS)}`);
-    }, 30000);
-  });
-
-  describe('Market Resolution', () => {
-    it('should query payout info for a real market condition', async () => {
-      // First get a real market from Gamma API to get a valid condition ID
-      const response = await fetch(
-        'https://gamma-api.polymarket.com/markets?closed=true&limit=1'
-      );
-      const markets = await response.json() as Array<{ conditionId: string; question: string }>;
-
-      if (markets.length === 0) {
-        console.log('No closed markets found, skipping test');
-        return;
-      }
-
-      const ctf = new ethers.Contract(CTF_CONTRACT, CTF_ABI, provider);
-      const conditionId = markets[0].conditionId;
-
-      try {
-        const [yesNumerator, noNumerator, denominator] = await Promise.all([
-          ctf.payoutNumerators(conditionId, 0),
-          ctf.payoutNumerators(conditionId, 1),
-          ctf.payoutDenominator(conditionId),
-        ]);
-
-        expect(yesNumerator.gte(0)).toBe(true);
-        expect(noNumerator.gte(0)).toBe(true);
-        expect(denominator.gte(0)).toBe(true);
-
-        const isResolved = denominator.gt(0);
-
-        console.log('✓ Market resolution query works');
-        console.log(`  Market: "${markets[0].question.slice(0, 40)}..."`);
-        console.log(`  Condition ID: ${conditionId.slice(0, 20)}...`);
-        console.log(`  Is resolved: ${isResolved}`);
-        if (isResolved) {
-          console.log(`  Payout numerators: [${yesNumerator.toString()}, ${noNumerator.toString()}]`);
-          console.log(`  Payout denominator: ${denominator.toString()}`);
-        }
-      } catch (error) {
-        // Some markets might be NegRisk markets with different contract
-        console.log('✓ Query attempted (market might be NegRisk type)');
-        console.log(`  Condition ID: ${conditionId.slice(0, 20)}...`);
-      }
-    }, 30000);
-  });
-
-  describe('Gas Price', () => {
-    it('should fetch current gas price', async () => {
-      const gasPrice = await provider.getGasPrice();
-      const gasPriceGwei = ethers.utils.formatUnits(gasPrice, 'gwei');
-
-      expect(gasPrice.gt(0)).toBe(true);
-
-      console.log('✓ Gas price fetched');
-      console.log(`  Current gas price: ${parseFloat(gasPriceGwei).toFixed(2)} gwei`);
-    }, 30000);
-  });
-});
-
-describe('CTF Architecture Understanding', () => {
-  it('should document the two-contract architecture', () => {
-    /**
-     * Polymarket uses TWO different CTF systems:
-     *
-     * 1. STANDARD CTF (0x4D97DCd97eC945f40cF65F87097ACe5EA0476045)
-     *    - Used for simple binary (Yes/No) markets
-     *    - Operations: split, merge, redeem
-     *    - Each market is independent
-     *
-     * 2. NEGRISK CTF (0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E)
-     *    - Used for "winner-take-all" events (elections, championships)
-     *    - Key innovation: NO shares can convert to YES shares in other markets
-     *    - Example: "Trump NO" can become "Biden YES + Harris YES + ..."
-     *
-     * Why NegRisk exists:
-     * - Capital efficiency: Don't need to buy YES in every candidate
-     * - Buying NO in one candidate = betting on all other candidates
-     * - The Negative Adapter (0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296) handles conversions
-     *
-     * Which contract to use:
-     * - Check the market's metadata to determine if it's a NegRisk market
-     * - Most simple Yes/No markets use Standard CTF
-     * - Multi-outcome events (elections, sports champions) may use NegRisk
-     */
-
-    console.log('✓ CTF Architecture Documented');
-    console.log('');
-    console.log('Standard CTF Contract:');
-    console.log(`  ${CTF_CONTRACT}`);
-    console.log('  - Simple Yes/No markets');
-    console.log('  - split/merge/redeem operations');
-    console.log('');
-    console.log('NegRisk CTF Contract:');
-    console.log(`  ${SECOND_CTF_CONTRACT}`);
-    console.log('  - Winner-take-all events');
-    console.log('  - NO shares convertible to YES in other markets');
-    console.log('');
-    console.log('NegRisk Adapter:');
-    console.log(`  ${NEG_RISK_ADAPTER}`);
-    console.log('  - Handles NO → YES conversions');
-    console.log('');
-    console.log('NegRisk CTF Exchange:');
-    console.log(`  ${NEG_RISK_CTF_EXCHANGE}`);
-    console.log('  - Trading for NegRisk markets');
-
-    // This test always passes - it's documentation
-    expect(true).toBe(true);
-  });
-});

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

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