Cara Menangkap Penurunan Setelah Pump Shitcoin: Pendekatan Sistematis

Setiap trader kripto pernah melihat ini setidaknya sekali: token yang kemarin tidak dikenal siapa pun naik +800% dalam 4 jam. Twitter meledak dengan emoji roket. Reddit penuh postingan "ini baru permulaan". Rekan kerjamu — yang sebulan lalu tidak tahu bedanya order book dengan menu McDonald's — kirim pesan "bro, masukin minimal seratus dolar dong." Dua belas jam kemudian, token sudah turun 85% dari puncaknya. Sunyi. Roket dihapus.

Pertanyaannya bukan apakah akan ada dump. Pertanyaannya adalah bagaimana mengambil keuntungan secara sistematis darinya tanpa hancur oleh pump itu sendiri.

Artikel ini bukan saran keuangan (disclaimer wajib yang tidak dibaca siapa pun, tapi para pengacara tetap bersikeras). Ini adalah uraian teknis mekanisme, sinyal, dan algoritma untuk mengidentifikasi titik pembalikan setelah pergerakan impulsif pada aset berlikuiditas rendah.

Anatomi Pump-and-Dump: Tiga Fase dari Satu Kegilaan

Sebelum shorting, kamu perlu memahami struktur fenomena ini. Setiap pump-and-dump shitcoin melewati tiga fase, masing-masing dengan tanda data karakteristiknya.

Fase 1: Akumulasi (Perburuan Senyap)

Durasi: dari beberapa jam hingga beberapa hari.

Seseorang — sekelompok orang dalam, grup Telegram terkoordinasi, atau sekadar pemain besar dengan keunggulan informasi — mulai membeli token tersebut. Dilakukan dengan hati-hati: order kecil, di beberapa exchange, sering saat sesi Asia (ketika likuiditas minimal dan perhatian tersebar).

Yang terlihat di data:

• Volume perdagangan meningkat bertahap (50-200% di atas rata-rata 7 hari), namun harga hampir tidak bergerak
• Sisi bid order book menebal: "dinding" muncul 2-5% di bawah harga saat ini
• Metrik on-chain (untuk token DEX): transfer besar ke exchange, pertumbuhan dompet pembeli unik
• Funding rate pada futures perpetual (jika ada) mulai sedikit meningkat

Pada fase ini, terlalu dini untuk shorting. Kamu belum tahu apakah ini akumulasi atau minat organik. Membedakan keduanya seringkali mustahil — perbedaannya hanya jelas dalam retrospeksi.

Fase 2: Impuls (Pesta)

Durasi: dari 30 menit hingga 12 jam.

Harga menembus level resistance kunci, dan kaskade dimulai. Stop-loss short-seller dilikuidasi. FOMO (Fear Of Missing Out) menyedot trader ritel. Crypto Twitter menjadi ruang gema. Setiap retweet adalah long berleverage 50x baru.

Tanda-tanda khas:

• Volume 1000-5000% di atas rata-rata (bukan salah ketik)
• Funding rate meroket ke 0,1-0,5% per 8 jam (normal adalah 0,01%)
• Open Interest tumbuh eksponensial: posisi baru dibuka lebih cepat dari yang ditutup
• Spread bid-ask melebar 3-10x karena kurangnya likuiditas di sisi ask
• Order book menunjukkan ruang kosong di atas: antara harga saat ini dan ask signifikan terdekat — kekosongan

Shorting pada fase ini adalah bunuh diri. Ini seperti berdiri di depan kereta karena "akhirnya pasti berhenti." Ya, akan berhenti. Tapi saat itu, kamu sudah terlikuidasi. Lebih lanjut di bawah pada bagian "Apa yang TIDAK Boleh Dilakukan."

Fase 3: Distribusi dan Crash (Mabuk Setelah Pesta)

Durasi: dari 2 hingga 48 jam.

Orang dalam mulai mengambil profit. Harga membuat koreksi bermakna pertama (-15-30% dari puncak). Trader ritel "membeli dip." Harga memantul. Lalu turun lagi. Setiap pantulan berikutnya lebih lemah. Setiap penurunan lebih dalam.

Yang terjadi di data:

• Volume tetap tinggi namun bergeser ke sisi jual
• Funding rate mulai menurun tapi masih abnormal tinggi
• Open Interest berhenti tumbuh atau mulai turun (long menutup posisi)
• Order jual pasar besar muncul, "memakan" order book beberapa level ke bawah
• On-chain: transfer besar dari dompet orang dalam ke exchange

Ini adalah zona perburuan. Di sinilah pekerjaan dimulai.

Sinyal Kunci untuk Masuk Short

Setiap sinyal sendirian lemah. Kombinasi tiga atau lebih sudah merupakan hipotesis yang layak.

1. Funding Rate: Pajak atas Keserakahan

Funding rate adalah biaya memegang posisi pada futures perpetual. Ketika semua orang ingin long, long membayar short. Semakin tinggi rate, semakin miring pasar ke satu sisi.

Mengapa ini berhasil: pada funding rate 0,3% per 8 jam, long membayar ~1% per hari hanya untuk memegang posisi. Dengan leverage 10x, itu 10% dari modal per hari. Ini tidak bisa bertahan lama — posisi mulai ditutup, mendorong harga turun.

Catatan: funding ekstrem saja bukan sinyal short. Bisa tetap tinggi selama berjam-jam atau bahkan berhari-hari sementara harga terus naik. Funding adalah filter (konfirmasi kemiringan), bukan trigger (titik entry).

def funding_rate_signal(
    current_rate: float,
    historical_rates: list[float],
    lookback: int = 90,  # 90 periode = 30 hari
) -> dict:
    """
    Menilai tingkat anomali funding rate saat ini.

    Mengembalikan:
        signal: 'neutral' | 'elevated' | 'extreme' | 'insane'
        z_score: float — deviasi dari norma
        percentile: float — persentil dalam data historis
    """
    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),  # % disetahunkan
    }

2. Open Interest: Siapa yang Terjebak

Open Interest (OI) adalah jumlah total kontrak terbuka di futures. Ketika OI naik bersamaan dengan harga — peserta baru masuk pasar (kebanyakan long). Ketika harga mulai turun tapi OI tetap tinggi — long-long itu terjebak. Likuidasi mereka akan memicu dump.

Pola kunci:

Momen paling berbahaya bagi long dan terbaik bagi short: harga mulai turun, tapi OI masih di puncaknya. Artinya long terbuka belum menutup — mereka berharap ada pantulan. Ketika harapan itu habis, kaskade likuidasi dimulai.

def oi_divergence_signal(
    prices: list[float],
    oi_values: list[float],
    window: int = 12,  # 12 candle (mis. 12 x 5 menit = 1 jam)
) -> dict:
    """
    Deteksi divergensi harga/OI.

    Divergensi OI bullish: harga turun, OI tinggi — long terjebak.
    """
    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  # harga turun 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. Analisis Volume: Kebenaran dalam Tick

Volume adalah satu-satunya indikator pasar yang tidak bisa dipalsukan (yah, hampir — wash trading di beberapa exchange masih nyata, tapi venue teratas sudah semakin baik melawannya).

Sinyal untuk shorting:

Volume menurun pada rally. Tanda klasik kelemahan. Harga membuat high baru, tapi volume pada pergerakan itu lebih rendah dari sebelumnya. Pembeli kehabisan tenaga.

Lonjakan volume pada penurunan. Jika koreksi -10% terjadi dengan volume melebihi volume rally terakhir — penjual telah mengambil inisiatif.

Breakout palsu dengan volume rendah. Harga menembus high lokal, namun volume breakout 2-3 kali di bawah rata-rata. Ini jebakan bagi pembeli: harga cepat kembali.

def volume_exhaustion_signal(
    candles: list[dict],  # [{open, high, low, close, volume, timestamp}, ...]
    pump_start_idx: int,
) -> dict:
    """
    Analisis kelelahan volume setelah pump.
    """
    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. Pola Candlestick: Sekolah Lama yang Berhasil

Ya, analisis candlestick berasal dari abad ke-17, Munehisa Homma dan futures beras. Ya, 90% "strategi candlestick" di YouTube adalah omong kosong. Namun pada timeframe 5 menit dan 15 menit setelah pump, pola tertentu memiliki kekuatan prediktif yang signifikan secara statistik. Alasannya sederhana: pola-pola ini mencerminkan mikrostruktur nyata — serah terima kendali dari pembeli ke penjual.

Pola yang layak dipantau:

Sangat penting: pola tanpa konteks adalah noise. Shooting Star pada pullback acak tidak berarti apa-apa. Shooting Star di puncak pump dengan funding rate anomali dan divergensi OI — itu cerita yang sama sekali berbeda.

def detect_reversal_patterns(
    candles: list[dict],
    min_upper_shadow_ratio: float = 2.0,  # bayangan > 2x badan untuk shooting star
) -> list[dict]:
    """
    Deteksi pola pembalikan bearish.
    """
    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']):  # bearish
            signals.append({
                'pattern': 'shooting_star',
                'index': i,
                'timestamp': c['timestamp'],
                'strength': upper_shadow / total_range,
            })

        prev = candles[i - 1]
        if (prev['close'] > prev['open']  # sebelumnya bullish
            and c['close'] < c['open']      # saat ini bearish
            and c['open'] > prev['close']   # buka di atas close sebelumnya
            and c['close'] < prev['open']): # tutup di bawah open sebelumnya
            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']        # pertama bullish
                and c2_body < c1_body * 0.3      # kedua kecil (doji)
                and c3['close'] < c3['open']     # ketiga bearish
                and c3_body > c1_body * 0.5      # ketiga cukup besar
                and c3['close'] < c1['close']):  # ketiga tutup di bawah close pertama
                signals.append({
                    'pattern': 'evening_star',
                    'index': i,
                    'timestamp': c['timestamp'],
                    'strength': c3_body / c1_body,
                })

    return signals

5. VWAP: Jangkar Realitas

VWAP (Volume-Weighted Average Price) adalah harga rata-rata tertimbang volume. Anchored VWAP dari awal pump menunjukkan harga masuk rata-rata bagi semua peserta yang membeli selama impuls.

Mengapa ini penting: ketika harga turun di bawah anchored VWAP — rata-rata pembeli merugi. Tekanan psikologis meningkat. Mereka yang membeli "murah" (di awal pump) mulai mengambil profit. Mereka yang membeli di puncak — panik.

Aturan: penembusan di bawah anchored VWAP dengan volume tinggi adalah sinyal kuat untuk shorting atau menambah posisi.

def anchored_vwap(
    candles: list[dict],
    anchor_idx: int,
) -> list[float]:
    """
    Hitung Anchored VWAP dari titik tertentu (awal pump).
    """
    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. Liquidation Cascade: Efek Domino

Ini adalah mekanisme dump paling kuat — dan paling menguntungkan bagi short. Logikanya sederhana:

1. Seorang trader membuka long berleverage 20x. Likuidasi terpicu jika harga turun 5%.
2. Harga turun 5%. Posisi dilikuidasi — exchange menjual di pasar.
3. Penjualan pasar mendorong harga lebih rendah. Ini melikuidasi trader berikutnya.
4. Dan seterusnya. Kaskade.

Cara melihat ini datang:

CoinGlass Liquidation Heatmap menunjukkan di mana level likuidasi terkonsentrasi. Jika di bawah harga saat ini kamu melihat "dinding" likuidasi — penurunan ke level tersebut kemungkinan besar akan memicu kaskade.

Sinyal kaskade: jika di zona -5% hingga -15% dari harga saat ini terdapat lebih dari $5 juta likuidasi terkonsentrasi (untuk shitcoin dengan volume harian$50-200 juta) — kaskade kemungkinan besar terjadi.

Algoritma Praktis: Filter -> Entry -> Risiko

Teori itu bagus. Sekarang — pipeline-nya.

Langkah 1: Penyaringan (Scanner)

Dari ribuan token, kamu perlu mengisolasi yang berada di fase pasca-pump. Kriteria:

def pump_scanner(
    symbols: list[str],
    exchange,  # instans exchange ccxt
    lookback_hours: int = 24,
    min_pump_pct: float = 100,  # minimum +100% selama lookback
    min_volume_z: float = 3,    # volume Z-score > 3
) -> list[dict]:
    """
    Scanner untuk token dalam fase pasca-pump.
    """
    import numpy as np

    candidates = []

    for symbol in symbols:
        try:
            candles = exchange.fetch_ohlcv(symbol, '1h', limit=168)  # 7 hari
            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

Langkah 2: Konvergensi Sinyal (Scoring)

Untuk setiap kandidat — evaluasi di seluruh enam parameter:

def confluence_score(
    funding_signal: dict,
    oi_signal: dict,
    volume_signal: dict,
    pattern_signals: list[dict],
    vwap_position: float,  # harga / VWAP (< 1 = di bawah VWAP)
    liquidation_density: float,  # likuidasi $Juta di bawah harga saat ini
) -> dict:
    """
    Skor komposit untuk entry short.
    Skor 0-6, di mana setiap faktor = 0 atau 1 poin.
    """
    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"Long terjebak: OI persentil {oi_signal['oi_percentile']}")

    if volume_signal['signal'] == 'exhaustion':
        score += 1
        reasons.append(f"Degradasi volume: {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"Pola: {strong_patterns[-1]['pattern']}")

    if vwap_position < 0.98:  # harga 2%+ di bawah VWAP
        score += 1
        reasons.append(f"Di bawah VWAP: {round((1 - vwap_position) * 100, 1)}%")

    if liquidation_density > 5:  # > $5 juta likuidasi
        score += 1
        reasons.append(f"Kepadatan likuidasi: ${liquidation_density}Juta")

    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,
    }

Langkah 3: Entry dan Manajemen Risiko

Entry:

• Skor >= 4: masuk dengan 50% posisi
• Skor = 3: masuk dengan 25% posisi
• Skor < 3: tunggu

Stop-loss:

• Di atas swing high terakhir + buffer 1-2%
• BUKAN stop ketat. Volatilitas shitcoin akan membunuhmu. Minimum 5-10% dari entry.
• Pada Skor = 6, stop 8-12% dapat diterima (lebih yakin = stop lebih lebar, tapi leverage lebih kecil)

Take-profit:

• TP1 (50% posisi): level support utama berikutnya atau -20% dari entry
• TP2 (30% posisi): VWAP dari awal pump
• TP3 (20% posisi): level sebelum pump

Ukuran posisi:

$\text{Ukuran posisi} = \frac{\text{Risiko per trade}}{\text{Jarak stop}} = \frac{0{,}02 \times \text{Modal}}{\text{Stop \%}}$

Dengan modal $10.000, risiko 2% per trade, dan stop 8%:

$\text{Posisi} = \frac{200}{0{,}08} = \$2.500$

Dengan leverage 3x: kamu mempertaruhkan $200 (2$500-$1.250 (TP1-TP3).

Leverage maksimum: 3-5x. Tidak lebih. Serius. Shitcoin dalam fase pump bisa naik lagi +50% setelah "semua indikator bilang short." Leverage tinggi = likuidasi.

Apa yang TIDAK Boleh Dilakukan: Lima Dosa Mematikan

1. JANGAN short saat pump

"Tapi pasti akan turun!" — ya, akan turun. Tapi kapan? Jika kamu masuk short di +200% dan harga naik +600% sebelum turun ke +150% — kamu dilikuidasi di +450%. Secara teknis kamu benar. Secara praktis — bangkrut.

Aturan: masuk hanya setelah pullback pertama yang signifikan (-15% atau lebih dari puncak) dan terbentuknya struktur pembalikan.

2. JANGAN gunakan stop-loss ketat

Stop-loss 2% pada shitcoin dengan ATR 15% bukan manajemen risiko — itu adalah sumbangan kepada market maker. Stop-mu akan terkena dalam hitungan menit selama wick volatil berikutnya.

Aturan: stop-loss >= 1,5 x ATR pada timeframe saat ini. Idealnya 2x.

3. JANGAN taruh semua pada satu trade

Bahkan dengan Skor 6/6, probabilitas sukses sekitar 65-70%. Artinya 3 dari 10 trade adalah kerugian. Jika kamu menempatkan 10% modal pada masing-masing — tiga kerugian berturut-turut = drawdown -30%. Setelah itu, kamu akan mulai trading lebih buruk secara psikologis.

Aturan: 1-2% modal per trade. Maksimum 5% dengan keyakinan ekstrem.

4. JANGAN abaikan likuiditas

Kamu bukan Goldman Sachs. Jika volume harian token adalah $2 juta dan kamu mencoba masuk dengan$50 ribu — kamu menjadi peristiwa pasar. Entri-mu menggerakkan harga, keluarmu menggerakkan harga. Slippage memakan semua profit.

Aturan: ukuran posisi <= 1% dari volume harian token.

5. JANGAN short di pasar spot tanpa kemampuan short

Ini tampak jelas, tapi jumlah orang yang "shorting" dengan membeli token invers di DEX atau dengan "menjual spot yang mereka rencanakan untuk dibeli kembali lebih murah" sungguh mencengangkan. Gunakan futures di exchange dengan likuiditas yang tepat. Atau jangan short sama sekali.

Alat Pemantauan

CoinGlass (coinglass.com)

Alat utama untuk analisis futures:

• Liquidation Heatmap: visualisasi level likuidasi pada grafik harga
• Funding Rate: perbandingan funding rate antar exchange secara real time
• Open Interest: OI gabungan per exchange
• Long/Short Ratio: rasio long terhadap short (berdasarkan jumlah akun dan volume)

Coinalyze (coinalyze.net)

Analitik derivatif mendalam:

• Aggregated OI: Open Interest gabungan dipecah per exchange
• Liquidations: riwayat likuidasi dipecah berdasarkan long/short
• OI-weighted Funding Rate: funding rate yang lebih akurat dengan mempertimbangkan porsi setiap exchange

TradingView (tradingview.com)

Untuk analisis grafik:

• Pine Script untuk mengotomatiskan pola candlestick
• Anchored VWAP (alat bawaan)
• Overlay data CoinGlass melalui indikator komunitas

Laevitas (laevitas.ch)

Terminal derivatif profesional:

• Gamma exposure
• Options flow
• OI heatmap per strike

Otomatisasi dengan AI Agent

Semua yang dijelaskan di atas dapat (dan harus) diotomatiskan. Berikut arsitektur sistem deteksi:

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 agent untuk mendeteksi dump pasca-pump.

    Pipeline:
    1. Scanning: volume Z-score > 3 + kenaikan harga > 100%
    2. Filtering: lonjakan funding + pertumbuhan OI
    3. Waiting: pola pembalikan pada 5m/15m
    4. Alert: scoring -> notifikasi
    """

    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):
        """Loop pemindaian utama."""
        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 terdeteksi: +{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% di atas puncak

                    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]:
        """Pemindaian cepat semua simbol."""
        ...

    async def _deep_analysis(self, symbol: str) -> dict:
        """
        Analisis mendalam simbol tertentu.
        Mengumpulkan semua 6 sinyal dan menghitung confluence score.
        """
        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):
        """Kirim alert (Telegram, webhook, dll.)."""
        print(f"[{alert.level.value.upper()}] {alert.symbol} "
              f"Skor: {alert.score}/6 | {', '.join(alert.reasons)}")
        ...

Ambang Batas Kunci untuk Otomatisasi

Statistik dan Realita

Mari jujur. Strategi ini bukan holy grail. Berikut statistik backtest perkiraan pada data 2024-2025:

Keterbatasan utama:

1. Survivorship bias: kami hanya menganalisis token yang diperdagangkan di exchange futures. Pump-and-dump paling liar terjadi di DEX, di mana shorting tidak mungkin dilakukan.

2. Likuiditas: pada banyak futures shitcoin, tidak ada cukup likuiditas untuk ukuran posisi yang berarti. Slippage bisa memakan 2-5% profit.

3. Melawan market maker: MM profesional mengetahui pola-pola ini dan secara aktif menggunakannya untuk memburu stop-loss short-seller. Pump palsu setelah pola pembalikan terbentuk — itu permainan standar.

4. Black swan pada short: secara teoritis, short memiliki potensi kerugian tak terbatas. Dalam praktiknya, stop-loss menyelesaikan masalah — namun saat momen likuiditas rendah, stop bisa terisi jauh lebih buruk dari harga yang ditentukan.

Kesimpulan

Shorting dump setelah pump shitcoin adalah salah satu dari sedikit strategi di kripto di mana edge (keunggulan statistik) benar-benar ada. Alasannya: irasionalitas massal trader ritel menciptakan pola yang dapat diprediksi, dan mekanika liquidation cascade memperkuat pergerakan ke arahmu.

Tiga aturan untuk dibawa pulang:

1. Jangan pernah short saat impuls. Tunggu Fase 3. Tunggu pola pembalikan. Tunggu divergensi OI. Kesabaran adalah alat utamamu, bukan indikator canggih apa pun.

2. Gunakan konvergensi sinyal. Satu indikator adalah noise. Dua adalah hipotesis. Empat atau lebih adalah setup yang bisa diperdagangkan. Funding + OI + pola + VWAP = entry.

3. Kelola ukuran posisi, bukan leverage. Risiko 2% per trade, leverage maksimum 3-5x, stop-loss >= 1,5 ATR. Membosankan? Ya. Tapi trader yang membosankan adalah satu-satunya yang masih ada di pasar setahun kemudian.

Dan satu hal terakhir. Ingat: di balik setiap dump, ada orang-orang nyata yang kehilangan uang nyata. Banyak dari mereka adalah pemula yang tunduk pada FOMO. Kami menganalisis mekanisme pasar, bukan mengadvokasi manipulasi. Mendapat keuntungan dari inefisiensi adalah sah. Menciptakan inefisiensi itu tidak.

Untuk lebih lanjut tentang funding rate dan dampaknya pada leverage, lihat artikel kami Funding Rate Membunuh Leverage-mu. Tentang metode deteksi anomali dalam trading — Deteksi Anomali untuk Melindungi Bot Trading. Tentang arbitrase funding rate antar exchange — Arbitrase Funding Rate Lintas Exchange.

Tautan Berguna

1. CoinGlass — Liquidation Heatmap
2. CoinGlass — Funding Rate
3. CoinGlass — Open Interest
4. Coinalyze — Aggregated Open Interest
5. Hyblock Capital — Liquidation Levels
6. Laevitas — Derivatives Analytics
7. TradingView — Anchored VWAP
8. Binance — Funding Rate History

Sitasi

@article{soloviov2026shitcoinpumpdump,
  author = {Soloviov, Eugen},
  title = {How to Catch Drops After Shitcoin Pumps: A Systematic Approach},
  year = {2026},
  url = {https://marketmaker.cc/id/blog/post/shitcoin-pump-dump-strategies},
  version = {0.1.0},
  description = {Uraian sistematis strategi shorting setelah pump shitcoin. Funding rate, OI, analisis volume, pola candlestick, liquidation cascade. Dilengkapi algoritma praktis.}
}