잡코인 펌프 후 폭락을 잡는 방법: 체계적 접근법

모든 암호화폐 트레이더는 이런 장면을 최소 한 번은 목격한 적이 있다. 어제까지 아무도 들어보지 못한 토큰이 4시간 만에 +800%를 기록한다. 트위터는 로켓 이모지로 폭발한다. 레딧에는 "이건 시작에 불과해"라는 글이 올라온다. 한 달 전까지 호가창과 맥도날드 주문을 구분 못 하던 동료가 "야, 최소 백만 원이라도 넣어봐"라고 메시지를 보낸다. 12시간 후 토큰은 고점 대비 85% 하락한다. 적막. 로켓은 삭제되었다.

문제는 덤프가 일어날 것인지가 아니다. 문제는 펌프 자체에 깔리지 않으면서 어떻게 체계적으로 수익을 낼 것인가다.

이 글은 투자 조언이 아니다(아무도 읽지 않지만 변호사가 넣으라고 하는 의무적 면책 조항). 저유동성 자산의 임펄스 움직임 이후 반전 포인트를 식별하기 위한 메커니즘, 시그널, 알고리즘에 대한 기술적 분석이다.

펌프 앤 덤프의 해부학: 하나의 광기가 거치는 세 단계

숏을 치기 전에 이 현상의 구조를 이해해야 한다. 잡코인의 모든 펌프 앤 덤프는 세 단계를 거치며, 각 단계는 데이터에서 고유한 특성 시그니처를 보인다.

1단계: 매집 (조용한 사냥)

소요 시간: 수 시간에서 수일.

누군가—인사이더 그룹, 조직화된 텔레그램 그룹, 또는 정보 우위를 가진 대형 플레이어—가 토큰을 매집하기 시작한다. 신중하게 진행된다: 소액 주문으로, 여러 거래소에 걸쳐, 주로 아시아 세션(유동성이 최소이고 시장 관심이 분산되는 시간대)에.

데이터에서 보이는 것:

• 거래량이 점진적으로 증가(지난 7일 평균 대비 50-200% 높음)하지만 가격은 거의 움직이지 않음
• 매수 호가창이 두꺼워짐: 현재 가격 아래 2-5%에 "벽"이 나타남
• 온체인 지표(DEX 토큰의 경우): 거래소로의 대규모 전송, 고유 매수 지갑 수 증가
• 무기한 선물의 펀딩비(존재하는 경우)가 소폭 상승 시작

이 단계에서 숏을 치기는 이르다. 이것이 매집인지 유기적 수요인지 아직 알 수 없다. 사실 둘을 구분하는 것은 종종 불가능하며, 차이는 사후에야 분명해진다.

2단계: 임펄스 (파티)

소요 시간: 30분에서 12시간.

가격이 핵심 저항선을 돌파하고 캐스케이드가 시작된다. 숏 포지션의 스톱로스가 청산된다. FOMO(Fear Of Missing Out)가 개인 투자자를 빨아들인다. 크립토 트위터는 에코 체임버가 된다. 리트윗 하나하나가 새로운 50배 레버리지 롱이다.

특징적 시그니처:

• 거래량이 평균의 1000-5000%(오타 아님)
• 펀딩비가 8시간당 0.1-0.5%로 급등(정상은 0.01%)
• 미결제약정(Open Interest)이 지수적으로 증가: 새 포지션 개설 속도가 청산 속도를 추월
• 매수-매도 스프레드가 매도 호가 유동성 부족으로 3-10배 확대
• 호가창에 상방 진공 상태: 현재 가격과 가장 가까운 대형 매도 호가 사이에 빈 공간

이 단계에서 숏을 치는 것은 자살행위다. "언젠가는 멈추겠지"라며 기차 앞에 서는 것과 같다. 그래, 멈추긴 한다. 하지만 그때쯤이면 이미 청산당한 후다. 이에 대해서는 아래 "해서는 안 되는 것" 섹션에서 자세히 다룬다.

3단계: 분배와 붕괴 (숙취)

소요 시간: 2시간에서 48시간.

인사이더들이 이익 실현을 시작한다. 가격이 첫 번째 의미 있는 조정(-15-30%)을 보인다. 개인 투자자들이 "디핑을 산다." 가격이 반등한다. 그리고 다시 하락한다. 이후 반등은 점점 약해지고, 하락은 점점 깊어진다.

데이터에서 일어나는 일:

• 거래량은 여전히 높지만 매도 쪽으로 이동
• 펀딩비가 하락하기 시작하지만 여전히 비정상적으로 높음
• 미결제약정 증가가 멈추거나 감소 시작(롱 청산)
• 대형 시장가 매도 주문이 나타나 호가창을 몇 단계씩 "뚫고 내려감"
• 온체인: 인사이더 지갑에서 거래소로 대규모 전송

여기가 사냥 구역이다. 진정한 작업은 여기서 시작된다.

숏 진입을 위한 핵심 시그널

각 시그널은 단독으로는 약하다. 세 개 이상의 조합이 되어야 실행 가능한 가설이 된다.

1. 펀딩비: 탐욕에 대한 세금

펀딩비는 무기한 선물에서 포지션을 유지하는 비용이다. 모두가 롱을 원할 때, 롱이 숏에게 지불한다. 비율이 높을수록 시장이 한쪽으로 더 쏠려 있다.

왜 작동하는가: 8시간당 0.3% 펀딩비에서 롱 보유자는 포지션 유지 비용만으로 하루 약 1%를 지불한다. 10배 레버리지에서는 하루 자본의 10%다. 이런 상태가 오래 지속될 수 없으며, 포지션이 닫히기 시작하면서 가격을 하방 압박한다.

주의사항: 극단적 펀딩 자체는 숏 시그널이 아니다. 가격이 계속 상승하는 동안 수 시간에서 며칠까지 높은 수준을 유지할 수 있다. 펀딩은 필터(쏠림의 확인)이지 트리거(진입 포인트)가 아니다.

def funding_rate_signal(
    current_rate: float,
    historical_rates: list[float],
    lookback: int = 90,  # 90 기간 = 30일
) -> dict:
    """
    현재 펀딩비의 이상 정도를 평가.

    Returns:
        signal: 'neutral' | 'elevated' | 'extreme' | 'insane'
        z_score: float — 정상값으로부터의 편차
        percentile: float — 과거 데이터에서의 백분위
    """
    import numpy as np

    hist = np.array(historical_rates[-lookback:])
    mean = hist.mean()
    std = hist.std()

    z_score = (current_rate - mean) / std if std > 0 else 0
    percentile = np.searchsorted(np.sort(hist), current_rate) / len(hist)

    if z_score > 4:
        signal = 'insane'
    elif z_score > 3:
        signal = 'extreme'
    elif z_score > 2:
        signal = 'elevated'
    else:
        signal = 'neutral'

    return {
        'signal': signal,
        'z_score': round(z_score, 2),
        'percentile': round(percentile, 4),
        'annualized_cost': round(current_rate * 3 * 365 * 100, 1),  # 연간 %
    }

2. 미결제약정(Open Interest): 누가 갇혀 있는가

미결제약정(OI)은 선물에서 미청산 계약의 총 수량이다. OI가 가격과 함께 상승하면 새로운 참여자(주로 롱)가 진입 중이다. 가격이 하락하기 시작했는데 OI가 여전히 높다면 그 롱들은 갇힌 것이다. 그들의 청산이 덤프의 연료가 된다.

핵심 패턴:

롱에게 가장 위험하고 숏에게 가장 좋은 순간: 가격이 하락하기 시작했지만 OI가 여전히 최대치에 있다. 이는 미결제 롱이 아직 청산되지 않았음을 의미한다—반등을 기대하고 있는 것이다. 그 희망이 사라지면 청산 캐스케이드가 시작된다.

def oi_divergence_signal(
    prices: list[float],
    oi_values: list[float],
    window: int = 12,  # 12개 캔들(예: 12 × 5분 = 1시간)
) -> dict:
    """
    가격/OI 다이버전스 탐지.

    강세 OI 다이버전스: 가격 하락, OI 고점 — 롱이 갇힘.
    """
    import numpy as np

    recent_prices = np.array(prices[-window:])
    recent_oi = np.array(oi_values[-window:])

    price_change = (recent_prices[-1] - recent_prices[0]) / recent_prices[0]
    oi_change = (recent_oi[-1] - recent_oi[0]) / recent_oi[0]

    oi_at_peak = recent_oi[-1] > np.percentile(oi_values, 90)
    price_declining = price_change < -0.03  # 가격 3% 이상 하락

    trapped_longs = oi_at_peak and price_declining

    if len(oi_values) > window * 2:
        oi_velocity = oi_change / max(abs(price_change), 0.001)
    else:
        oi_velocity = 0

    return {
        'trapped_longs': trapped_longs,
        'oi_percentile': round(
            np.searchsorted(np.sort(oi_values), recent_oi[-1]) / len(oi_values), 2
        ),
        'price_change': round(price_change * 100, 2),
        'oi_change': round(oi_change * 100, 2),
        'oi_velocity': round(oi_velocity, 2),
    }

3. 거래량 분석: 틱 속의 진실

거래량은 위조할 수 없는 유일한 시장 지표다(거의 — 일부 거래소에서의 세탁 거래는 아직 현실이지만, 주요 거래소에서는 크게 개선됐다).

숏 시그널:

상승 시 거래량 감소. 전형적인 약세 신호. 가격이 신고가를 찍지만, 해당 움직임의 거래량이 이전보다 적다. 매수세가 소진되고 있다.

하락 시 거래량 급증. -10% 조정이 직전 상승 임펄스의 거래량을 넘는 거래량으로 발생한다면—매도세가 주도권을 잡은 것이다.

저거래량 페이크 돌파. 가격이 지역 고점을 돌파하지만, 돌파 시 거래량이 평균의 2-3배 이하다. 이것은 매수자에 대한 함정이다: 가격은 빠르게 되돌아간다.

def volume_exhaustion_signal(
    candles: list[dict],  # [{open, high, low, close, volume, timestamp}, ...]
    pump_start_idx: int,
) -> dict:
    """
    펌프 후 거래량 소진 분석.
    """
    import numpy as np

    pump_candles = candles[pump_start_idx:]

    up_candles = [c for c in pump_candles if c['close'] > c['open']]
    down_candles = [c for c in pump_candles if c['close'] <= c['open']]

    if not up_candles or not down_candles:
        return {'signal': 'insufficient_data'}

    avg_up_vol = np.mean([c['volume'] for c in up_candles])
    avg_down_vol = np.mean([c['volume'] for c in down_candles])

    up_volumes = [c['volume'] for c in up_candles]
    if len(up_volumes) >= 3:
        first_half = np.mean(up_volumes[:len(up_volumes)//2])
        second_half = np.mean(up_volumes[len(up_volumes)//2:])
        volume_degradation = (second_half - first_half) / first_half
    else:
        volume_degradation = 0

    all_volumes = np.array([c['volume'] for c in candles])
    vol_mean = all_volumes[:-len(pump_candles)].mean() if len(candles) > len(pump_candles) else all_volumes.mean()
    vol_std = all_volumes[:-len(pump_candles)].std() if len(candles) > len(pump_candles) else all_volumes.std()
    current_z = (pump_candles[-1]['volume'] - vol_mean) / vol_std if vol_std > 0 else 0

    return {
        'sell_buy_volume_ratio': round(avg_down_vol / max(avg_up_vol, 1), 2),
        'volume_degradation_pct': round(volume_degradation * 100, 1),
        'current_volume_z_score': round(current_z, 2),
        'signal': 'exhaustion' if volume_degradation < -0.3 else 'active',
    }

4. 캔들 패턴: 여전히 유효한 고전 기법

그렇다, 캔들 분석은 17세기 혼마 무네히사와 쌀 선물로 거슬러 올라간다. 그렇다, 유튜브 "캔들 전략"의 90%는 쓰레기다. 하지만 펌프 후 5분봉과 15분봉 타임프레임에서 특정 패턴은 통계적으로 유의미한 예측력을 가진다. 이유는 단순하다: 이들은 실제 미시구조—매수세에서 매도세로의 주도권 전환을 반영하기 때문이다.

추적할 가치가 있는 패턴:

매우 중요: 맥락 없는 패턴은 노이즈다. 임의 조정에서의 유성형은 아무 의미가 없다. 비정상적 펀딩비와 OI 다이버전스를 동반한 펌프 고점에서의 유성형—그것은 완전히 다른 이야기다.

def detect_reversal_patterns(
    candles: list[dict],
    min_upper_shadow_ratio: float = 2.0,  # 윗꼬리 > 몸통의 2배(유성형 기준)
) -> list[dict]:
    """
    하락 반전 패턴 탐지.
    """
    signals = []

    for i in range(2, len(candles)):
        c = candles[i]
        body = abs(c['close'] - c['open'])
        upper_shadow = c['high'] - max(c['close'], c['open'])
        lower_shadow = min(c['close'], c['open']) - c['low']
        total_range = c['high'] - c['low']

        if total_range == 0:
            continue

        if (upper_shadow > body * min_upper_shadow_ratio
            and lower_shadow < body * 0.5
            and c['close'] < c['open']):  # 하락
            signals.append({
                'pattern': 'shooting_star',
                'index': i,
                'timestamp': c['timestamp'],
                'strength': upper_shadow / total_range,
            })

        prev = candles[i - 1]
        if (prev['close'] > prev['open']  # 이전 캔들은 양봉
            and c['close'] < c['open']      # 현재 캔들은 음봉
            and c['open'] > prev['close']   # 시가가 이전 종가보다 높음
            and c['close'] < prev['open']): # 종가가 이전 시가보다 낮음
            signals.append({
                'pattern': 'bearish_engulfing',
                'index': i,
                'timestamp': c['timestamp'],
                'strength': body / (abs(prev['close'] - prev['open']) + 1e-10),
            })

        if i >= 2:
            c1 = candles[i - 2]
            c2 = candles[i - 1]
            c3 = candles[i]

            c1_body = abs(c1['close'] - c1['open'])
            c2_body = abs(c2['close'] - c2['open'])
            c3_body = abs(c3['close'] - c3['open'])

            if (c1['close'] > c1['open']        # 첫 번째는 양봉
                and c2_body < c1_body * 0.3      # 두 번째는 작음(도지)
                and c3['close'] < c3['open']     # 세 번째는 음봉
                and c3_body > c1_body * 0.5      # 세 번째가 충분히 큼
                and c3['close'] < c1['close']):  # 세 번째 종가가 첫 번째 종가보다 낮음
                signals.append({
                    'pattern': 'evening_star',
                    'index': i,
                    'timestamp': c['timestamp'],
                    'strength': c3_body / c1_body,
                })

    return signals

5. VWAP: 현실의 닻

VWAP(거래량 가중 평균 가격)은 거래량으로 가중된 평균 가격이다. 펌프 시작점부터의 앵커드 VWAP은 임펄스 기간 동안 매수한 모든 참여자의 평균 진입 가격을 보여준다.

왜 중요한가: 가격이 앵커드 VWAP 아래로 내려가면—평균 매수자가 손실 상태에 놓인다. 심리적 압박이 커진다. 펌프 초기에 "싸게" 산 사람들이 이익 실현을 시작한다. 고점에서 산 사람들은 패닉 상태다.

규칙: 거래량 증가를 동반한 앵커드 VWAP 하방 이탈은 숏 진입 또는 포지션 추가의 강한 시그널이다.

def anchored_vwap(
    candles: list[dict],
    anchor_idx: int,
) -> list[float]:
    """
    지정 포인트(펌프 시작점)로부터의 앵커드 VWAP 계산.
    """
    vwap_values = []
    cum_vol = 0
    cum_vol_price = 0

    for i in range(anchor_idx, len(candles)):
        c = candles[i]
        typical_price = (c['high'] + c['low'] + c['close']) / 3
        cum_vol += c['volume']
        cum_vol_price += typical_price * c['volume']

        vwap = cum_vol_price / cum_vol if cum_vol > 0 else typical_price
        vwap_values.append(vwap)

    return vwap_values

6. 청산 캐스케이드: 도미노 효과

이것은 가장 강력한 덤프 메커니즘이며, 숏 포지션에게 가장 수익성 높은 메커니즘이다. 논리는 단순하다:

1. 트레이더가 20배 레버리지로 롱을 연다. 가격이 5% 하락하면 청산된다.
2. 가격이 5% 하락한다. 포지션이 청산된다—거래소가 시장가로 매도한다.
3. 시장가 매도가 가격을 더 내린다. 다음 트레이더의 청산을 유발한다.
4. 이런 식으로 계속. 캐스케이드.

사전에 파악하는 방법:

CoinGlass 청산 히트맵은 청산 레벨이 어디에 집중되어 있는지 보여준다. 현재 가격 아래에 청산 "벽"이 보인다면, 해당 레벨까지의 하락은 높은 확률로 캐스케이드를 유발한다.

캐스케이드 시그널: 현재 가격의 -5%에서 -15% 구간에 500만 달러 이상의 청산이 집중되어 있다면(일 거래량 5천만~2억 달러인 잡코인 기준), 캐스케이드가 발생할 가능성이 높다.

실전 알고리즘: 필터 -> 진입 -> 리스크

이론은 훌륭하다. 이제 파이프라인이다.

1단계: 필터링 (스캐너)

수천 개의 토큰 중 펌프 후 단계에 있는 것을 선별해야 한다. 기준:

def pump_scanner(
    symbols: list[str],
    exchange,  # ccxt exchange instance
    lookback_hours: int = 24,
    min_pump_pct: float = 100,  # 조회 기간 내 최소 +100%
    min_volume_z: float = 3,    # 거래량 Z-score > 3
) -> list[dict]:
    """
    펌프 후 단계에 있는 토큰 스캐너.
    """
    import numpy as np

    candidates = []

    for symbol in symbols:
        try:
            candles = exchange.fetch_ohlcv(symbol, '1h', limit=168)  # 7일
            if len(candles) < 168:
                continue

            closes = [c[4] for c in candles]
            volumes = [c[5] for c in candles]

            recent_closes = closes[-lookback_hours:]
            max_price = max(recent_closes)
            min_price_before = min(closes[:-lookback_hours]) if len(closes) > lookback_hours else closes[0]
            pump_pct = (max_price - min_price_before) / min_price_before * 100

            current_price = closes[-1]
            drawdown_from_peak = (current_price - max_price) / max_price * 100

            vol_baseline = np.mean(volumes[:-lookback_hours])
            vol_std = np.std(volumes[:-lookback_hours])
            vol_recent = np.mean(volumes[-lookback_hours:])
            vol_z = (vol_recent - vol_baseline) / vol_std if vol_std > 0 else 0

            if pump_pct >= min_pump_pct and vol_z >= min_volume_z:
                candidates.append({
                    'symbol': symbol,
                    'pump_pct': round(pump_pct, 1),
                    'drawdown_from_peak': round(drawdown_from_peak, 1),
                    'volume_z_score': round(vol_z, 2),
                    'current_price': current_price,
                    'peak_price': max_price,
                })
        except Exception:
            continue

    candidates.sort(key=lambda x: x['drawdown_from_peak'], reverse=True)
    return candidates

2단계: 시그널 수렴 (스코어링)

각 후보에 대해 여섯 가지 파라미터로 평가:

def confluence_score(
    funding_signal: dict,
    oi_signal: dict,
    volume_signal: dict,
    pattern_signals: list[dict],
    vwap_position: float,  # 가격 / VWAP (< 1 = VWAP 아래)
    liquidation_density: float,  # 현재 가격 아래 청산량(백만 달러)
) -> dict:
    """
    숏 진입을 위한 종합 점수.
    점수 0-6, 각 요소 = 0 또는 1점.
    """
    score = 0
    reasons = []

    if funding_signal['signal'] in ('extreme', 'insane'):
        score += 1
        reasons.append(f"Funding z-score: {funding_signal['z_score']}")

    if oi_signal['trapped_longs']:
        score += 1
        reasons.append(f"Trapped longs: OI percentile {oi_signal['oi_percentile']}")

    if volume_signal['signal'] == 'exhaustion':
        score += 1
        reasons.append(f"Volume degradation: {volume_signal['volume_degradation_pct']}%")

    strong_patterns = [p for p in pattern_signals if p['strength'] > 0.6]
    if strong_patterns:
        score += 1
        reasons.append(f"Pattern: {strong_patterns[-1]['pattern']}")

    if vwap_position < 0.98:  # 가격이 VWAP보다 2% 이상 아래
        score += 1
        reasons.append(f"Below VWAP: {round((1 - vwap_position) * 100, 1)}%")

    if liquidation_density > 5:  # 500만 달러 이상 청산
        score += 1
        reasons.append(f"Liquidation density: ${liquidation_density}M")

    if score >= 4:
        action = 'strong_short'
    elif score >= 3:
        action = 'short'
    elif score >= 2:
        action = 'watch'
    else:
        action = 'skip'

    return {
        'score': score,
        'max_score': 6,
        'action': action,
        'reasons': reasons,
    }

3단계: 진입과 리스크 관리

진입:

• 점수 >= 4: 50% 포지션 진입
• 점수 = 3: 25% 포지션 진입
• 점수 < 3: 대기

스톱로스:

• 마지막 스윙 하이 위 + 1-2% 버퍼
• 타이트한 스톱 금지. 잡코인의 변동성이 당신을 죽인다. 진입가 대비 최소 5-10%.
• 점수 = 6일 때 8-12% 스톱 허용(확신이 클수록 = 스톱은 넓게, 레버리지는 낮게)

테이크프로핏:

• TP1 (50% 포지션): 다음 주요 지지선 또는 진입가 대비 -20%
• TP2 (30% 포지션): 펌프 시작점의 VWAP
• TP3 (20% 포지션): 펌프 이전 가격 수준

포지션 크기:

$\text{Position size} = \frac{\text{Risk per trade}}{\text{Stop distance}} = \frac{0.02 \times \text{Capital}}{\text{Stop \%}}$

자본 $10,000, 거래당 리스크 2%, 스톱 8%인 경우:

$\text{Position} = \frac{200}{0.08} = \$2,500$

3배 레버리지: $200(자본의 2$500-$1,250의 잠재 수익(TP1-TP3)을 노린다.

최대 레버리지: 3-5배. 그 이상은 절대 안 된다. 진심이다. 잡코인은 펌프 단계에서 "모든 지표가 숏이라고 말한" 후에도 추가로 +50% 할 수 있다. 고레버리지 = 청산.

해서는 안 되는 것: 다섯 가지 치명적 실수

1. 펌프 도중에 숏 치지 말라

"분명히 떨어질 거야!" — 맞다, 떨어진다. 하지만 언제? +200%에서 숏을 잡았는데 가격이 +150%로 떨어지기 전에 +600%까지 갔다면, +450%에서 이미 청산된 것이다. 기술적으로는 맞았다. 실질적으로는 파산이다.

규칙: 첫 번째 의미 있는 조정(고점 대비 -15% 이상)과 반전 구조 형성 후에만 진입하라.

2. 타이트한 스톱로스를 쓰지 말라

ATR 15%인 잡코인에 2% 스톱로스는 리스크 관리가 아니라 마켓 메이커에 대한 자선 행위다. 다음 변동성 급등에서 몇 분 안에 스톱이 털린다.

규칙: 스톱로스 >= 현재 타임프레임 ATR의 1.5배. 이상적으로는 2배.

3. 한 번의 매매에 모든 것을 걸지 말라

점수 6/6에서도 성공 확률은 약 65-70%다. 이는 10번의 매매 중 3번은 손실이라는 뜻이다. 매번 자본의 10%를 투입하면, 3연패 = -30% 드로다운. 심리적으로 그 후 더 나쁜 매매를 하게 된다.

규칙: 매매당 자본의 1-2%. 극도의 확신이 있을 때 최대 5%.

4. 유동성을 무시하지 말라

당신은 골드만삭스가 아니다. 토큰의 일 거래량이 200만 달러인데 5만 달러로 진입하려 한다면—당신 자신이 시장 이벤트가 된다. 당신의 진입이 가격을 움직이고, 당신의 청산도 가격을 움직인다. 슬리피지가 모든 이익을 먹어치운다.

규칙: 포지션 크기 <= 토큰 일 거래량의 1%.

5. 숏 기능이 없는 현물 시장에서 숏 치지 말라

당연해 보이지만, DEX에서 인버스 토큰을 사거나 "나중에 싸게 다시 사려고 현물을 파는" 것으로 "숏"을 치는 사람의 수는 놀랍도록 많다. 적절한 유동성이 있는 거래소의 선물을 사용하라. 아니면 아예 숏을 치지 말라.

모니터링 도구

CoinGlass (coinglass.com)

선물 분석의 핵심 도구:

• 청산 히트맵: 가격 차트 위의 청산 레벨 시각화
• 펀딩비: 거래소간 펀딩비 실시간 비교
• 미결제약정: 거래소별 종합 OI
• 롱/숏 비율: 롱과 숏의 비율(계정 수 및 거래량 기준)

Coinalyze (coinalyze.net)

심층 파생상품 분석:

• 종합 OI: 거래소별로 분류된 통합 미결제약정
• 청산: 롱/숏별 청산 히스토리
• OI 가중 펀딩비: 각 거래소 비중을 반영한 더 정확한 펀딩비

TradingView (tradingview.com)

차트 분석용:

• Pine Script로 캔들 패턴 자동화
• 앵커드 VWAP(내장 도구)
• 커뮤니티 인디케이터를 통한 CoinGlass 데이터 통합

Laevitas (laevitas.ch)

전문 파생상품 터미널:

• 감마 익스포저
• 옵션 플로우
• 행사가별 OI 히트맵

AI 에이전트를 활용한 자동화

위에서 설명한 모든 것은 자동화할 수 있고, 자동화해야 한다. 다음은 탐지 시스템의 아키텍처다:

import asyncio
import numpy as np
from dataclasses import dataclass
from enum import Enum

class AlertLevel(Enum):
    WATCH = "watch"
    PREPARE = "prepare"
    ENTRY = "entry"

@dataclass
class PumpDumpAlert:
    symbol: str
    level: AlertLevel
    score: int
    reasons: list[str]
    suggested_entry: float | None
    suggested_stop: float | None
    suggested_tp: list[float]
    timestamp: float

class PumpDumpDetector:
    """
    펌프 후 덤프를 탐지하는 AI 에이전트.

    파이프라인:
    1. 스캐닝: 거래량 Z-score > 3 + 가격 상승 > 100%
    2. 필터링: 펀딩비 스파이크 + OI 증가
    3. 대기: 5m/15m에서의 반전 패턴
    4. 알림: 스코어링 -> 통지
    """

    def __init__(
        self,
        exchange,
        symbols: list[str],
        volume_z_threshold: float = 3.0,
        funding_z_threshold: float = 2.0,
        min_pump_pct: float = 80.0,
        scan_interval_sec: int = 60,
    ):
        self.exchange = exchange
        self.symbols = symbols
        self.volume_z_threshold = volume_z_threshold
        self.funding_z_threshold = funding_z_threshold
        self.min_pump_pct = min_pump_pct
        self.scan_interval_sec = scan_interval_sec
        self.active_watches: dict[str, dict] = {}

    async def scan_loop(self):
        """메인 스캔 루프."""
        while True:
            candidates = await self._broad_scan()

            for candidate in candidates:
                symbol = candidate['symbol']

                if symbol not in self.active_watches:
                    self.active_watches[symbol] = {
                        'first_seen': asyncio.get_event_loop().time(),
                        'pump_peak': candidate['peak_price'],
                        'pump_start_approx': candidate.get('pump_start_price'),
                    }
                    await self._emit_alert(PumpDumpAlert(
                        symbol=symbol,
                        level=AlertLevel.WATCH,
                        score=0,
                        reasons=[f"Pump detected: +{candidate['pump_pct']}%"],
                        suggested_entry=None,
                        suggested_stop=None,
                        suggested_tp=[],
                        timestamp=asyncio.get_event_loop().time(),
                    ))

                analysis = await self._deep_analysis(symbol)

                if analysis['score'] >= 3:
                    entry = candidate['current_price']
                    stop = candidate['peak_price'] * 1.02  # 고점 위 2%

                    await self._emit_alert(PumpDumpAlert(
                        symbol=symbol,
                        level=AlertLevel.ENTRY if analysis['score'] >= 4 else AlertLevel.PREPARE,
                        score=analysis['score'],
                        reasons=analysis['reasons'],
                        suggested_entry=entry,
                        suggested_stop=stop,
                        suggested_tp=[
                            entry * 0.80,  # TP1: -20%
                            entry * 0.65,  # TP2: -35%
                            entry * 0.50,  # TP3: -50%
                        ],
                        timestamp=asyncio.get_event_loop().time(),
                    ))

            current_time = asyncio.get_event_loop().time()
            self.active_watches = {
                s: d for s, d in self.active_watches.items()
                if current_time - d['first_seen'] < 48 * 3600
            }

            await asyncio.sleep(self.scan_interval_sec)

    async def _broad_scan(self) -> list[dict]:
        """모든 심볼의 빠른 스캔."""
        ...

    async def _deep_analysis(self, symbol: str) -> dict:
        """
        특정 심볼의 심층 분석.
        6개 시그널을 모두 수집하고 수렴 점수를 계산.
        """
        funding = await self._get_funding_signal(symbol)

        oi = await self._get_oi_signal(symbol)

        volume = await self._get_volume_signal(symbol)

        patterns = await self._get_pattern_signals(symbol, timeframe='5m')

        vwap_pos = await self._get_vwap_position(symbol)

        liq_density = await self._get_liquidation_density(symbol)

        return confluence_score(
            funding, oi, volume, patterns, vwap_pos, liq_density
        )

    async def _emit_alert(self, alert: PumpDumpAlert):
        """알림 발송(Telegram, webhook 등)."""
        print(f"[{alert.level.value.upper()}] {alert.symbol} "
              f"Score: {alert.score}/6 | {', '.join(alert.reasons)}")
        ...

자동화를 위한 핵심 임계값

통계와 현실

솔직해지자. 이 전략은 성배가 아니다. 2024-2025년 데이터 기반 백테스트의 대략적인 통계는 다음과 같다:

핵심 한계:

1. 생존자 편향: 선물 거래소에서 거래되는 토큰만 분석한다. 가장 극단적인 펌프 앤 덤프는 숏이 불가능한 DEX에서 발생한다.

2. 유동성: 많은 잡코인 선물에서 의미 있는 포지션 크기에 대한 유동성이 부족하다. 슬리피지가 수익의 2-5%를 먹어치울 수 있다.

3. 마켓 메이커와의 싸움: 프로 MM은 이런 패턴을 알고 있으며, 숏 포지션의 스톱로스를 사냥하는 데 적극적으로 활용한다. 반전 패턴이 형성된 후의 페이크 펌프는 표준적인 수법이다.

4. 숏의 블랙 스완: 이론적으로 숏의 손실은 무한대다. 실질적으로는 스톱로스가 문제를 해결한다. 하지만 저유동성 순간에는 스톱이 설정 가격보다 크게 나쁜 가격으로 체결될 수 있다.

결론

잡코인 펌프 후 덤프를 숏 치는 것은 암호화폐에서 에지(통계적 우위)가 실제로 존재하는 몇 안 되는 전략 중 하나다. 이유: 개인 투자자의 대규모 비합리성이 예측 가능한 패턴을 만들어내고, 청산 캐스케이드의 메커니즘이 당신에게 유리한 방향으로 움직임을 증폭시킨다.

가져갈 세 가지 규칙:

1. 절대 임펄스를 숏 치지 말라. 3단계를 기다려라. 반전 패턴을 기다려라. OI 다이버전스를 기다려라. 인내심이 가장 중요한 도구이지, 어떤 영리한 지표가 아니다.

2. 시그널 수렴을 활용하라. 지표 하나는 노이즈다. 둘은 가설이다. 넷 이상이면 실행 가능한 셋업이다. 펀딩비 + OI + 패턴 + VWAP = 진입.

3. 레버리지가 아닌 포지션 크기를 관리하라. 매매당 2% 리스크, 최대 3-5배 레버리지, 스톱로스 >= 1.5 ATR. 지루한가? 그렇다. 하지만 지루한 트레이더만이 1년 후에도 시장에 남아 있다.

마지막으로 한 가지. 기억하라: 모든 덤프의 뒤에는 실제 돈을 잃은 실제 사람들이 있다. 그들 중 많은 이가 FOMO에 굴복한 초보자들이다. 우리는 시장 메커니즘을 분석하는 것이지 조작을 옹호하는 것이 아니다. 비효율성에서 수익을 내는 것은 정당하다. 그 비효율성을 만들어내는 것은 아니다.

펀딩비와 레버리지에 대한 영향에 대해 더 알고 싶다면 펀딩비가 레버리지를 죽인다 글을 참고하라. 트레이딩에서의 이상 탐지 방법에 대해서는 트레이딩 봇을 위한 이상 탐지를, 거래소간 펀딩비 차익거래에 대해서는 거래소간 펀딩비 차익거래를 참고하라.

유용한 링크

1. CoinGlass — 청산 히트맵
2. CoinGlass — 펀딩비
3. CoinGlass — 미결제약정
4. Coinalyze — 종합 미결제약정
5. Hyblock Capital — 청산 레벨
6. Laevitas — 파생상품 분석
7. TradingView — 앵커드 VWAP
8. Binance — 펀딩비 히스토리

인용

@article{soloviov2026shitcoinpumpdump,
  author = {Soloviov, Eugen},
  title = {잡코인 펌프 후 폭락을 잡는 방법: 체계적 접근법},
  year = {2026},
  url = {https://marketmaker.cc/ko/blog/post/shitcoin-pump-dump-strategies},
  version = {0.1.0},
  description = {잡코인 펌프 후 숏 전략의 체계적 분석. 펀딩비, OI, 거래량 분석, 캔들 패턴, 청산 캐스케이드. 실전 알고리즘 포함.}
}