feat: initial polymarket copy trade tool

- Watcher: polls Data API for trader activity - Executor: buy/sell with market orders + retry logic - Position manager: JSON-based state tracking - Auto-sell: limit orders at profit target - Redeemer: check & redeem winning positions on-chain - Config: env-based settings with validation - DRY_RUN mode for safe testing
2026-02-22 15:38:13 +07:00
commit 7c7fad45f3
16 changed files with 3211 additions and 0 deletions
@@ -0,0 +1,148 @@
+import { ethers } from 'ethers';
+import config from '../config/index.js';
+import { getOpenPositions, updatePosition, removePosition } from './position.js';
+import logger from '../utils/logger.js';
+
+// Contract addresses on Polygon
+const CTF_ADDRESS = '0x4D97DCd97eC945f40cF65F87097ACe5EA0476045';
+const NEG_RISK_CTF_ADDRESS = '0xC5d563A36AE78145C45a50134d48A1215220f80a';
+const USDC_ADDRESS = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174';
+
+// CTF ABI (minimal for redeemPositions & balanceOf)
+const CTF_ABI = [
+    'function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets)',
+    'function balanceOf(address owner, uint256 tokenId) view returns (uint256)',
+    'function payoutNumerators(bytes32 conditionId, uint256 outcomeIndex) view returns (uint256)',
+    'function payoutDenominator(bytes32 conditionId) view returns (uint256)',
+];
+
+/**
+ * Check if a market has been resolved and our position is a winner
+ * @param {string} conditionId
+ * @returns {Object|null} { resolved, won }
+ */
+async function checkMarketResolution(conditionId) {
+    try {
+        // Check via Gamma API
+        const url = `${config.gammaHost}/markets?condition_id=${conditionId}`;
+        const response = await fetch(url);
+        if (!response.ok) return null;
+
+        const markets = await response.json();
+        if (!markets || markets.length === 0) return null;
+
+        const market = markets[0];
+        return {
+            resolved: market.closed || market.resolved || false,
+            active: market.active,
+            endDate: market.end_date_iso,
+            resolutionSource: market.resolution_source,
+            question: market.question,
+        };
+    } catch (err) {
+        logger.error('Failed to check market resolution:', err.message);
+        return null;
+    }
+}
+
+/**
+ * Check on-chain if a position (token) has value (payout available)
+ */
+async function checkOnChainPayout(conditionId) {
+    try {
+        const provider = new ethers.providers.JsonRpcProvider('https://polygon-rpc.com');
+        const ctf = new ethers.Contract(CTF_ADDRESS, CTF_ABI, provider);
+
+        const denominator = await ctf.payoutDenominator(conditionId);
+        if (denominator.isZero()) return { resolved: false, payouts: [] };
+
+        // Check payouts for both outcomes (YES=0, NO=1)
+        const payouts = [];
+        for (let i = 0; i < 2; i++) {
+            const numerator = await ctf.payoutNumerators(conditionId, i);
+            payouts.push(numerator.toNumber() / denominator.toNumber());
+        }
+
+        return { resolved: true, payouts };
+    } catch (err) {
+        // If payoutDenominator is 0 or reverts, market not resolved
+        return { resolved: false, payouts: [] };
+    }
+}
+
+/**
+ * Redeem winning position on-chain
+ */
+async function redeemPosition(conditionId, isNegRisk = false) {
+    try {
+        const provider = new ethers.providers.JsonRpcProvider('https://polygon-rpc.com');
+        const wallet = new ethers.Wallet(config.privateKey, provider);
+        const ctfAddress = isNegRisk ? NEG_RISK_CTF_ADDRESS : CTF_ADDRESS;
+        const ctf = new ethers.Contract(ctfAddress, CTF_ABI, wallet);
+
+        const parentCollectionId = ethers.constants.HashZero;
+        const indexSets = [1, 2]; // Both outcomes
+
+        logger.info(`Redeeming position for conditionId: ${conditionId}`);
+
+        const tx = await ctf.redeemPositions(
+            USDC_ADDRESS,
+            parentCollectionId,
+            conditionId,
+            indexSets,
+            { gasLimit: 300000 },
+        );
+
+        logger.info(`Redeem tx sent: ${tx.hash}`);
+        const receipt = await tx.wait();
+        logger.success(`Redeem confirmed in block ${receipt.blockNumber}`);
+
+        return true;
+    } catch (err) {
+        logger.error('Failed to redeem position:', err.message);
+        return false;
+    }
+}
+
+/**
+ * Check all open positions for redeemable (resolved & won) markets
+ */
+export async function checkAndRedeemPositions() {
+    const positions = getOpenPositions();
+    if (positions.length === 0) return;
+
+    logger.info(`Checking ${positions.length} position(s) for redemption...`);
+
+    for (const position of positions) {
+        try {
+            // Check via API first
+            const resolution = await checkMarketResolution(position.conditionId);
+
+            if (!resolution || !resolution.resolved) {
+                // Try on-chain check as fallback
+                const onChain = await checkOnChainPayout(position.conditionId);
+                if (!onChain.resolved) continue;
+
+                // Check if our outcome won
+                // Determine outcome index (0=YES, 1=NO based on token position)
+                logger.info(`Market resolved on-chain: ${position.market} | Payouts: ${onChain.payouts}`);
+            } else {
+                logger.info(`Market resolved: ${position.market}`);
+            }
+
+            if (config.dryRun) {
+                logger.info(`[DRY RUN] Would redeem position: ${position.market}`);
+                continue;
+            }
+
+            // Attempt to redeem
+            const success = await redeemPosition(position.conditionId);
+            if (success) {
+                removePosition(position.conditionId);
+                logger.money(`Redeemed: ${position.market}`);
+            }
+        } catch (err) {
+            logger.error(`Error checking position ${position.market}:`, err.message);
+        }
+    }
+}