@catalyst-team/poly-sdk 0.1.0

package/scripts/verify/verify-all-apis.ts

@@ -0,0 +1,160 @@
+/**
+ * Verify all Polymarket API responses against SDK type definitions
+ *
+ * Run: pnpm -F @prediction-router/poly-sdk tsx scripts/verify-all-apis.ts
+ */
+
+const DATA_API = 'https://data-api.polymarket.com';
+const GAMMA_API = 'https://gamma-api.polymarket.com';
+const CLOB_API = 'https://clob.polymarket.com';
+
+// Known active wallet for testing
+const TEST_WALLET = '0x1c579085b4dcdf00f0ce6f2d8c1d402fec0f1632';
+
+interface FieldAnalysis {
+  field: string;
+  type: string;
+  sample: unknown;
+  isNull: boolean;
+}
+
+function analyzeFields(obj: Record<string, unknown>, prefix = ''): FieldAnalysis[] {
+  const results: FieldAnalysis[] = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fieldPath = prefix ? `${prefix}.${key}` : key;
+    const type = value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+    results.push({
+      field: fieldPath,
+      type,
+      sample: type === 'object' ? '[object]' : type === 'array' ? `[${(value as unknown[]).length} items]` : value,
+      isNull: value === null,
+    });
+    if (type === 'object' && value !== null) {
+      results.push(...analyzeFields(value as Record<string, unknown>, fieldPath));
+    }
+  }
+  return results;
+}
+
+async function fetchAndAnalyze(name: string, url: string, extractFirst = true) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`API: ${name}`);
+  console.log(`URL: ${url}`);
+  console.log('='.repeat(60));
+
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.log(`ERROR: ${response.status} ${response.statusText}`);
+      return null;
+    }
+
+    const data = await response.json();
+    const sample = extractFirst && Array.isArray(data) ? data[0] : data;
+
+    if (!sample) {
+      console.log('No data returned');
+      return null;
+    }
+
+    console.log('\nRaw Response Sample:');
+    console.log(JSON.stringify(sample, null, 2));
+
+    console.log('\nField Analysis:');
+    const fields = analyzeFields(sample as Record<string, unknown>);
+    for (const f of fields) {
+      const nullMarker = f.isNull ? ' [NULL]' : '';
+      console.log(`  ${f.field}: ${f.type}${nullMarker}`);
+    }
+
+    return sample;
+  } catch (error) {
+    console.log(`ERROR: ${error}`);
+    return null;
+  }
+}
+
+async function main() {
+  console.log('Polymarket API Verification Script');
+  console.log('===================================\n');
+
+  // ===== DATA API =====
+  console.log('\n' + '#'.repeat(60));
+  console.log('# DATA API');
+  console.log('#'.repeat(60));
+
+  // Positions
+  await fetchAndAnalyze(
+    'Positions',
+    `${DATA_API}/positions?user=${TEST_WALLET}`
+  );
+
+  // Activity
+  await fetchAndAnalyze(
+    'Activity',
+    `${DATA_API}/activity?user=${TEST_WALLET}&limit=1`
+  );
+
+  // Trades
+  await fetchAndAnalyze(
+    'Trades',
+    `${DATA_API}/trades?limit=1`
+  );
+
+  // Leaderboard
+  await fetchAndAnalyze(
+    'Leaderboard',
+    `${DATA_API}/v1/leaderboard?limit=1`
+  );
+
+  // ===== GAMMA API =====
+  console.log('\n' + '#'.repeat(60));
+  console.log('# GAMMA API');
+  console.log('#'.repeat(60));
+
+  // Markets
+  const market = await fetchAndAnalyze(
+    'Markets',
+    `${GAMMA_API}/markets?active=true&limit=1`
+  );
+
+  // Events
+  await fetchAndAnalyze(
+    'Events',
+    `${GAMMA_API}/events?active=true&limit=1`
+  );
+
+  // ===== CLOB API =====
+  console.log('\n' + '#'.repeat(60));
+  console.log('# CLOB API');
+  console.log('#'.repeat(60));
+
+  // Get a conditionId from gamma market
+  const conditionId = (market as Record<string, unknown>)?.conditionId;
+  if (conditionId) {
+    // Market
+    const clobMarket = await fetchAndAnalyze(
+      'CLOB Market',
+      `${CLOB_API}/markets/${conditionId}`,
+      false
+    );
+
+    // Orderbook
+    const tokens = (clobMarket as Record<string, unknown>)?.tokens as Array<{ token_id: string }>;
+    if (tokens?.[0]) {
+      await fetchAndAnalyze(
+        'Orderbook',
+        `${CLOB_API}/book?token_id=${tokens[0].token_id}`,
+        false
+      );
+    }
+  }
+
+  // ===== SUMMARY =====
+  console.log('\n' + '#'.repeat(60));
+  console.log('# VERIFICATION COMPLETE');
+  console.log('#'.repeat(60));
+  console.log('\nReview the output above to compare with SDK type definitions.');
+}
+
+main().catch(console.error);

package/scripts/wallet/check-wallet-balances.ts

@@ -0,0 +1,75 @@
+/**
+ * Check Wallet Balances Script
+ *
+ * Query token balances for any wallet address on Polygon.
+ * No private key required - just provide an address.
+ *
+ * Usage:
+ *   npx tsx scripts/check-wallet-balances.ts <address>
+ *   npx tsx scripts/check-wallet-balances.ts 0xc2e7800b5af46e6093872b177b7a5e7f0563be51
+ */
+
+import { SwapService, POLYGON_TOKENS } from '../src/index.js';
+
+const TEST_ADDRESS = '0xc2e7800b5af46e6093872b177b7a5e7f0563be51'; // Top Polymarket trader
+
+async function main() {
+  const address = process.argv[2] || TEST_ADDRESS;
+
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║          POLYGON WALLET BALANCE CHECKER                     ║');
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log('');
+  console.log(`Wallet: ${address}`);
+  console.log('');
+
+  console.log('Fetching balances...');
+  console.log('');
+
+  try {
+    const balances = await SwapService.getWalletBalances(address);
+
+    console.log('─── Token Balances ───');
+    console.log('');
+
+    for (const b of balances) {
+      const amount = parseFloat(b.balance);
+      if (amount > 0) {
+        console.log(`  ${b.symbol.padEnd(10)} ${b.balance}`);
+      }
+    }
+
+    // Show zero balances
+    const zeroBalances = balances.filter((b) => parseFloat(b.balance) === 0);
+    if (zeroBalances.length > 0) {
+      console.log('');
+      console.log(`  (Zero balance: ${zeroBalances.map((b) => b.symbol).join(', ')})`);
+    }
+
+    // Summary
+    console.log('');
+    console.log('─── Summary ───');
+    const nonZero = balances.filter((b) => parseFloat(b.balance) > 0);
+    console.log(`  Tokens with balance: ${nonZero.length}`);
+
+    // Calculate stablecoin value
+    let stablecoinValue = 0;
+    for (const b of balances) {
+      if (['USDC', 'USDC_E', 'USDT', 'DAI'].includes(b.token)) {
+        stablecoinValue += parseFloat(b.balance);
+      }
+    }
+    console.log(`  Stablecoin value: $${stablecoinValue.toFixed(2)}`);
+
+    console.log('');
+    console.log('─── Supported Tokens ───');
+    console.log(`  ${Object.keys(POLYGON_TOKENS).join(', ')}`);
+
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  console.log('');
+}
+
+main().catch(console.error);

package/scripts/wallet/test-wallet-operations.ts

@@ -0,0 +1,191 @@
+/**
+ * Test Wallet Operations
+ *
+ * Comprehensive test for all wallet-related operations that require a private key:
+ * - Token balances
+ * - Allowance checking
+ * - Token approvals
+ * - Swap operations (dry run)
+ *
+ * Usage:
+ *   POLY_PRIVATE_KEY=0x... npx tsx scripts/test-wallet-operations.ts
+ *   Or set PRIVATE_KEY in .env file
+ */
+
+import { ethers } from 'ethers';
+import dotenv from 'dotenv';
+import {
+  SwapService,
+  AuthorizationService,
+  POLYGON_TOKENS,
+} from '../src/index.js';
+
+dotenv.config();
+
+const PRIVATE_KEY = process.env.POLY_PRIVATE_KEY || process.env.PRIVATE_KEY;
+
+if (!PRIVATE_KEY) {
+  console.error('❌ Error: No private key found.');
+  console.error('   Set POLY_PRIVATE_KEY or PRIVATE_KEY in environment or .env file');
+  process.exit(1);
+}
+
+const POLYGON_RPC = 'https://polygon-rpc.com';
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║           POLY-SDK WALLET OPERATIONS TEST                  ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  // Initialize
+  const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
+  const signer = new ethers.Wallet(PRIVATE_KEY, provider);
+
+  console.log(`Wallet Address: ${signer.address}`);
+  console.log(`Network: Polygon Mainnet (${POLYGON_RPC})`);
+  console.log('');
+
+  // Test 1: Get native MATIC balance
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('Test 1: Native MATIC Balance');
+  console.log('═══════════════════════════════════════════════════════════');
+  try {
+    const maticBalance = await provider.getBalance(signer.address);
+    const maticFormatted = ethers.utils.formatEther(maticBalance);
+    console.log(`  MATIC Balance: ${maticFormatted} MATIC`);
+
+    if (parseFloat(maticFormatted) < 0.01) {
+      console.log('  ⚠️  Warning: Low MATIC balance. Need MATIC for gas fees.');
+    } else {
+      console.log('  ✅ Sufficient MATIC for gas');
+    }
+  } catch (err) {
+    console.log(`  ❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  // Test 2: Get all token balances using SwapService
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('Test 2: Token Balances (SwapService.getBalances)');
+  console.log('═══════════════════════════════════════════════════════════');
+  try {
+    const swapService = new SwapService(signer);
+    const balances = await swapService.getBalances();
+
+    console.log('  Token Balances:');
+    for (const b of balances) {
+      const amount = parseFloat(b.balance);
+      const status = amount > 0 ? '✅' : '  ';
+      console.log(`    ${status} ${b.symbol.padEnd(8)} ${b.balance}`);
+    }
+
+    // Calculate total stablecoin value
+    let stablecoinValue = 0;
+    for (const b of balances) {
+      if (['USDC', 'USDC_E', 'USDT', 'DAI'].includes(b.token)) {
+        stablecoinValue += parseFloat(b.balance);
+      }
+    }
+    console.log(`\n  Total Stablecoin Value: $${stablecoinValue.toFixed(2)}`);
+  } catch (err) {
+    console.log(`  ❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  // Test 3: Check allowances using AuthorizationService
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('Test 3: Trading Allowances (AuthorizationService)');
+  console.log('═══════════════════════════════════════════════════════════');
+  try {
+    const authService = new AuthorizationService(signer);
+    const result = await authService.checkAllowances();
+
+    console.log(`  Wallet: ${result.wallet}`);
+    console.log(`  USDC Balance: ${result.usdcBalance}`);
+    console.log(`  Trading Ready: ${result.tradingReady ? '✅ Yes' : '❌ No'}`);
+
+    console.log('\n  ERC20 Allowances:');
+    for (const allowance of result.erc20Allowances) {
+      const status = allowance.approved ? '✅' : '❌';
+      console.log(`    ${status} ${allowance.contract}: ${allowance.allowance}`);
+    }
+
+    console.log('\n  ERC1155 Approvals:');
+    for (const approval of result.erc1155Approvals) {
+      const status = approval.approved ? '✅' : '❌';
+      console.log(`    ${status} ${approval.contract}`);
+    }
+
+    if (result.issues.length > 0) {
+      console.log('\n  Issues:');
+      for (const issue of result.issues) {
+        console.log(`    ⚠️  ${issue}`);
+      }
+    }
+  } catch (err) {
+    console.log(`  ❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  // Test 4: Swap Quote (without executing)
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('Test 4: Swap Service (Quote Only - No Execution)');
+  console.log('═══════════════════════════════════════════════════════════');
+  try {
+    const swapService = new SwapService(signer);
+
+    // Check if we have any tokens to get a quote for
+    const balances = await swapService.getBalances();
+    const maticBalance = balances.find((b) => b.token === 'MATIC');
+    const usdcBalance = balances.find((b) => b.token === 'USDC');
+
+    if (maticBalance && parseFloat(maticBalance.balance) > 1) {
+      console.log('  Checking swap quote: 1 MATIC -> USDC');
+      // Note: We're not executing, just confirming the service initializes correctly
+      console.log('  ✅ SwapService initialized successfully');
+      console.log(`  Router: ${POLYGON_TOKENS.WMATIC} (WMATIC)`);
+      console.log(`  Can swap: MATIC, WMATIC, USDC, USDC_E, USDT, DAI, WETH`);
+    } else {
+      console.log('  ℹ️  Insufficient MATIC balance for swap test');
+      console.log('  ✅ SwapService initialized successfully');
+    }
+  } catch (err) {
+    console.log(`  ❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  // Test 5: Static wallet query (no signer needed)
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('Test 5: Static Wallet Query (Any Address)');
+  console.log('═══════════════════════════════════════════════════════════');
+  try {
+    // Query a known top trader
+    const topTrader = '0xc2e7800b5af46e6093872b177b7a5e7f0563be51';
+    console.log(`  Querying wallet: ${topTrader}`);
+
+    const balances = await SwapService.getWalletBalances(topTrader);
+    const nonZero = balances.filter((b) => parseFloat(b.balance) > 0);
+
+    console.log('  Balances:');
+    for (const b of nonZero) {
+      console.log(`    ${b.symbol.padEnd(8)} ${parseFloat(b.balance).toLocaleString()}`);
+    }
+    console.log('  ✅ Static query works without signer');
+  } catch (err) {
+    console.log(`  ❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+
+  // Summary
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('SUMMARY');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log(`
+  ✅ Token balance queries work
+  ✅ Allowance checking works
+  ✅ SwapService initializes correctly
+  ✅ Static wallet queries work
+
+  To test actual transactions:
+  - Use approve-trading if allowances are missing
+  - Use swap if you want to exchange tokens
+  - Use deposit if you want to deposit to Polymarket
+  `);
+}
+
+main().catch(console.error);

package/scripts/wallet/verify-wallet-tools.ts

@@ -0,0 +1,124 @@
+/**
+ * Verify Wallet Tools Implementation
+ *
+ * This script tests the wallet-related SDK and MCP tools:
+ * 1. BridgeClient.getSupportedAssets() - Get supported deposit assets
+ * 2. BridgeClient.createDepositAddresses() - Get deposit addresses
+ * 3. AuthorizationService.checkAllowances() - Check allowances
+ *
+ * Usage:
+ *   npx tsx scripts/verify-wallet-tools.ts
+ *   POLY_PRIVKEY=0x... npx tsx scripts/verify-wallet-tools.ts
+ */
+
+import { Wallet, providers } from 'ethers';
+import { BridgeClient, AuthorizationService } from '../src/index.js';
+
+const PRIVATE_KEY = process.env.POLY_PRIVKEY || process.env.POLY_PRIVATE_KEY;
+const RPC_URL = 'https://polygon-rpc.com';
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║          WALLET TOOLS VERIFICATION                          ║');
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  // Test 1: Get Supported Assets
+  console.log('─── Test 1: BridgeClient.getSupportedAssets() ───');
+  try {
+    const bridge = new BridgeClient();
+    const assets = await bridge.getSupportedAssets();
+    console.log(`✅ Found ${assets.length} supported assets`);
+
+    // Group by chain
+    const chains = new Set<string>();
+    for (const asset of assets) {
+      chains.add(asset.chainName);
+    }
+    console.log(`   Chains: ${Array.from(chains).join(', ')}`);
+
+    // Show first 3 assets as sample
+    console.log('   Sample assets:');
+    for (const asset of assets.slice(0, 3)) {
+      console.log(`   - ${asset.chainName} ${asset.tokenSymbol}: min $${asset.minDepositUsd}`);
+    }
+  } catch (err) {
+    console.log(`❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+  console.log('');
+
+  // Test 2: Get Deposit Addresses (requires address, not private key)
+  console.log('─── Test 2: BridgeClient.createDepositAddresses() ───');
+  try {
+    const bridge = new BridgeClient();
+    // Use a test address
+    const testAddress = '0xc2e7800b5af46e6093872b177b7a5e7f0563be51';
+    const result = await bridge.createDepositAddresses(testAddress);
+    console.log(`✅ Got deposit addresses for ${testAddress.slice(0, 10)}...`);
+    console.log(`   EVM: ${result.address.evm.slice(0, 20)}...`);
+    console.log(`   Solana: ${result.address.svm.slice(0, 20)}...`);
+    console.log(`   Bitcoin: ${result.address.btc.slice(0, 20)}...`);
+  } catch (err) {
+    console.log(`❌ Error: ${err instanceof Error ? err.message : err}`);
+  }
+  console.log('');
+
+  // Test 3: Check Allowances (requires private key)
+  console.log('─── Test 3: AuthorizationService.checkAllowances() ───');
+  if (!PRIVATE_KEY) {
+    console.log('⚠️  Skipped: Set POLY_PRIVKEY to test allowance checking');
+  } else {
+    try {
+      const provider = new providers.JsonRpcProvider(RPC_URL);
+      const wallet = new Wallet(PRIVATE_KEY, provider);
+      console.log(`   Wallet: ${wallet.address}`);
+
+      const authService = new AuthorizationService(wallet);
+      const result = await authService.checkAllowances();
+
+      console.log(`✅ Allowance check completed`);
+      console.log(`   USDC Balance: ${result.usdcBalance}`);
+      console.log(`   Trading Ready: ${result.tradingReady ? '✅ Yes' : '❌ No'}`);
+
+      if (result.issues.length > 0) {
+        console.log('   Issues:');
+        for (const issue of result.issues) {
+          console.log(`   - ${issue}`);
+        }
+      }
+
+      console.log('   ERC20 Allowances:');
+      for (const a of result.erc20Allowances) {
+        console.log(`   - ${a.contract}: ${a.approved ? '✅' : '❌'} (${a.allowance || 'N/A'})`);
+      }
+
+      console.log('   ERC1155 Approvals:');
+      for (const a of result.erc1155Approvals) {
+        console.log(`   - ${a.contract}: ${a.approved ? '✅' : '❌'}`);
+      }
+    } catch (err) {
+      console.log(`❌ Error: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  console.log('');
+
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('Verification complete.');
+  console.log('');
+  console.log('Architecture:');
+  console.log('  SDK Layer:');
+  console.log('    - BridgeClient.getSupportedAssets()');
+  console.log('    - BridgeClient.createDepositAddresses()');
+  console.log('    - depositUsdc() function');
+  console.log('    - AuthorizationService.checkAllowances()');
+  console.log('    - AuthorizationService.approveAll()');
+  console.log('');
+  console.log('  MCP Tools (call SDK):');
+  console.log('    - get_supported_deposit_assets → BridgeClient');
+  console.log('    - get_deposit_addresses → BridgeClient');
+  console.log('    - deposit_usdc → depositUsdc()');
+  console.log('    - check_allowances → AuthorizationService');
+  console.log('    - approve_trading → AuthorizationService');
+}
+
+main().catch(console.error);