Come Sfruttare i Crolli Dopo i Pump degli Shitcoin: Un Approccio Sistematico

Ogni trader crypto lo ha visto almeno una volta: un token di cui nessuno aveva mai sentito parlare il giorno prima fa +800% in 4 ore. Twitter esplode di emoji a razzo. Reddit si riempie di post "è solo l'inizio". Il tuo collega — che un mese fa non sapeva distinguere un order book da un ordine al McDonald's — ti manda un messaggio: "amico, mettici almeno cento euro." Dodici ore dopo, il token ha perso l'85% dal picco. Silenzio. Razzi cancellati.

La domanda non è se ci sarà un dump. La domanda è come trarne profitto sistematicamente senza essere travolti dal pump stesso.

Questo articolo non è un consiglio finanziario (il disclaimer obbligatorio che nessuno legge, ma gli avvocati insistono). È un'analisi tecnica della meccanica, dei segnali e degli algoritmi per identificare i punti di inversione dopo i movimenti impulsivi su asset a bassa liquidità.

Anatomia di un Pump-and-Dump: Tre Fasi di Una Sola Follia

Prima di andare allo short, è necessario comprendere la struttura del fenomeno. Ogni pump-and-dump degli shitcoin attraversa tre fasi, ognuna con le proprie firme caratteristiche nei dati.

Fase 1: Accumulo (La Caccia Silenziosa)

Durata: da alcune ore a diversi giorni.

Qualcuno — un gruppo di insider, un gruppo Telegram coordinato, o semplicemente un grande player con un vantaggio informativo — inizia ad acquistare il token. Lo fa con cautela: ordini piccoli, su più exchange, spesso durante la sessione asiatica (quando la liquidità è minima e l'attenzione è dispersa).

Cosa è visibile nei dati:

• Il volume di trading aumenta gradualmente (50-200% sopra la media a 7 giorni), ma il prezzo si muove a malapena
• Il lato bid dell'order book si ispessisce: compaiono "muri" 2-5% sotto il prezzo corrente
• Metriche on-chain (per i token DEX): grandi trasferimenti verso gli exchange, crescita dei wallet acquirenti unici
• Il funding rate sui futures perpetui (se esistono) comincia ad aumentare leggermente

In questa fase, è troppo presto per andare allo short. Non sai ancora se si tratta di accumulo o di interesse organico. Distinguere l'uno dall'altro è spesso impossibile — la differenza diventa ovvia solo col senno di poi.

Fase 2: L'Impulso (La Festa)

Durata: da 30 minuti a 12 ore.

Il prezzo rompe un livello di resistenza chiave e inizia una cascata. Gli stop-loss dei venditori allo scoperto vengono liquidati. Il FOMO (Fear Of Missing Out) risucchia i trader retail. Crypto Twitter diventa una camera d'eco. Ogni retweet è un nuovo long con leva 50x.

Firme caratteristiche:

• Il volume è 1000-5000% sopra la media (non è un errore di battitura)
• Il funding rate schizza a 0,1-0,5% ogni 8 ore (la norma è 0,01%)
• L'Open Interest cresce esponenzialmente: nuove posizioni vengono aperte più velocemente di quanto non vengano chiuse
• Lo spread bid-ask si allarga di 3-10x per mancanza di liquidità sul lato ask
• L'order book mostra un vuoto sopra: tra il prezzo corrente e il più vicino ask significativo — il nulla

Andare allo short durante questa fase è suicidio. È come mettersi davanti a un treno perché "alla fine si fermerà." Sì, si fermerà. Ma a quel punto sarai già stato liquidato. Ne parleremo più avanti nella sezione "Cosa NON Fare".

Fase 3: Distribuzione e Crollo (Il Giorno Dopo)

Durata: da 2 a 48 ore.

Gli insider iniziano a prendere profitto. Il prezzo fa la sua prima correzione significativa (-15-30% dal picco). I trader retail "comprano il dip." Il prezzo rimbalza. Poi scende di nuovo. Ogni rimbalzo successivo è più debole. Ogni caduta è più profonda.

Cosa succede nei dati:

• Il volume rimane elevato ma si sposta verso il lato vendita
• Il funding rate inizia a scendere ma è ancora anormalmente alto
• L'Open Interest smette di crescere o inizia a calare (i long si chiudono)
• Compaiono grandi ordini di vendita a mercato che "mangiano" l'order book di diversi livelli
• On-chain: grandi trasferimenti dai wallet degli insider verso gli exchange

Questa è la zona di caccia. È qui che inizia il lavoro.

Segnali Chiave per Entrare allo Short

Ogni segnale da solo è debole. Una combinazione di tre o più è già un'ipotesi praticabile.

1. Funding Rate: La Tassa sull'Avidità

Il funding rate è il costo per mantenere una posizione sui futures perpetui. Quando tutti vogliono essere long, i long pagano gli short. Più alto è il tasso, più il mercato è sbilanciato su un lato.

Perché funziona: con un funding rate dello 0,3% ogni 8 ore, i long pagano ~1% al giorno solo per mantenere la posizione. Con leva 10x, questo è il 10% del capitale al giorno. Non può durare a lungo — le posizioni iniziano a chiudersi, spingendo il prezzo verso il basso.

Avvertenza: il funding estremo da solo non è un segnale di short. Può rimanere alto per ore o persino giorni mentre il prezzo continua a salire. Il funding è un filtro (conferma dello squilibrio), non un trigger (punto di ingresso).

def funding_rate_signal(
    current_rate: float,
    historical_rates: list[float],
    lookback: int = 90,  # 90 periodi = 30 giorni
) -> dict:
    """
    Valuta il livello di anomalia del funding rate corrente.

    Restituisce:
        signal: 'neutral' | 'elevated' | 'extreme' | 'insane'
        z_score: float — deviazione dalla norma
        percentile: float — percentile nei dati storici
    """
    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),  # % annualizzato
    }

2. Open Interest: Chi È Intrappolato

L'Open Interest (OI) è il numero totale di contratti aperti nei futures. Quando l'OI sale insieme al prezzo — nuovi partecipanti stanno entrando nel mercato (principalmente long). Quando il prezzo inizia a scendere ma l'OI rimane alto — quei long sono intrappolati. Le loro liquidazioni alimenteranno il dump.

Pattern chiave:

Il momento più pericoloso per i long e il migliore per gli short: il prezzo ha iniziato a scendere, ma l'OI è ancora al massimo. Questo significa che i long aperti non si sono ancora chiusi — sperano in un rimbalzo. Quando quella speranza si esaurisce, inizia la cascata di liquidazioni.

def oi_divergence_signal(
    prices: list[float],
    oi_values: list[float],
    window: int = 12,  # 12 candele (es. 12 x 5 min = 1 ora)
) -> dict:
    """
    Rileva la divergenza prezzo/OI.

    Divergenza OI rialzista: prezzo in calo, OI alto — i long sono intrappolati.
    """
    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  # prezzo sceso del 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. Analisi del Volume: La Verità nei Tick

Il volume è l'unico indicatore di mercato che non può essere falsificato (beh, quasi — il wash trading su alcuni exchange è ancora una realtà, ma le piattaforme principali sono migliorate nel combatterlo).

Segnali per lo short:

Volume in calo sui rally. Un classico segno di debolezza. Il prezzo fa un nuovo massimo, ma il volume su quel movimento è inferiore a quello precedente. I compratori stanno esaurendo la spinta.

Picco di volume sui cali. Se una correzione del -10% avviene con un volume superiore a quello dell'ultimo rally — i venditori hanno preso l'iniziativa.

Falsa rottura con basso volume. Il prezzo rompe un massimo locale, ma il volume della rottura è 2-3 volte inferiore alla media. È una trappola per i compratori: il prezzo torna rapidamente.

def volume_exhaustion_signal(
    candles: list[dict],  # [{open, high, low, close, volume, timestamp}, ...]
    pump_start_idx: int,
) -> dict:
    """
    Analisi dell'esaurimento del volume dopo un 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. Pattern Candlestick: Il Classico Che Funziona

Sì, l'analisi delle candele risale al XVII secolo, Munehisa Homma e i futures sul riso. Sì, il 90% delle "strategie candlestick" su YouTube sono spazzatura. Ma sui timeframe a 5 e 15 minuti dopo un pump, certi pattern hanno un potere predittivo statisticamente significativo. Il motivo è semplice: riflettono la reale microstruttura — il passaggio del controllo dai compratori ai venditori.

Pattern da monitorare:

Criticamente importante: un pattern senza contesto è rumore. Una Shooting Star in un pullback casuale non significa niente. Una Shooting Star al picco del pump con funding rate anomalo e divergenza OI — quella è tutta un'altra storia.

def detect_reversal_patterns(
    candles: list[dict],
    min_upper_shadow_ratio: float = 2.0,  # ombra > 2x corpo per shooting star
) -> list[dict]:
    """
    Rileva pattern di inversione ribassista.
    """
    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']):  # ribassista
            signals.append({
                'pattern': 'shooting_star',
                'index': i,
                'timestamp': c['timestamp'],
                'strength': upper_shadow / total_range,
            })

        prev = candles[i - 1]
        if (prev['close'] > prev['open']  # la precedente è rialzista
            and c['close'] < c['open']      # la corrente è ribassista
            and c['open'] > prev['close']   # apre sopra la chiusura precedente
            and c['close'] < prev['open']): # chiude sotto l'apertura precedente
            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']        # la prima è rialzista
                and c2_body < c1_body * 0.3      # la seconda è piccola (doji)
                and c3['close'] < c3['open']     # la terza è ribassista
                and c3_body > c1_body * 0.5      # la terza è abbastanza grande
                and c3['close'] < c1['close']):  # la terza chiude sotto la chiusura della prima
                signals.append({
                    'pattern': 'evening_star',
                    'index': i,
                    'timestamp': c['timestamp'],
                    'strength': c3_body / c1_body,
                })

    return signals

5. VWAP: L'Ancora della Realtà

Il VWAP (Volume-Weighted Average Price) è il prezzo medio ponderato per il volume. Il VWAP ancorato dall'inizio del pump mostra il prezzo medio di ingresso di tutti i partecipanti che hanno acquistato durante l'impulso.

Perché è importante: quando il prezzo scende sotto il VWAP ancorato — il compratore medio è in perdita. La pressione psicologica aumenta. Chi ha comprato "a buon prezzo" (all'inizio del pump) inizia a prendere profitto. Chi ha comprato al picco — è nel panico.

Regola: una rottura sotto il VWAP ancorato su volume elevato è un forte segnale per aprire uno short o aggiungere alla posizione.

def anchored_vwap(
    candles: list[dict],
    anchor_idx: int,
) -> list[float]:
    """
    Calcola il VWAP Ancorato da un dato punto (inizio del 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. Cascate di Liquidazione: L'Effetto Domino

Questo è il meccanismo di dump più potente — e il più redditizio per gli short. La logica è semplice:

1. Un trader apre un long con leva 20x. La liquidazione scatta se il prezzo scende del 5%.
2. Il prezzo scende del 5%. La posizione viene liquidata — l'exchange vende a mercato.
3. La vendita a mercato spinge il prezzo più in basso. Questo liquida il trader successivo.
4. E così via. Cascata.

Come anticiparlo:

La Liquidation Heatmap di CoinGlass mostra dove i livelli di liquidazione sono concentrati. Se sotto il prezzo corrente vedi un "muro" di liquidazioni — una discesa a quel livello con ogni probabilità innescherà una cascata.

Segnale di cascata: se nella zona da -5% a -15% dal prezzo corrente sono concentrate liquidazioni per oltre $5M (per uno shitcoin con volume giornaliero di$50-200M) — una cascata è probabile.

Algoritmo Pratico: Filtro -> Ingresso -> Rischio

La teoria è meravigliosa. Ora — la pipeline.

Passo 1: Filtro (Scanner)

Da migliaia di token, devi isolare quelli nella fase post-pump. Criteri:

def pump_scanner(
    symbols: list[str],
    exchange,  # istanza ccxt exchange
    lookback_hours: int = 24,
    min_pump_pct: float = 100,  # minimo +100% nel periodo
    min_volume_z: float = 3,    # Z-score del volume > 3
) -> list[dict]:
    """
    Scanner per token nella fase post-pump.
    """
    import numpy as np

    candidates = []

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

Passo 2: Convergenza dei Segnali (Scoring)

Per ogni candidato — valutazione su tutti e sei i parametri:

def confluence_score(
    funding_signal: dict,
    oi_signal: dict,
    volume_signal: dict,
    pattern_signals: list[dict],
    vwap_position: float,  # prezzo / VWAP (< 1 = sotto il VWAP)
    liquidation_density: float,  # $M liquidazioni sotto il prezzo corrente
) -> dict:
    """
    Punteggio composito per l'ingresso allo short.
    Punteggio 0-6, dove ogni fattore = 0 o 1 punto.
    """
    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 intrappolati: percentile OI {oi_signal['oi_percentile']}")

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

    if vwap_position < 0.98:  # prezzo 2%+ sotto il VWAP
        score += 1
        reasons.append(f"Sotto il VWAP: {round((1 - vwap_position) * 100, 1)}%")

    if liquidation_density > 5:  # > $5M liquidazioni
        score += 1
        reasons.append(f"Densità liquidazioni: ${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,
    }

Passo 3: Ingresso e Gestione del Rischio

Ingresso:

• Punteggio >= 4: entra con il 50% della posizione
• Punteggio = 3: entra con il 25% della posizione
• Punteggio < 3: aspetta

Stop-loss:

• Sopra l'ultimo swing high + buffer dell'1-2%
• NON uno stop stretto. La volatilità degli shitcoin ti distruggerà. Minimo 5-10% dall'ingresso.
• Con Punteggio = 6, uno stop dell'8-12% è accettabile (più fiducia = stop più ampio, ma meno leva)

Take-profit:

• TP1 (50% della posizione): prossimo livello di supporto importante o -20% dall'ingresso
• TP2 (30% della posizione): VWAP dall'inizio del pump
• TP3 (20% della posizione): livello pre-pump

Dimensione della posizione:

$\text{Dimensione posizione} = \frac{\text{Rischio per trade}}{\text{Distanza stop}} = \frac{0{,}02 \times \text{Capitale}}{\text{Stop \%}}$

Con $10.000 di capitale, 2% di rischio per trade e uno stop dell'8%:

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

Con leva 3x: rischi $200 (2$500-$1.250 (TP1-TP3).

Leva massima: 3-5x. Niente di più. Sul serio. Gli shitcoin nella fase di pump possono fare un altro +50% dopo che "tutti gli indicatori dicevano short." Alta leva = liquidazione.

Cosa NON Fare: Cinque Peccati Mortali

1. NON andare allo short durante il pump

"Ma sicuramente scenderà!" — sì, scenderà. Ma quando? Se hai aperto uno short a +200% e il prezzo ha fatto +600% prima di scendere a +150% — sei stato liquidato a +450%. Tecnicamente avevi ragione. Praticamente — sei fallito.

Regola: entra solo dopo il primo pullback significativo (-15% o più dal picco) e la formazione di una struttura di inversione.

2. NON usare stop-loss stretti

Uno stop-loss del 2% su uno shitcoin con ATR al 15% non è gestione del rischio — è una donazione ai market maker. Il tuo stop verrà colpito in pochi minuti durante il prossimo wick volatile.

Regola: stop-loss >= 1,5 x ATR del timeframe corrente. Idealmente 2x.

3. NON puntare tutto su un singolo trade

Anche con un Punteggio di 6/6, la probabilità di successo è intorno al 65-70%. Questo significa che 3 trade su 10 sono perdenti. Se metti il 10% del capitale su ognuno — tre perdite consecutive = -30% di drawdown. Dopo di che, psicologicamente inizierai a tradare peggio.

Regola: 1-2% del capitale per trade. Massimo 5% con convinzione estrema.

4. NON ignorare la liquidità

Non sei Goldman Sachs. Se il volume giornaliero di un token è $2M e stai cercando di entrare con$50K — diventi tu l'evento di mercato. Il tuo ingresso muove il prezzo, la tua uscita muove il prezzo. Lo slippage mangia tutto il profitto.

Regola: dimensione della posizione <= 1% del volume giornaliero del token.

5. NON andare allo short sui mercati spot senza capacità di short

Questo sembra ovvio, ma il numero di persone che "vanno allo short" acquistando token inversi su un DEX o "vendendo spot che pianificavano di ricomprare a un prezzo inferiore" è sconcertante. Usa i futures su exchange con liquidità adeguata. O non andare allo short del tutto.

Strumenti di Monitoraggio

CoinGlass (coinglass.com)

Lo strumento principale per l'analisi dei futures:

• Liquidation Heatmap: visualizzazione dei livelli di liquidazione sul grafico dei prezzi
• Funding Rate: confronto dei funding rate tra gli exchange in tempo reale
• Open Interest: OI aggregato per exchange
• Long/Short Ratio: rapporto tra long e short (per numero di account e per volume)

Coinalyze (coinalyze.net)

Analisi approfondita dei derivati:

• OI Aggregato: Open Interest combinato suddiviso per exchange
• Liquidazioni: storico delle liquidazioni suddiviso per long/short
• Funding Rate ponderato per OI: funding rate più accurato che tiene conto della quota di ciascun exchange

TradingView (tradingview.com)

Per l'analisi dei grafici:

• Pine Script per automatizzare i pattern candlestick
• VWAP Ancorato (strumento integrato)
• Overlay dati CoinGlass tramite indicatori della community

Laevitas (laevitas.ch)

Terminale professionale per derivati:

• Gamma exposure
• Options flow
• OI heatmap per strike

Automazione con Agenti AI

Tutto quanto descritto sopra può (e dovrebbe) essere automatizzato. Ecco l'architettura del sistema di rilevamento:

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:
    """
    Agente AI per il rilevamento di dump post-pump.

    Pipeline:
    1. Scansione: Z-score volume > 3 + aumento del prezzo > 100%
    2. Filtro: picco di funding + crescita OI
    3. Attesa: pattern di inversione su 5m/15m
    4. Alert: scoring -> notifica
    """

    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 principale di scansione."""
        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 rilevato: +{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% sopra il picco

                    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]:
        """Scansione rapida di tutti i simboli."""
        ...

    async def _deep_analysis(self, symbol: str) -> dict:
        """
        Analisi approfondita di un simbolo specifico.
        Raccoglie tutti e 6 i segnali e calcola il punteggio di confluence.
        """
        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):
        """Invia alert (Telegram, webhook, ecc.)."""
        print(f"[{alert.level.value.upper()}] {alert.symbol} "
              f"Punteggio: {alert.score}/6 | {', '.join(alert.reasons)}")
        ...

Soglie Chiave per l'Automazione

Statistiche e Realtà

Siamo onesti. Questa strategia non è il sacro graal. Ecco le statistiche approssimative di backtest sui dati 2024-2025:

Limitazioni principali:

1. Survivorship bias: analizziamo solo i token scambiati sugli exchange futures. I pump-and-dump più selvaggi avvengono sui DEX, dove lo short è impossibile.

2. Liquidità: sui futures di molti shitcoin non c'è abbastanza liquidità per una dimensione di posizione significativa. Lo slippage può mangiare il 2-5% dei profitti.

3. Combattere i market maker: i MM professionisti conoscono questi pattern e li usano attivamente per cacciare gli stop-loss dei venditori allo scoperto. Un falso pump dopo che si forma un pattern di inversione — è una mossa standard.

4. Black swan sugli short: teoricamente, uno short ha un potenziale di perdita illimitato. In pratica, lo stop-loss risolve il problema — ma durante i momenti di bassa liquidità, lo stop può riempirsi molto peggio del prezzo specificato.

Conclusione

Andare allo short sui dump dopo i pump degli shitcoin è una delle poche strategie nel crypto in cui esiste un vero edge (vantaggio statistico). Il motivo: l'irrazionalità di massa dei trader retail crea pattern prevedibili, e la meccanica delle cascate di liquidazione amplifica il movimento nella tua direzione.

Tre regole da portare via:

1. Non andare mai allo short durante l'impulso. Aspetta la Fase 3. Aspetta i pattern di inversione. Aspetta la divergenza OI. La pazienza è il tuo strumento principale, non qualche indicatore ingegnoso.

2. Usa la convergenza dei segnali. Un indicatore è rumore. Due è un'ipotesi. Quattro o più è un setup tradeable. Funding + OI + pattern + VWAP = ingresso.

3. Gestisci la dimensione della posizione, non la leva. 2% di rischio per trade, leva massima 3-5x, stop-loss >= 1,5 ATR. Noioso? Sì. Ma i trader noiosi sono gli unici ancora sul mercato un anno dopo.

E un'ultima cosa. Ricorda: dietro ogni dump ci sono persone reali che hanno perso denaro reale. Molte di loro sono principianti che hanno ceduto al FOMO. Noi analizziamo la meccanica del mercato, non sosteniamo la manipolazione. Trarre profitto dall'inefficienza è legittimo. Creare quella inefficienza non lo è.

Per ulteriori informazioni sui funding rate e il loro impatto sulla leva, consulta il nostro articolo I Funding Rate Distruggono la Tua Leva. Sui metodi di rilevamento delle anomalie nel trading — Rilevamento delle Anomalie per Proteggere i Bot di Trading. Sull'arbitraggio del funding rate tra exchange — Arbitraggio del Funding Rate tra Exchange.

Link Utili

1. CoinGlass — Liquidation Heatmap
2. CoinGlass — Funding Rate
3. CoinGlass — Open Interest
4. Coinalyze — Open Interest Aggregato
5. Hyblock Capital — Livelli di Liquidazione
6. Laevitas — Analisi dei Derivati
7. TradingView — VWAP Ancorato
8. Binance — Storico Funding Rate

Citazione

@article{soloviov2026shitcoinpumpdump,
  author = {Soloviov, Eugen},
  title = {Come Sfruttare i Crolli Dopo i Pump degli Shitcoin: Un Approccio Sistematico},
  year = {2026},
  url = {https://marketmaker.cc/it/blog/post/shitcoin-pump-dump-strategies},
  version = {0.1.0},
  description = {Un'analisi sistematica delle strategie di short dopo i pump degli shitcoin. Funding rate, OI, analisi del volume, pattern candlestick, cascate di liquidazione. Con un algoritmo pratico.}
}