@catalyst-team/poly-sdk 0.1.0 → 0.2.0

package/src/mcp/tools/wallet.ts

@@ -1,683 +0,0 @@
-/**
- * Wallet Tools - MCP tools for deposits, swaps, and authorization management
- *
- * These tools use SDK services:
- * - BridgeClient for deposit addresses and supported assets
- * - SwapService for DEX swaps on Polygon (QuickSwap V3)
- * - AuthorizationService for allowance checks and approvals
- * - depositUsdc() for executing USDC deposits
- * - swapAndDeposit() for swapping any token to USDC and depositing
- */
-
-import { ethers } from 'ethers';
-import type { PolymarketSDK } from '../../index.js';
-import {
-  BridgeClient,
-  AuthorizationService,
-  depositUsdc,
-  swapAndDeposit,
-  SwapService,
-  getSupportedDepositTokens,
-} from '../../index.js';
-import type { ToolDefinition } from '../types.js';
-import { wrapError, McpToolError, ErrorCode } from '../errors.js';
-
-// Tool definitions
-export const walletToolDefinitions: ToolDefinition[] = [
-  {
-    name: 'get_supported_deposit_assets',
-    description: 'Get all supported assets and chains for deposits to Polymarket',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        chainId: {
-          type: 'number',
-          description: 'Filter by chain ID (optional)',
-        },
-      },
-    },
-  },
-  {
-    name: 'get_deposit_addresses',
-    description: 'Get deposit addresses (EVM, Solana, Bitcoin) for the configured wallet',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'deposit_usdc',
-    description: 'Deposit USDC to Polymarket. Transfers USDC from your wallet to Polymarket via the Bridge.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        amount: {
-          type: 'number',
-          description: 'Amount to deposit in USDC (minimum $2)',
-        },
-        token: {
-          type: 'string',
-          enum: ['NATIVE_USDC', 'USDC_E'],
-          description: 'Which USDC token to deposit (default: NATIVE_USDC)',
-        },
-      },
-      required: ['amount'],
-    },
-  },
-  {
-    name: 'check_allowances',
-    description: 'Check all ERC20 and ERC1155 allowances required for trading',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'approve_trading',
-    description: 'Set up all required ERC20 and ERC1155 approvals for trading on Polymarket',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'swap',
-    description: 'Swap between tokens on Polygon using QuickSwap V3. Supports MATIC, WETH, USDC, USDC.e, USDT, DAI.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        tokenIn: {
-          type: 'string',
-          description: 'Token to swap from (e.g., MATIC, WETH, USDT, DAI, USDC, USDC_E)',
-        },
-        tokenOut: {
-          type: 'string',
-          description: 'Token to swap to (e.g., USDC, USDC_E, WETH)',
-        },
-        amount: {
-          type: 'string',
-          description: 'Amount to swap in token units',
-        },
-        slippage: {
-          type: 'number',
-          description: 'Slippage tolerance in percent (default: 0.5)',
-        },
-      },
-      required: ['tokenIn', 'tokenOut', 'amount'],
-    },
-  },
-  {
-    name: 'swap_and_deposit',
-    description: 'Swap any supported Polygon token to USDC and deposit to Polymarket. Supports MATIC, WETH, USDT, DAI, USDC, USDC.e.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        token: {
-          type: 'string',
-          description: 'Token to deposit (e.g., MATIC, WETH, USDT, DAI, USDC)',
-        },
-        amount: {
-          type: 'string',
-          description: 'Amount to deposit in token units',
-        },
-        slippage: {
-          type: 'number',
-          description: 'Slippage tolerance for swap in percent (default: 0.5)',
-        },
-      },
-      required: ['token', 'amount'],
-    },
-  },
-  {
-    name: 'get_token_balances',
-    description: 'Get balances for all supported tokens on Polygon for the configured wallet (requires private key)',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-  {
-    name: 'get_wallet_balances',
-    description: 'Get Polygon token balances for any wallet address (MATIC, USDC, USDC.e, USDT, DAI, WETH). No private key required.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        address: {
-          type: 'string',
-          description: 'Wallet address to check (0x...)',
-        },
-      },
-      required: ['address'],
-    },
-  },
-  {
-    name: 'get_swap_quote',
-    description: 'Get a swap quote to check if a route is available and estimate output amount. No private key required. Uses QuickSwap V3 Quoter contract.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        tokenIn: {
-          type: 'string',
-          description: 'Token to swap from (e.g., MATIC, WETH, USDT, DAI, USDC, USDC_E)',
-        },
-        tokenOut: {
-          type: 'string',
-          description: 'Token to swap to (e.g., USDC, USDC_E, WETH)',
-        },
-        amount: {
-          type: 'string',
-          description: 'Amount to swap in token units',
-        },
-      },
-      required: ['tokenIn', 'tokenOut', 'amount'],
-    },
-  },
-  {
-    name: 'get_available_pools',
-    description: 'Get all available liquidity pools on QuickSwap V3. Shows which token pairs can be swapped directly.',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-    },
-  },
-];
-
-// Input/Output types
-interface GetSupportedAssetsInput {
-  chainId?: number;
-}
-
-interface DepositUsdcInput {
-  amount: number;
-  token?: 'NATIVE_USDC' | 'USDC_E';
-}
-
-// Default Polygon RPC for wallet operations
-const POLYGON_RPC = 'https://polygon-rpc.com';
-
-/**
- * Helper to get signer from SDK
- * Ensures the signer is connected to a Polygon provider
- */
-function getSignerFromSdk(sdk: PolymarketSDK): ethers.Wallet {
-  const sdkAny = sdk as unknown as {
-    clobApi: {
-      signer?: ethers.Wallet;
-    };
-  };
-
-  const signer = sdkAny.clobApi?.signer;
-  if (!signer) {
-    throw new McpToolError(
-      ErrorCode.AUTH_REQUIRED,
-      'Wallet not configured. Set POLY_PRIVATE_KEY to use wallet features.'
-    );
-  }
-
-  // Ensure signer is connected to a provider
-  if (!signer.provider) {
-    const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
-    return signer.connect(provider);
-  }
-
-  return signer;
-}
-
-/**
- * Get supported deposit assets
- */
-export async function handleGetSupportedAssets(
-  _sdk: PolymarketSDK,
-  input: GetSupportedAssetsInput
-) {
-  try {
-    const bridge = new BridgeClient();
-    const assets = await bridge.getSupportedAssets();
-
-    // Filter by chainId if provided
-    const filtered = input.chainId
-      ? assets.filter((a) => a.chainId === input.chainId)
-      : assets;
-
-    // Get unique chains
-    const chainSet = new Set<string>();
-    for (const asset of filtered) {
-      chainSet.add(asset.chainName);
-    }
-
-    return {
-      assets: filtered.map((a) => ({
-        chainId: a.chainId,
-        chainName: a.chainName,
-        tokenSymbol: a.tokenSymbol,
-        tokenName: a.tokenName,
-        tokenAddress: a.tokenAddress,
-        decimals: a.decimals,
-        minDeposit: a.minDeposit,
-        minDepositUsd: a.minDepositUsd,
-      })),
-      summary: {
-        totalChains: chainSet.size,
-        totalAssets: filtered.length,
-        chains: Array.from(chainSet),
-      },
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Get deposit addresses for the wallet
- */
-export async function handleGetDepositAddresses(sdk: PolymarketSDK) {
-  const signer = getSignerFromSdk(sdk);
-  const walletAddress = signer.address;
-
-  try {
-    const bridge = new BridgeClient();
-    const result = await bridge.createDepositAddresses(walletAddress);
-
-    const evmChains = ['Ethereum', 'Polygon', 'Arbitrum', 'Base', 'Optimism'];
-
-    return {
-      wallet: walletAddress,
-      addresses: {
-        evm: result.address.evm,
-        solana: result.address.svm,
-        bitcoin: result.address.btc,
-      },
-      evmChains,
-      instructions: `Send assets to these addresses to deposit to your Polymarket account.
-
-EVM Chains (Ethereum, Polygon, Arbitrum, Base, Optimism):
-  ${result.address.evm}
-
-Solana:
-  ${result.address.svm}
-
-Bitcoin:
-  ${result.address.btc}
-
-Assets will be automatically converted to USDC.e on Polygon.`,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Deposit USDC to Polymarket
- */
-export async function handleDepositUsdc(
-  sdk: PolymarketSDK,
-  input: DepositUsdcInput
-) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const result = await depositUsdc(signer, input.amount, {
-      token: input.token || 'NATIVE_USDC',
-    });
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error,
-        wallet: signer.address,
-        amount: input.amount,
-      };
-    }
-
-    return {
-      success: true,
-      wallet: signer.address,
-      amount: result.amount,
-      txHash: result.txHash,
-      depositAddress: result.depositAddress,
-      message: `Successfully deposited $${result.amount} USDC. The bridge will automatically convert it to USDC.e on Polygon (typically 1-5 minutes).`,
-      explorerUrl: `https://polygonscan.com/tx/${result.txHash}`,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Check all allowances required for trading
- */
-export async function handleCheckAllowances(sdk: PolymarketSDK) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const authService = new AuthorizationService(signer);
-    const result = await authService.checkAllowances();
-
-    return {
-      wallet: result.wallet,
-      erc20: {
-        usdc: {
-          balance: result.usdcBalance,
-          allowances: result.erc20Allowances,
-        },
-      },
-      erc1155: {
-        conditionalTokens: {
-          approvals: result.erc1155Approvals,
-        },
-      },
-      tradingReady: result.tradingReady,
-      issues: result.issues,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Set up all required approvals for trading
- */
-export async function handleApproveTrading(sdk: PolymarketSDK) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const authService = new AuthorizationService(signer);
-    const result = await authService.approveAll();
-
-    return {
-      wallet: result.wallet,
-      erc20Approvals: result.erc20Approvals,
-      erc1155Approvals: result.erc1155Approvals,
-      allApproved: result.allApproved,
-      summary: result.summary,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-// Input types for new tools
-interface SwapInput {
-  tokenIn: string;
-  tokenOut: string;
-  amount: string;
-  slippage?: number;
-}
-
-interface SwapAndDepositInput {
-  token: string;
-  amount: string;
-  slippage?: number;
-}
-
-/**
- * Swap between tokens on Polygon using QuickSwap V3
- */
-export async function handleSwap(sdk: PolymarketSDK, input: SwapInput) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const swapService = new SwapService(signer);
-
-    // Check balance first
-    const balance = await swapService.getBalance(input.tokenIn);
-    if (parseFloat(balance) < parseFloat(input.amount)) {
-      return {
-        success: false,
-        error: `Insufficient ${input.tokenIn} balance. Have: ${balance}, Need: ${input.amount}`,
-        wallet: signer.address,
-      };
-    }
-
-    // Execute swap
-    const result = await swapService.swap(input.tokenIn, input.tokenOut, input.amount, {
-      slippage: input.slippage || 0.5,
-    });
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: 'Swap failed',
-        wallet: signer.address,
-        txHash: result.transactionHash,
-      };
-    }
-
-    return {
-      success: true,
-      wallet: signer.address,
-      tokenIn: result.tokenIn,
-      tokenOut: result.tokenOut,
-      amountIn: result.amountIn,
-      amountOut: result.amountOut,
-      txHash: result.transactionHash,
-      gasUsed: result.gasUsed,
-      explorerUrl: `https://polygonscan.com/tx/${result.transactionHash}`,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Swap any token to USDC and deposit to Polymarket
- */
-export async function handleSwapAndDeposit(sdk: PolymarketSDK, input: SwapAndDepositInput) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const result = await swapAndDeposit(signer, input.token, input.amount, {
-      slippage: input.slippage || 0.5,
-    });
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.error,
-        wallet: signer.address,
-        token: input.token,
-        amount: input.amount,
-      };
-    }
-
-    return {
-      success: true,
-      wallet: signer.address,
-      tokenIn: result.tokenIn,
-      amountIn: result.amountIn,
-      usdcAmount: result.usdcAmount,
-      swapTxHash: result.swapTxHash || null,
-      depositTxHash: result.depositTxHash,
-      depositAddress: result.depositAddress,
-      message: result.swapTxHash
-        ? `Swapped ${result.amountIn} ${result.tokenIn} to ${result.usdcAmount} USDC, then deposited to Polymarket.`
-        : `Deposited ${result.usdcAmount} USDC to Polymarket.`,
-      explorerUrl: result.depositTxHash
-        ? `https://polygonscan.com/tx/${result.depositTxHash}`
-        : undefined,
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Get balances for all supported tokens (requires configured wallet)
- */
-export async function handleGetTokenBalances(sdk: PolymarketSDK) {
-  const signer = getSignerFromSdk(sdk);
-
-  try {
-    const swapService = new SwapService(signer);
-    const balances = await swapService.getBalances();
-
-    // Filter out zero balances
-    const nonZeroBalances = balances.filter((b) => parseFloat(b.balance) > 0);
-
-    return {
-      wallet: signer.address,
-      balances: balances.map((b) => ({
-        token: b.token,
-        symbol: b.symbol,
-        balance: b.balance,
-        decimals: b.decimals,
-      })),
-      nonZeroBalances: nonZeroBalances.map((b) => ({
-        token: b.token,
-        balance: b.balance,
-      })),
-      supportedTokens: getSupportedDepositTokens(),
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Get balances for any wallet address (no private key required)
- */
-export async function handleGetWalletBalances(
-  _sdk: PolymarketSDK,
-  input: { address: string }
-) {
-  try {
-    // Validate address
-    if (!input.address || !input.address.startsWith('0x') || input.address.length !== 42) {
-      throw new McpToolError(
-        ErrorCode.INVALID_INPUT,
-        'Invalid wallet address. Must be a valid Ethereum address (0x...)'
-      );
-    }
-
-    const balances = await SwapService.getWalletBalances(input.address);
-
-    // Filter out zero balances
-    const nonZeroBalances = balances.filter((b) => parseFloat(b.balance) > 0);
-
-    // Calculate total USD value (simplified, assumes stablecoins = $1)
-    let totalUsdValue = 0;
-    for (const b of nonZeroBalances) {
-      const amount = parseFloat(b.balance);
-      if (['USDC', 'USDC_E', 'USDT', 'DAI'].includes(b.token)) {
-        totalUsdValue += amount;
-      }
-      // For MATIC/WETH, would need price oracle for accurate value
-    }
-
-    return {
-      address: input.address,
-      balances: balances.map((b) => ({
-        token: b.token,
-        symbol: b.symbol,
-        balance: b.balance,
-        decimals: b.decimals,
-      })),
-      nonZeroBalances: nonZeroBalances.map((b) => ({
-        token: b.token,
-        balance: b.balance,
-      })),
-      summary: {
-        totalTokens: nonZeroBalances.length,
-        stablecoinValue: totalUsdValue.toFixed(2),
-      },
-      supportedTokens: getSupportedDepositTokens(),
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-// Input types for quote tools
-interface GetSwapQuoteInput {
-  tokenIn: string;
-  tokenOut: string;
-  amount: string;
-}
-
-/**
- * Get a swap quote (check route availability and estimate output)
- * No private key required - uses read-only provider
- */
-export async function handleGetSwapQuote(
-  _sdk: PolymarketSDK,
-  input: GetSwapQuoteInput
-) {
-  try {
-    // Validate inputs
-    if (!input.tokenIn || !input.tokenOut || !input.amount) {
-      throw new McpToolError(
-        ErrorCode.INVALID_INPUT,
-        'tokenIn, tokenOut, and amount are all required'
-      );
-    }
-
-    // Create a read-only SwapService with a dummy wallet
-    // The getQuote method only uses the provider, not the signer
-    const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
-    const dummyWallet = ethers.Wallet.createRandom().connect(provider);
-    const swapService = new SwapService(dummyWallet);
-
-    const quote = await swapService.getQuote(input.tokenIn, input.tokenOut, input.amount);
-
-    if (quote.possible) {
-      return {
-        possible: true,
-        tokenIn: quote.tokenIn,
-        tokenOut: quote.tokenOut,
-        amountIn: quote.amountIn,
-        amountOut: quote.amountOut,
-        route: quote.route,
-        routeDescription: quote.route.length === 2
-          ? `Direct swap: ${quote.route.join(' → ')}`
-          : `Multi-hop: ${quote.route.join(' → ')}`,
-        message: `Can swap ${quote.amountIn} ${quote.tokenIn} for ~${quote.amountOut} ${quote.tokenOut}`,
-      };
-    } else {
-      return {
-        possible: false,
-        tokenIn: quote.tokenIn,
-        tokenOut: quote.tokenOut,
-        amountIn: quote.amountIn,
-        amountOut: null,
-        route: quote.route,
-        poolExists: quote.poolExists,
-        reason: quote.reason,
-        suggestion: quote.tokenOut === 'USDC_E'
-          ? 'For USDC.e, use: MATIC → USDC via swap, then USDC → USDC.e via deposit_usdc (Bridge)'
-          : 'Try swapping through USDC as an intermediate token',
-      };
-    }
-  } catch (err) {
-    throw wrapError(err);
-  }
-}
-
-/**
- * Get all available liquidity pools on QuickSwap V3
- */
-export async function handleGetAvailablePools(_sdk: PolymarketSDK) {
-  try {
-    // Create a read-only SwapService
-    const provider = new ethers.providers.JsonRpcProvider(POLYGON_RPC);
-    const dummyWallet = ethers.Wallet.createRandom().connect(provider);
-    const swapService = new SwapService(dummyWallet);
-
-    const pools = await swapService.getAvailablePools();
-
-    return {
-      pools: pools.map((p) => ({
-        pair: `${p.tokenA}/${p.tokenB}`,
-        tokenA: p.tokenA,
-        tokenB: p.tokenB,
-        poolAddress: p.poolAddress,
-      })),
-      totalPools: pools.length,
-      supportedTokens: swapService.getSupportedTokens().filter(
-        (t) => t !== 'NATIVE_USDC' && t !== 'WMATIC' // Exclude aliases
-      ),
-      note: 'These are direct swap pairs. For pairs not listed, multi-hop routing through USDC or WMATIC may be available. Use get_swap_quote to check.',
-    };
-  } catch (err) {
-    throw wrapError(err);
-  }
-}