Trading Bot Risk Engine

import { TradingClient, ThreatClient, Chain } from '@webacy-xyz/sdk';

const tradingClient = new TradingClient({
  apiKey: process.env.WEBACY_API_KEY,
  defaultChain: Chain.SOL,
});

const threatClient = new ThreatClient({
  apiKey: process.env.WEBACY_API_KEY,
});

interface RiskEngineResult {
  shouldTrade: boolean;
  maxPositionUsd: number;
  riskScore: number;
  flags: string[];
  metrics: {
    liquidity: number;
    buyTax: number;
    sellTax: number;
    sniperCount: number;
    bundlerCount: number;
    top10Concentration: number;
  };
}

// Main risk engine function
async function evaluateToken(
  tokenAddress: string,
  chain: Chain,
  intendedPositionUsd: number
): Promise<RiskEngineResult> {
  const flags: string[] = [];

  // Step 1: Quick check (Trading Lite for Solana, contract analysis for EVM)
  let quickCheck: { riskScore: number; isHoneypot: boolean; liquidity: number };

  if (chain === Chain.SOL) {
    quickCheck = await tradingClient.tradingLite.analyze(tokenAddress);
  } else {
    // EVM chains - use contract analysis
    const contract = await threatClient.contracts.analyze(tokenAddress, { chain });
    const pools = await tradingClient.tokens.getPools(tokenAddress, { chain });
    const totalLiquidity = pools.pools.reduce((sum, p) => sum + p.liquidity, 0);

    quickCheck = {
      riskScore: contract.overallRisk,
      isHoneypot: contract.isHoneypot ?? false,
      liquidity: totalLiquidity,
    };
  }

  // Immediate rejection: honeypot
  if (quickCheck.isHoneypot) {
    return {
      shouldTrade: false,
      maxPositionUsd: 0,
      riskScore: 100,
      flags: ['HONEYPOT DETECTED'],
      metrics: {
        liquidity: quickCheck.liquidity,
        buyTax: 0,
        sellTax: 100,
        sniperCount: 0,
        bundlerCount: 0,
        top10Concentration: 0,
      },
    };
  }

  // Step 2: Tax analysis (EVM only)
  let buyTax = 0;
  let sellTax = 0;

  if (chain !== Chain.SOL) {
    try {
      const tax = await threatClient.contracts.getTax(tokenAddress, { chain });
      buyTax = tax.buyTax;
      sellTax = tax.sellTax;

      if (sellTax > 25) {
        flags.push(`EXTREME SELL TAX: ${sellTax}%`);
      } else if (sellTax > 10) {
        flags.push(`High sell tax: ${sellTax}%`);
      }

      if (buyTax > 10) {
        flags.push(`High buy tax: ${buyTax}%`);
      }
    } catch {
      // Tax check failed - proceed with caution
      flags.push('Tax check unavailable');
    }
  }

  // Step 3: Holder analysis
  let sniperCount = 0;
  let bundlerCount = 0;
  let top10Concentration = 0;

  try {
    const holders = await tradingClient.holderAnalysis.get(tokenAddress, { chain });
    sniperCount = holders.sniperCount;
    bundlerCount = holders.bundlerCount;
    top10Concentration = holders.top10Percentage;

    if (sniperCount > 10) {
      flags.push(`Heavy sniping: ${sniperCount} snipers`);
    }

    if (bundlerCount > 3) {
      flags.push(`Bundler activity: ${bundlerCount} clusters`);
    }

    if (top10Concentration > 80) {
      flags.push(`High concentration: Top 10 hold ${top10Concentration}%`);
    }
  } catch {
    flags.push('Holder analysis unavailable');
  }

  // Step 4: Calculate max position based on liquidity
  const liquidity = quickCheck.liquidity;
  const maxPositionUsd = liquidity * 0.02; // 2% of liquidity

  if (intendedPositionUsd > maxPositionUsd) {
    flags.push(`Position too large for liquidity`);
  }

  if (liquidity < 5000) {
    flags.push(`Low liquidity: $${liquidity.toLocaleString()}`);
  }

  // Final decision
  const criticalFlags = flags.filter(f =>
    f.includes('EXTREME') ||
    f.includes('HONEYPOT') ||
    f.includes('Position too large')
  );

  const shouldTrade =
    !quickCheck.isHoneypot &&
    quickCheck.riskScore < 60 &&
    sellTax < 25 &&
    liquidity >= intendedPositionUsd * 50 &&
    criticalFlags.length === 0;

  return {
    shouldTrade,
    maxPositionUsd,
    riskScore: quickCheck.riskScore,
    flags,
    metrics: {
      liquidity,
      buyTax,
      sellTax,
      sniperCount,
      bundlerCount,
      top10Concentration,
    },
  };
}

// Batch evaluation for multiple tokens
async function evaluateTokenBatch(
  tokens: Array<{ address: string; chain: Chain }>,
  positionSizeUsd: number
): Promise<Map<string, RiskEngineResult>> {
  const results = new Map<string, RiskEngineResult>();

  // Process in parallel (up to 10 at a time)
  const batchSize = 10;

  for (let i = 0; i < tokens.length; i += batchSize) {
    const batch = tokens.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(t => evaluateToken(t.address, t.chain, positionSizeUsd))
    );

    batch.forEach((token, index) => {
      results.set(token.address, batchResults[index]);
    });
  }

  return results;
}

// Pre-trade checklist
async function preTradeCheck(
  tokenAddress: string,
  chain: Chain,
  positionUsd: number
): Promise<{
  approved: boolean;
  checklist: Array<{ check: string; passed: boolean; details: string }>;
}> {
  const evaluation = await evaluateToken(tokenAddress, chain, positionUsd);

  const checklist = [
    {
      check: 'Not a honeypot',
      passed: evaluation.metrics.sellTax < 100,
      details: evaluation.metrics.sellTax >= 100 ? 'Cannot sell' : 'Sellable',
    },
    {
      check: 'Acceptable tax',
      passed: evaluation.metrics.sellTax < 15,
      details: `Buy: ${evaluation.metrics.buyTax}%, Sell: ${evaluation.metrics.sellTax}%`,
    },
    {
      check: 'Sufficient liquidity',
      passed: evaluation.metrics.liquidity >= positionUsd * 50,
      details: `$${evaluation.metrics.liquidity.toLocaleString()} available`,
    },
    {
      check: 'Not heavily sniped',
      passed: evaluation.metrics.sniperCount < 10,
      details: `${evaluation.metrics.sniperCount} snipers detected`,
    },
    {
      check: 'Not concentrated',
      passed: evaluation.metrics.top10Concentration < 80,
      details: `Top 10 hold ${evaluation.metrics.top10Concentration}%`,
    },
    {
      check: 'Risk score acceptable',
      passed: evaluation.riskScore < 60,
      details: `Score: ${evaluation.riskScore}/100`,
    },
  ];

  return {
    approved: checklist.every(c => c.passed),
    checklist,
  };
}

// Usage example
async function main() {
  const token = 'PumpTokenMint...';
  const positionSize = 500; // $500

  const check = await preTradeCheck(token, Chain.SOL, positionSize);

  console.log('\nPre-Trade Checklist:');
  console.log('==================');

  for (const item of check.checklist) {
    const status = item.passed ? '✓' : '✗';
    console.log(`${status} ${item.check}: ${item.details}`);
  }

  console.log('==================');
  console.log(`Decision: ${check.approved ? 'APPROVED' : 'REJECTED'}`);
}