Cara Menangkap Kejatuhan Selepas Pump Shitcoin: Pendekatan Sistematik

Setiap pedagang kripto pernah melihat ini sekurang-kurangnya sekali: token yang tidak dikenali sesiapa semalam melonjak +800% dalam masa 4 jam. Twitter meledak dengan emoji roket. Reddit dipenuhi dengan siaran "ini baru permulaan". Rakan sekerja anda — yang sebulan lalu tidak tahu bezanya buku pesanan dengan pesanan McDonald's — menghantar mesej kepada anda "bro, masukkan sekurang-kurangnya seratus ringgit." Dua belas jam kemudian, token itu telah kehilangan 85% daripada kemuncaknya. Senyap. Roket dipadam.

Persoalannya bukan sama ada dump akan berlaku. Persoalannya adalah bagaimana untuk meraih keuntungan secara sistematik daripadanya tanpa dihancurkan oleh pump itu sendiri.

Artikel ini bukan nasihat kewangan (penafian wajib yang tiada siapa membaca, tetapi peguam mendesak). Ini adalah huraian teknikal mekanik, isyarat, dan algoritma untuk mengenal pasti titik pembalikan selepas pergerakan impuls pada aset berlikuiditi rendah.

Anatomi Pump-and-Dump: Tiga Fasa Satu Kegilaan

Sebelum membuat short, anda perlu memahami struktur fenomena ini. Setiap pump-and-dump shitcoin melalui tiga fasa, masing-masing dengan tandatangan data tersendiri.

Fasa 1: Pengumpulan (Pemburuan Senyap)

Tempoh: dari beberapa jam hingga beberapa hari.

Seseorang — sekumpulan orang dalam, kumpulan Telegram yang terkoordinasi, atau sekadar pemain besar dengan kelebihan maklumat — mula membeli token tersebut. Ia dilakukan dengan berhati-hati: pesanan kecil, merentasi pelbagai bursa, sering semasa sesi Asia (apabila kecairan minimum dan perhatian berselerak).

Apa yang kelihatan dalam data:

• Volum dagangan beransur meningkat (50-200% di atas purata 7 hari), tetapi harga hampir tidak bergerak
• Bahagian bid buku pesanan menebal: "dinding" muncul 2-5% di bawah harga semasa
• Metrik on-chain (untuk token DEX): pemindahan besar ke bursa, pertumbuhan dompet pembeli unik
• Kadar funding pada niaga hadapan kekal (jika wujud) mula sedikit meningkat

Pada fasa ini, terlalu awal untuk membuat short. Anda belum tahu sama ada ini pengumpulan atau minat organik. Membezakan satu daripada yang lain sering mustahil — perbezaannya hanya jelas selepas kejadian.

Fasa 2: Impuls (Pesta)

Tempoh: dari 30 minit hingga 12 jam.

Harga menembusi paras rintangan utama, dan lata bermula. Stop-loss penjual pendek dilikuidasi. FOMO (Fear Of Missing Out) menyedut pedagang runcit. Crypto Twitter menjadi bilik gema. Setiap retweet adalah long berleveraj 50x baharu.

Tandatangan ciri:

• Volum 1000-5000% di atas purata (bukan silap taip)
• Kadar funding melambung ke 0.1-0.5% setiap 8 jam (normal ialah 0.01%)
• Open Interest tumbuh secara eksponen: kedudukan baharu dibuka lebih cepat daripada ditutup
• Spread bid-ask melebar 3-10x akibat kekurangan kecairan bahagian ask
• Buku pesanan menunjukkan vakum di atas: antara harga semasa dan ask bererti terdekat — kekosongan

Membuat short semasa fasa ini adalah bunuh diri. Ia seperti berdiri di hadapan kereta api kerana "ia pasti akan berhenti." Ya, ia akan berhenti. Tetapi pada ketika itu, anda sudah dilikuidasi. Lebih lanjut mengenai ini di bawah dalam bahagian "Apa yang TIDAK Patut Dilakukan".

Fasa 3: Pengagihan dan Runtuh (Mabuk Selepas)

Tempoh: dari 2 hingga 48 jam.

Orang dalam mula mengambil keuntungan. Harga membuat pembetulan pertama yang bermakna (-15-30% dari kemuncak). Pedagang runcit "membeli dip." Harga melantun. Kemudian jatuh semula. Setiap lantunan berikutnya lebih lemah. Setiap kejatuhan lebih dalam.

Apa yang berlaku dalam data:

• Volum kekal tinggi tetapi beralih ke bahagian jual
• Kadar funding mula menurun tetapi masih luar biasa tinggi
• Open Interest berhenti berkembang atau mula jatuh (long ditutup)
• Pesanan jual pasaran besar muncul, "menelan" buku pesanan beberapa aras ke bawah
• On-chain: pemindahan besar dari dompet orang dalam ke bursa

Ini adalah zon pemburuan. Di sinilah kerja bermula.

Isyarat Utama untuk Masuk Short

Setiap isyarat sahaja adalah lemah. Gabungan tiga atau lebih sudah merupakan hipotesis yang boleh digunakan.

1. Kadar Funding: Cukai ke atas Ketamakan

Kadar funding adalah kos memegang kedudukan pada niaga hadapan kekal. Apabila semua orang ingin menjadi long, long membayar short. Lebih tinggi kadarnya, lebih condong pasaran ke satu sisi.

Mengapa ini berfungsi: pada kadar funding 0.3% per 8 jam, long membayar ~1% sehari hanya untuk memegang kedudukan mereka. Pada leveraj 10x, itu 10% modal sehari. Ini tidak boleh berlangsung lama — kedudukan mula ditutup, menolak harga ke bawah.

Amaran: funding ekstrem sahaja bukan isyarat short. Ia boleh kekal tinggi selama berjam-jam atau bahkan berhari-hari sementara harga terus naik. Funding adalah penapis (pengesahan condong), bukan pencetus (titik masuk).

def funding_rate_signal(
    current_rate: float,
    historical_rates: list[float],
    lookback: int = 90,  # 90 periods = 30 days
) -> dict:
    """
    Assess the anomaly level of the current funding rate.

    Returns:
        signal: 'neutral' | 'elevated' | 'extreme' | 'insane'
        z_score: float — deviation from the norm
        percentile: float — percentile in historical data
    """
    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),  # % annualized
    }

2. Open Interest: Siapa yang Terperangkap

Open Interest (OI) adalah jumlah kontrak terbuka dalam niaga hadapan. Apabila OI naik bersama harga — peserta baharu memasuki pasaran (kebanyakannya long). Apabila harga mula jatuh tetapi OI kekal tinggi — long tersebut terperangkap. Likuidasi mereka akan memacu dump.

Corak utama:

Detik paling berbahaya untuk long dan terbaik untuk short: harga mula jatuh, tetapi OI masih berada pada kemuncaknya. Ini bermakna long terbuka belum ditutup — mereka mengharapkan lantunan. Apabila harapan itu habis, lata likuidasi bermula.

def oi_divergence_signal(
    prices: list[float],
    oi_values: list[float],
    window: int = 12,  # 12 candles (e.g., 12 x 5 min = 1 hour)
) -> dict:
    """
    Detect price/OI divergence.

    Bullish OI divergence: price falling, OI high — longs are trapped.
    """
    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  # price dropped by 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 Volum: Kebenaran dalam Tik

Volum adalah satu-satunya penunjuk pasaran yang tidak boleh dipalsukan (baik, hampir — wash trading di sesetengah bursa masih realiti, tetapi platform teratas semakin baik dalam memeranginya).

Isyarat untuk shorting:

Volum menurun pada rali. Tanda kelemahan klasik. Harga membuat paras tinggi baharu, tetapi volum pada pergerakan itu lebih rendah daripada sebelumnya. Pembeli kehabisan tenaga.

Lonjakan volum pada kejatuhan. Jika pembetulan -10% berlaku pada volum melebihi volum rali terakhir — penjual telah mengambil alih inisiatif.

Pecahan palsu dengan volum rendah. Harga menembusi paras tinggi tempatan, tetapi volum pecahan 2-3 kali di bawah purata. Ini adalah perangkap untuk pembeli: harga cepat kembali.

def volume_exhaustion_signal(
    candles: list[dict],  # [{open, high, low, close, volume, timestamp}, ...]
    pump_start_idx: int,
) -> dict:
    """
    Volume exhaustion analysis after a 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. Corak Candlestick: Sekolah Lama yang Berkesan

Ya, analisis candlestick berasal dari abad ke-17, Munehisa Homma dan niaga hadapan beras. Ya, 90% "strategi candlestick" di YouTube adalah sampah. Tetapi pada kerangka waktu 5 minit dan 15 minit selepas pump, corak tertentu mempunyai kuasa ramalan yang signifikan secara statistik. Sebabnya mudah: ia mencerminkan mikrostruktur sebenar — peralihan kawalan daripada pembeli kepada penjual.

Corak yang patut dipantau:

Amat penting: corak tanpa konteks adalah hingar. Shooting Star pada pemulihan rawak tidak bermakna apa-apa. Shooting Star pada kemuncak pump dengan kadar funding luar biasa dan divergens OI — itu cerita yang berbeza sepenuhnya.

def detect_reversal_patterns(
    candles: list[dict],
    min_upper_shadow_ratio: float = 2.0,  # shadow > 2x body for shooting star
) -> list[dict]:
    """
    Detect bearish reversal patterns.
    """
    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']  # previous is bullish
            and c['close'] < c['open']      # current is bearish
            and c['open'] > prev['close']   # opens above previous close
            and c['close'] < prev['open']): # closes below previous 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']        # first is bullish
                and c2_body < c1_body * 0.3      # second is small (doji)
                and c3['close'] < c3['open']     # third is bearish
                and c3_body > c1_body * 0.5      # third is large enough
                and c3['close'] < c1['close']):  # third closes below first's close
                signals.append({
                    'pattern': 'evening_star',
                    'index': i,
                    'timestamp': c['timestamp'],
                    'strength': c3_body / c1_body,
                })

    return signals

5. VWAP: Sauh Realiti

VWAP (Volume-Weighted Average Price) adalah harga purata berwajaran volum. VWAP berlabuh dari permulaan pump menunjukkan harga masuk purata bagi semua peserta yang membeli semasa impuls.

Mengapa ini penting: apabila harga jatuh di bawah VWAP berlabuh — pembeli purata berada dalam kerugian. Tekanan psikologi membina. Mereka yang membeli "murah" (pada permulaan pump) mula mengambil keuntungan. Mereka yang membeli pada kemuncak — panik.

Peraturan: pecahan di bawah VWAP berlabuh pada volum tinggi adalah isyarat kuat untuk membuat short atau menambah kedudukan.

def anchored_vwap(
    candles: list[dict],
    anchor_idx: int,
) -> list[float]:
    """
    Calculate Anchored VWAP from a given point (start of 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. Lata Likuidasi: Kesan Domino

Ini adalah mekanisme dump paling berkuasa — dan yang paling menguntungkan untuk short. Logiknya mudah:

1. Seorang pedagang membuka long berleveraj 20x. Likuidasi dicetuskan jika harga jatuh 5%.
2. Harga jatuh 5%. Kedudukan dilikuidasi — bursa menjual secara pasaran.
3. Jualan pasaran menolak harga lebih rendah. Ini melikuidasi pedagang berikutnya.
4. Dan seterusnya. Lata.

Cara menjangkanya:

CoinGlass Liquidation Heatmap menunjukkan di mana aras likuidasi tertumpu. Jika di bawah harga semasa anda melihat "dinding" likuidasi — kejatuhan ke aras itu kemungkinan besar akan mencetuskan lata.

Isyarat lata: jika dalam zon -5% hingga -15% dari harga semasa terdapat lebih $5M likuidasi tertumpu (untuk shitcoin dengan volum harian$50-200M) — lata berkemungkinan besar.

Algoritma Praktikal: Tapis -> Masuk -> Risiko

Teori adalah indah. Kini — saluran paip.

Langkah 1: Penapisan (Pengimbas)

Daripada ribuan token, anda perlu mengasingkan mereka yang berada dalam fasa pasca-pump. Kriteria:

def pump_scanner(
    symbols: list[str],
    exchange,  # ccxt exchange instance
    lookback_hours: int = 24,
    min_pump_pct: float = 100,  # minimum +100% over lookback
    min_volume_z: float = 3,    # volume Z-score > 3
) -> list[dict]:
    """
    Scanner for tokens in the post-pump phase.
    """
    import numpy as np

    candidates = []

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

Untuk setiap calon — penilaian merentasi semua enam parameter:

def confluence_score(
    funding_signal: dict,
    oi_signal: dict,
    volume_signal: dict,
    pattern_signals: list[dict],
    vwap_position: float,  # price / VWAP (< 1 = below VWAP)
    liquidation_density: float,  # $M liquidations below current price
) -> dict:
    """
    Composite score for short entry.
    Score 0-6, where each factor = 0 or 1 point.
    """
    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:  # price 2%+ below VWAP
        score += 1
        reasons.append(f"Below VWAP: {round((1 - vwap_position) * 100, 1)}%")

    if liquidation_density > 5:  # > $5M liquidations
        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,
    }

Langkah 3: Masuk dan Pengurusan Risiko

Masuk:

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

Stop-loss:

• Di atas paras tinggi ayunan terakhir + penampan 1-2%
• BUKAN stop ketat. Volatiliti pada shitcoin akan membunuh anda. Minimum 5-10% dari masuk.
• Pada Skor = 6, stop 8-12% boleh diterima (lebih keyakinan = stop lebih lebar, tetapi leveraj lebih rendah)

Take-profit:

• TP1 (50% kedudukan): aras sokongan utama seterusnya atau -20% dari masuk
• TP2 (30% kedudukan): VWAP dari permulaan pump
• TP3 (20% kedudukan): aras pra-pump

Saiz kedudukan:

$\text{Saiz kedudukan} = \frac{\text{Risiko per dagangan}}{\text{Jarak stop}} = \frac{0.02 \times \text{Modal}}{\text{Stop \%}}$

Dengan modal $10,000, risiko 2% per dagangan, dan stop 8%:

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

Dengan leveraj 3x: anda mempertaruhkan $200 (2$500-$1,250 (TP1-TP3).

Leveraj maksimum: 3-5x. Tidak lebih. Serius. Shitcoin dalam fasa pump boleh melakukan +50% lagi selepas "semua penunjuk mengatakan short." Leveraj tinggi = likuidasi.

Apa yang TIDAK Patut Dilakukan: Lima Dosa Maut

1. JANGAN short semasa pump

"Tapi ia pasti akan jatuh!" — ya, ia akan jatuh. Tapi bila? Jika anda masuk short pada +200% dan harga melakukan +600% sebelum jatuh ke +150% — anda dilikuidasi pada +450%. Secara teknikal anda betul. Secara praktikalnya — muflis.

Peraturan: masuk hanya selepas penarikan balik pertama yang signifikan (-15% atau lebih dari kemuncak) dan pembentukan struktur pembalikan.

2. JANGAN gunakan stop-loss ketat

Stop-loss 2% pada shitcoin dengan ATR 15% bukan pengurusan risiko — ia adalah derma kepada pembuat pasaran. Stop anda akan kena dalam beberapa minit semasa sumbu volatil seterusnya.

Peraturan: stop-loss >= 1.5 x ATR kerangka waktu semasa. Idealnya 2x.

3. JANGAN pertaruhkan semua pada satu dagangan

Walaupun dengan Skor 6/6, kebarangkalian kejayaan adalah sekitar 65-70%. Ini bermakna 3 daripada 10 dagangan adalah kerugian. Jika anda meletakkan 10% modal pada setiap satu — tiga kerugian berturutan = drawdown -30%. Selepas itu, anda akan berdagang lebih buruk dari segi psikologi.

Peraturan: 1-2% modal per dagangan. Maksimum 5% dengan keyakinan melampau.

4. JANGAN abaikan kecairan

Anda bukan Goldman Sachs. Jika volum harian token adalah $2M dan anda cuba masuk dengan$50K — anda menjadi peristiwa pasaran. Masuk anda menggerakkan harga, keluar anda menggerakkan harga. Slippage memakan semua keuntungan.

Peraturan: saiz kedudukan <= 1% daripada volum harian token.

5. JANGAN short pada pasaran spot tanpa keupayaan short

Ini kelihatan jelas, tetapi bilangan orang yang "short" dengan membeli token songsang pada DEX atau dengan "menjual spot yang mereka rancang untuk dibeli semula lebih murah" adalah mengejutkan. Gunakan niaga hadapan di bursa dengan kecairan yang betul. Atau jangan short langsung.

Alat Pemantauan

CoinGlass (coinglass.com)

Alat utama untuk analisis niaga hadapan:

• Liquidation Heatmap: visualisasi aras likuidasi pada carta harga
• Funding Rate: perbandingan kadar funding merentasi bursa dalam masa nyata
• Open Interest: OI teragregat mengikut bursa
• Long/Short Ratio: nisbah long kepada short (mengikut bilangan akaun dan volum)

Coinalyze (coinalyze.net)

Analitik derivatif mendalam:

• Aggregated OI: Open Interest gabungan dipecahkan mengikut bursa
• Liquidations: sejarah likuidasi dipecahkan mengikut long/short
• OI-weighted Funding Rate: kadar funding lebih tepat mengambil kira bahagian setiap bursa

TradingView (tradingview.com)

Untuk analisis carta:

• Pine Script untuk mengautomasikan corak candlestick
• Anchored VWAP (alat terbina dalam)
• Tindanan data CoinGlass melalui penunjuk komuniti

Laevitas (laevitas.ch)

Terminal derivatif profesional:

• Pendedahan gamma
• Aliran opsyen
• Peta haba OI mengikut harga mogok

Automasi dengan Ejen AI

Semua yang diterangkan di atas boleh (dan patut) diautomasikan. Berikut adalah seni bina sistem pengesanan:

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 for detecting post-pump dumps.

    Pipeline:
    1. Scanning: volume Z-score > 3 + price increase > 100%
    2. Filtering: funding spike + OI growth
    3. Waiting: reversal pattern on 5m/15m
    4. Alert: scoring -> notification
    """

    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):
        """Main scanning loop."""
        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% above peak

                    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]:
        """Quick scan of all symbols."""
        ...

    async def _deep_analysis(self, symbol: str) -> dict:
        """
        Deep analysis of a specific symbol.
        Collects all 6 signals and computes 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):
        """Send alert (Telegram, webhook, etc.)."""
        print(f"[{alert.level.value.upper()}] {alert.symbol} "
              f"Score: {alert.score}/6 | {', '.join(alert.reasons)}")
        ...

Ambang Utama untuk Automasi

Statistik dan Realiti

Mari kita jujur. Strategi ini bukan cawan suci. Berikut adalah statistik backtest anggaran pada data 2024-2025:

Batasan utama:

1. Berat sebelah kesinambungan: kami hanya menganalisis token yang didagangkan di bursa niaga hadapan. Pump-and-dump paling liar berlaku di DEX, di mana shorting tidak mungkin.

2. Kecairan: pada banyak niaga hadapan shitcoin, tidak ada kecairan yang mencukupi untuk saiz kedudukan yang bermakna. Slippage boleh memakan 2-5% keuntungan.

3. Melawan pembuat pasaran: MM profesional mengetahui corak ini dan menggunakannya secara aktif untuk memburu stop-loss penjual pendek. Pump palsu selepas corak pembalikan terbentuk — itu adalah permainan standard.

4. Angsa hitam pada short: secara teorinya, short mempunyai potensi kerugian tidak terhad. Secara praktikalnya, stop-loss menyelesaikan masalah — tetapi semasa detik kecairan rendah, stop boleh diisi jauh lebih teruk daripada harga yang ditentukan.

Kesimpulan

Membuat short dump selepas pump shitcoin adalah salah satu daripada beberapa strategi dalam kripto di mana kelebihan (kelebihan statistik) benar-benar wujud. Sebabnya: keirasionalan massa pedagang runcit mewujudkan corak yang boleh diramal, dan mekanik lata likuidasi menguatkan pergerakan ke arah anda.

Tiga peraturan untuk dibawa pulang:

1. Jangan sesekali short impuls. Tunggu Fasa 3. Tunggu corak pembalikan. Tunggu divergens OI. Kesabaran adalah alat utama anda, bukan penunjuk yang bijak.

2. Gunakan konvergens isyarat. Satu penunjuk adalah hingar. Dua adalah hipotesis. Empat atau lebih adalah persediaan yang boleh didagangkan. Funding + OI + corak + VWAP = masuk.

3. Urus saiz kedudukan, bukan leveraj. Risiko 2% per dagangan, leveraj maksimum 3-5x, stop-loss >= 1.5 ATR. Membosankan? Ya. Tetapi pedagang yang membosankan adalah satu-satunya yang masih berada di pasaran setahun kemudian.

Dan satu lagi perkara. Ingat: di sebalik setiap dump, terdapat orang sebenar yang kehilangan wang sebenar. Ramai daripada mereka adalah pemula yang tewas kepada FOMO. Kami menganalisis mekanik pasaran, bukan memperjuangkan manipulasi. Meraih keuntungan daripada ketidakcekapan adalah sah. Mewujudkan ketidakcekapan itu tidak.

Untuk lebih lanjut mengenai kadar funding dan kesannya pada leveraj, lihat artikel kami Kadar Funding Membunuh Leveraj Anda. Mengenai kaedah pengesanan anomali dalam dagangan — Pengesanan Anomali untuk Melindungi Bot Dagangan. Mengenai arbitraj kadar funding antara bursa — Arbitraj Kadar Funding Merentasi Bursa.

Pautan 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

Petikan

@article{soloviov2026shitcoinpumpdump,
  author = {Soloviov, Eugen},
  title = {Cara Menangkap Kejatuhan Selepas Pump Shitcoin: Pendekatan Sistematik},
  year = {2026},
  url = {https://marketmaker.cc/ms/blog/post/shitcoin-pump-dump-strategies},
  version = {0.1.0},
  description = {Huraian sistematik strategi shorting selepas pump shitcoin. Kadar funding, OI, analisis volume, corak candlestick, lata-likuidasi. Dengan algoritma praktikal.}
}