차익거래 스캐너 구축

예시: Solana의 SOL/USDC

Jupiter:  1 SOL = $140.00
Raydium:  1 SOL = $140.70

스프레드 = ($140.70 - $140.00) / $140.00 = 0.5%

차익거래 경로:
Jupiter에서 SOL 매수 → Raydium에서 SOL 매도 → 차액으로 수익

npm install @chainstream-io/sdk dotenv

// config.js
import 'dotenv/config';

export const CHAINSTREAM_ACCESS_TOKEN = process.env.CHAINSTREAM_ACCESS_TOKEN;

// 모니터링할 DEX (Solana: Jupiter, Raydium, PumpFun, Moonshot, Candy; EVM: KyberSwap on eth/bsc)
export const DEXES = ['jupiter', 'raydium', 'pumpfun', 'moonshot', 'candy'];

// 모니터링할 거래 쌍 (다중 DEX 스프레드 확인은 현재 지원 범위에서 Solana가 가장 강력)
export const TRADING_PAIRS = [
  { base: 'SOL', quote: 'USDC', chain: 'sol' },
  { base: 'SOL', quote: 'USDT', chain: 'sol' },
];

// 차익거래 임계값
export const MIN_PROFIT_PERCENT = 0.3;   // 최소 수익률
export const MIN_LIQUIDITY_USD = 50000;  // 최소 유동성

// scanner.js
import { ChainStreamClient } from '@chainstream-io/sdk';
import { CHAINSTREAM_ACCESS_TOKEN, DEXES } from './config.js';

export class PriceScanner {
  constructor() {
    this.client = new ChainStreamClient(CHAINSTREAM_ACCESS_TOKEN);
  }

  async getDexPrices(base, quote, chain) {
    // DEX 간 거래 쌍 가격 조회
    const prices = await this.client.dex.getPrices({
      base,
      quote,
      chain,
      dexes: DEXES
    });
    return prices;
  }
}

// evaluator.js
import { MIN_PROFIT_PERCENT, MIN_LIQUIDITY_USD } from './config.js';

export class ArbitrageEvaluator {

  findOpportunity(prices, pair) {
    // 낮은 유동성 필터링
    const validPrices = prices.filter(
      p => (p.liquidityUsd || 0) >= MIN_LIQUIDITY_USD
    );

    if (validPrices.length < 2) {
      return null;
    }

    // 최저 매수가와 최고 매도가 찾기
    const sortedPrices = [...validPrices].sort((a, b) => a.price - b.price);
    const buyFrom = sortedPrices[0];   // 최저가 - 매수
    const sellTo = sortedPrices[sortedPrices.length - 1]; // 최고가 - 매도

    // 스프레드 계산
    const spread = (sellTo.price - buyFrom.price) / buyFrom.price * 100;

    // 비용 추정
    const gasCostPercent = 0.1;  // ~0.1%
    const slippagePercent = 0.2; // ~0.2%
    const totalCost = gasCostPercent + slippagePercent;

    // 순이익
    const netProfit = spread - totalCost;

    if (netProfit < MIN_PROFIT_PERCENT) {
      return null;
    }

    return {
      pair: `${pair.base}/${pair.quote}`,
      buyDex: buyFrom.dex,
      buyPrice: buyFrom.price,
      sellDex: sellTo.dex,
      sellPrice: sellTo.price,
      spreadPercent: Number(spread.toFixed(3)),
      netProfitPercent: Number(netProfit.toFixed(3)),
      maxSizeUsd: Math.min(buyFrom.liquidityUsd, sellTo.liquidityUsd) * 0.02
    };
  }
}

// risk.js
export function assessRisk(opportunity) {
  const risks = [];

  // MEV 리스크
  if (opportunity.netProfitPercent > 1.0) {
    risks.push('🔴 높은 수익은 MEV에 프론트런되기 쉬움');
  }

  // 유동성 리스크
  if (opportunity.maxSizeUsd < 5000) {
    risks.push('🟡 실행 가능한 크기가 작음');
  }

  // 타이밍 리스크
  risks.push('⚠️ 가격 데이터에는 지연이 있음');

  return {
    risks,
    executable: risks.filter(r => r.includes('🔴')).length === 0
  };
}

// index.js
import { PriceScanner } from './scanner.js';
import { ArbitrageEvaluator } from './evaluator.js';
import { TRADING_PAIRS } from './config.js';

async function main() {
  const scanner = new PriceScanner();
  const evaluator = new ArbitrageEvaluator();

  console.log('🔍 차익거래 스캐너 시작...');

  while (true) {
    for (const pair of TRADING_PAIRS) {
      const prices = await scanner.getDexPrices(
        pair.base, 
        pair.quote, 
        pair.chain
      );

      const opp = evaluator.findOpportunity(prices, pair);

      if (opp) {
        console.log(`
🎯 차익거래 기회 발견!
   페어: ${opp.pair}
   매수: ${opp.buyDex} @ $${opp.buyPrice}
   매도: ${opp.sellDex} @ $${opp.sellPrice}
   스프레드: ${opp.spreadPercent}%
   순이익: ${opp.netProfitPercent}%
   최대 크기: $${opp.maxSizeUsd.toLocaleString()}
        `);
      }
    }

    // 10초마다 스캔
    await new Promise(resolve => setTimeout(resolve, 10000));
  }
}

main();