MagicTradeBot v6.0 — Guida all'integrazione di RedisMarketBridge

Dati di mercato in tempo reale. Zero chiamate API per bot. Nessun rischio di limitazione della velocità.

Indice

1. Introduzione
2. Panoramica dell'architettura
3. Prerequisiti
4. Installazione & Configurazione
5. Attivazione di Redis in MagicTradeBot
6. Esecuzione di bot multipli
7. Schema delle chiavi Redis
8. Modelli di distribuzione
9. Configurazione del motore dei segnali
10. Risoluzione dei problemi
11. Passaggio alla versione Pro
12. Riferimento rapido

1. Introduzione

MagicTradeBot v6.0 introduce l'integrazione nativa con Redis, consentendo un'architettura fondamentalmente nuova per l'esecuzione simultanea di più bot. Connettendosi a RedisMarketBridge come livello di dati di mercato condiviso, ogni bot della tua flotta legge i dati di mercato live da Redis invece di chiamare direttamente le API degli exchange — indipendentemente dal numero di bot in esecuzione.

Perché è importante

Senza Redis: 10 bot su Binance = consumo di limiti di velocità 10 volte superiore. 100 bot = throttling quasi certo.

Con Redis: 1.000 bot su Binance = lo stesso singolo slot di limite di velocità usato da RedisMarketBridge. I tuoi bot sono invisibili all'exchange.

RedisMarketBridge è l'unica fonte di verità. Tutti i bot consumano i dati da esso in microsecondi — senza round trip di rete, nessuna chiave API necessaria per bot.

1.1 Cos'è RedisMarketBridge?

RedisMarketBridge è una pipeline di dati di mercato self-hosted, open source (MIT) che:

• Si connette a 12 exchange simultaneamente utilizzando un worker parallelo dedicato per exchange
• Recupera e normalizza i dati di mercato: ticker, kline, tassi di funding, movimento del book degli ordini, spread tra exchange
• Elabora i dati attraverso una pipeline a 6 fasi — dal tick grezzo al segnale strutturato con gestione TTL
• Scrive tutto in Redis utilizzando uno schema di chiavi coerente leggibile da qualsiasi linguaggio
• Calcola i segnali — RSI, MACD, Bande di Bollinger, VWAP, CVD, OFI — e li memorizza insieme ai dati grezzi

1.2 Come MagicTradeBot v6.0 Lo Usa

Quando la modalità Redis è abilitata in MagicTradeBot, ogni istanza del bot cambia la sua strategia di recupero dei dati:

La logica di trading, l'elaborazione dei segnali, il piazzamento degli ordini e la gestione del rischio sono invariati. Cambia solo il livello di acquisizione dei dati — e la differenza di prestazioni è drammatica.

2. Panoramica dell'architettura

2.1 Lo Stack Completo

API Binance   ──→  Thread worker RMB  ──┐
API Bybit     ──→  Thread worker RMB  ──┤
API Gate.io   ──→  Thread worker RMB  ──┤
API HTX       ──→  Thread worker RMB  ──┤  →  Redis  (unica fonte di verità)
API KuCoin    ──→  Thread worker RMB  ──┤
API Kraken    ──→  Thread worker RMB  ──┤
… 12 in totale ──→  Thread worker RMB  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  Tutti leggono da Redis
                          │  MagicTradeBot Bot 3          │  Zero chiamate dirette agli exchange
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

Tutti i bot leggono da Redis. Zero chiamate API dirette agli exchange dal codice del bot. L'exchange parla solo con RedisMarketBridge.

2.2 Pipeline a 6 Fasi

RedisMarketBridge elabora i dati di mercato attraverso sei fasi sequenziali prima che raggiungano i tuoi bot:

3. Prerequisiti

3.1 Software Richiesto

3.2 Chiavi API degli Exchange

RedisMarketBridge utilizza solo endpoint pubblici per i dati di mercato — non sono richieste chiavi API per ticker, kline o tassi di funding. Le chiavi API sono opzionali e necessarie solo per:

• Limiti di velocità più elevati su alcuni exchange (Binance, OKX)
• Accesso a dati privati (non utilizzato nella pipeline dei dati di mercato)
• Funzionalità di trading future se abilitate

⚠️ IMPORTANTE — Chiavi API dei Bot

MagicTradeBot richiede ancora le chiavi API degli exchange per il piazzamento degli ordini. Solo l'acquisizione dei dati di mercato viene scaricata su RedisMarketBridge. Le chiavi API dei tuoi bot sono utilizzate esclusivamente per piazzare, monitorare e cancellare ordini.

4. Installazione & Configurazione

4.1 Passo 1 — Avviare Redis

Il modo più semplice è Docker Compose. Crea docker-compose.yml:

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    container_name: rmb-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --maxmemory 2gb --maxmemory-policy allkeys-lru
    restart: unless-stopped

volumes:
  redis-data:

docker compose up -d redis
# Verifica:
redis-cli ping   # → PONG

4.2 Passo 2 — Scaricare RedisMarketBridge

Livello gratuito (open source, MIT):

git clone https://github.com/magictradebot/redis-market-bridge
cd redis-market-bridge
cargo build --release
# Binario: ./target/release/redis-market-bridge

Livello Pro (download del binario):

Dopo aver acquistato una licenza Pro su magictradebot.com, scarica il binario pre-compilato per il tuo sistema operativo. Nessun passaggio di build richiesto. Lo stesso binario funziona per le funzionalità gratuite — la tua chiave di licenza attiva le funzionalità Pro istantaneamente.

4.3 Passo 3 — Configurare RedisMarketBridge

Tutta la configurazione risiede nella directory settings/:

connection.yaml — Connessione Redis

Redis:
  Host: "127.0.0.1"    # o l'IP del tuo server Redis
  Port: 6379
  Password: ""          # Imposta se l'autenticazione Redis è abilitata
  TLS: false
  Database: 0
  PoolSize: 20          # Aumenta per un numero elevato di bot

exchanges.yaml — Configurazione degli Exchange

Decommenta ogni exchange che vuoi abilitare. Tutti gli endpoint dei dati di mercato sono pubblici — le chiavi API sono opzionali:

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Opzionale — per limiti di velocità più elevati
      ApiSecret: ""
    Proxy:
      Enabled: false

  - Name: "bybit"
    Credentials:
      ApiKey: ""
      ApiSecret: ""

  # Livello Pro — decommenta per attivare:
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # RICHIESTO per OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Passphrase richiesta
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Attenzione: rilanciato a marzo 2026 — monitorare attentamente
  #- Name: "hyperliquid"

⚠️ Attenzione MEXC

L'API Futures di MEXC è stata offline dal 2022 al 2026 e rilanciata a marzo 2026. RedisMarketBridge mostrerà un avviso all'avvio e ad ogni scrittura di dati MEXC. Monitorare attentamente i dati MEXC durante il periodo iniziale di stabilizzazione.

application.yaml — Modalità del Motore

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # La tua chiave di licenza Pro (lascia vuoto per il livello gratuito)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Passo 4 — Avviare RedisMarketBridge

# Avvia il bridge:
./redis-market-bridge

# O con Docker Compose — aggiungi a docker-compose.yml:
# services:
#   rmb:
#     image: magictradebot/redis-market-bridge:latest
#     volumes:
#       - ./settings:/app/settings
#     depends_on: [redis]
#     restart: unless-stopped

Output di avvio previsto:

[RMB] Avvio di RedisMarketBridge v1.0
[RMB] Modalità motore: Both
[RMB] Redis: 127.0.0.1:6379 connesso ✓
[RMB] Avvio worker: binance
[RMB] Avvio worker: bybit
[RMB] Avvio worker: bitget
[Fase 1] Sincronizzazione simboli: BINANCE=665 BYBIT=542 BITGET=544
[Fase 1] Sincronizzazione simboli completata — 1.751 simboli in Redis
[Fase 3] Streaming dati tick — ciclo 5s
[Fase 6] Motore segnali attivo — RSI MACD BB VWAP

5. Attivazione di Redis in MagicTradeBot

5.1 Configurazione Redis

Apri la tua configurazione di MagicTradeBot e individua la sezione Redis (nuova nella v6.0):

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Imposta su true per attivare la modalità Redis
  Host: "127.0.0.1"               # Stessa istanza Redis di RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Dimensione del pool per istanza del bot

  # Comportamento di fallback quando Redis non è disponibile:
  FallbackToDirectApi: true        # Ricorre a chiamate API dirette se la chiave Redis manca
  FallbackWarningLog: true         # Registra un avviso ad ogni fallback
  FallbackStaleThresholdMs: 30000  # Considera i dati come obsoleti se più vecchi di 30s

5.2 Cosa Cambia Quando Redis è Abilitato

✅ Protezione di Fallback

Se una chiave Redis manca o è scaduta (es. RedisMarketBridge è giù), MagicTradeBot ricorre automaticamente a una chiamata API diretta all'exchange per quel punto dati specifico. Questo garantisce che i bot non si fermino mai a causa di un'interruzione del livello dati. Imposta FallbackToDirectApi: false per disabilitare (non raccomandato in produzione).

6. Esecuzione di bot multipli

6.1 Il Vantaggio Principale

6.2 Singolo Exchange — Bot Multipli

Esecuzione di 20 bot di strategia diversi che puntano tutti ai perpetual USDT di Binance:

# bot-1-btc.yaml  (Long/Short BTC, segnale 15m)
Exchange: "binance"
Symbol: "BTCUSDT"
Strategy: "momentum"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# bot-2-eth.yaml  (Long/Short ETH, segnale 30m)
Exchange: "binance"
Symbol: "ETHUSDT"
Strategy: "mean_reversion"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# ... ripeti per tutti i bot necessari
# Tutti leggono dallo stesso Redis — Binance vede SOLO la singola connessione di RMB

6.3 Multi-Exchange — Bot Multipli

Esecuzione di bot su 5 exchange diversi simultaneamente. Senza Redis questo richiederebbe la gestione di 5 budget di limiti di velocità separati su tutti i bot. Con Redis:

# bot-binance-sol.yaml
Exchange: "binance"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-bybit-sol.yaml  (stesso simbolo, exchange diverso — confronto arbitraggio)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (legge il segnale di arbitraggio cross-exchange da Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Legge il segnale pre-calcolato arb:signal:SOLUSDT da Redis

💡 Bot di Arbitraggio Cross-Exchange

ArbEdgeBot (il modulo di arbitraggio di funding di MagicTradeBot) trae il massimo beneficio da Redis. Legge i punteggi di divergenza di funding cross-exchange pre-calcolati da arb:signal:__top__ — una singola chiave contenente le opportunità top-N classificate per spread + momentum + peso della liquidità. Zero chiamate API richieste.

7. Schema delle chiavi Redis

MagicTradeBot legge i dati da Redis utilizzando uno schema di chiavi coerente scritto da RedisMarketBridge.

7.1 Riferimento delle chiavi

7.2 Esempio di ispezione con Redis CLI

redis-cli

# Verificare se il bridge sta scrivendo:
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 risultati

# Ottenere il prezzo corrente del BTC:
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Ottenere il tasso di funding per SOLUSDT:
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

# Ottenere l'RSI per ETHUSDT 30m:
> GET signal:binance:ETHUSDT:30m
{"rsi":42.3,"macd":-12.4,"bb_pct":0.31,"cvd":-184200}

# Ottenere i migliori segnali di arbitraggio (letti da ArbEdgeBot):
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# Controllare il TTL sui dati tick:
> TTL tick:binance:BTCUSDT
12

7.3 Lettura da Redis nel codice del bot

MagicTradeBot gestisce tutte le letture Redis internamente quando Redis.Enabled: true. Tuttavia, puoi anche leggere direttamente da Redis in script personalizzati o dashboard:

# Python
import redis, json

r = redis.Redis(host='127.0.0.1', port=6379)

# Ottenere il prezzo
tick = json.loads(r.get('tick:binance:BTCUSDT'))
price = tick['price']

# Ottenere l'RSI
signal = json.loads(r.get('signal:binance:BTCUSDT:30m'))
rsi = signal['rsi']

# Ottenere le migliori opportunità di arbitraggio
top = json.loads(r.get('arb:signal:__top__'))
best = top['signals'][0]  # {'symbol': 'SOLUSDT', 'score': 8.22, 'spread': 1.42, ...}

// Rust — Integrazione ArbEdgeBot
let price = get_last_price("binance", "BTCUSDT").await?.unwrap_or(0.0);
let signals: Vec<ArbSignal> = get_top_arb_signals().await?;
let funding_rates = get_all_funding_rates("bybit").await?;

// JavaScript / Node.js
const client = createClient({ url: 'redis://127.0.0.1:6379' });
const tick = JSON.parse(await client.get('tick:binance:BTCUSDT'));
const allPrices = JSON.parse(await client.get('tick:binance:__price__'));
// → { BTCUSDT: 67284.1, ETHUSDT: 3412.0, SOLUSDT: 184.2, ... 665 simboli }

8. Modelli di distribuzione

8.1 Modello A — Nodo Singolo (Principiante)

Tutto su una macchina. Ideale per uso personale, test o una flotta di bot a strategia singola.

Macchina: 1 VPS (4 CPU, 8 GB RAM raccomandati)

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Sincronizza tutti gli exchange in parallelo
│  Redis 7.x                               │  ← Archivio dati condiviso
│  MagicTradeBot Bot 1                     │  ← Legge Redis, piazza ordini
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

Quando usarlo: Per iniziare, eseguendo meno di 50 bot, o se la semplicità è più importante delle massime prestazioni.

8.2 Modello B — Bridge e Bot Separati (Consigliato)

RedisMarketBridge su un nodo dati vicino ai server degli exchange, i bot su un nodo di calcolo separato.

Nodo A (Dati — VPS a bassa latenza vicino all'exchange):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (rete)  ←→

Nodo B (Calcolo — dove si trovano i tuoi bot):
  MagicTradeBot Bot 1..N
  Tutti si connettono a Redis del Nodo A

Posizioni raccomandate per i nodi:

Quando usarlo: Esecuzione di 50+ bot, o quando la latenza dei dati tick è importante per la tua strategia.

8.3 Modello C — Distribuito (Avanzato)

Un nodo MarketBridge per regione di exchange, un cluster Redis condiviso e un nodo di calcolo SignalBridge dedicato.

Nodo 1 (Tokyo):          Nodo 2 (Singapore):      Nodo 3 (Francoforte):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Exchange: binance         Exchange: bybit            Exchange: kraken, gateio

                ↓                  ↓                       ↓
          Cluster Redis  (condiviso, replicato tra le regioni)
                               ↓
Nodo 4 (Calcolo):    SignalBridge — calcola RSI/MACD/CVD/OFI per tutti i simboli
                               ↓
Nodo 5..N:           Flotta di bot MagicTradeBot — legge Redis, piazza ordini

📋 Licenza Studio Richiesta

Il modello C richiede una licenza Studio (79 $/mese) che consente fino a 5 istanze RedisMarketBridge simultanee. Ogni nodo funziona in modo indipendente — un guasto di un nodo influisce solo sui dati di quell'exchange, non sull'intera flotta.

9. Configurazione del motore dei segnali

Tutti i segnali sono configurati in settings/signal_engine.yaml. Si applica solo quando Engine: SignalBridge o Engine: Both.

9.1 Segnali disponibili

9.2 Configurazione di esempio

# settings/signal_engine.yaml

rsi:
  enabled: true
  period: 14

macd:
  enabled: true
  fast_period: 12
  slow_period: 26
  signal_period: 9

atr:
  enabled: true
  period: 14

bollinger_bands:
  enabled: true
  bb_period: 20
  bb_deviation: 2.0

vwap:
  enabled: true
  std_dev_multiplier: 2.0

cumulative_volume_delta:
  enabled: true
  period: 10

order_flow_imbalance:
  enabled: true
  period: 5

# Pesante — disabilitare su macchine con poca CPU o nodi ad alta frequenza:
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

9.3 Linee guida per le prestazioni

• Macchine con poca CPU / nodi con intervallo 1m: Disabilitare OFI, Multi-Timeframe, Ichimoku
• Nodo SignalBridge dedicato: Abilitare tutto — scaricare il calcolo dal nodo MarketBridge
• Configurazione minima (più veloce): Solo RSI + MACD + ATR — copre la maggior parte delle strategie basate su segnali

10. Risoluzione dei problemi

10.1 Le chiavi Redis sono vuote / I bot segnalano dati obsoleti

# Verificare che RedisMarketBridge sia in esecuzione:
ps aux | grep redis-market-bridge

# Verificare la connessione Redis:
redis-cli ping   # → PONG

# Verificare se le chiavi esistono:
redis-cli KEYS 'tick:binance:*' | wc -l   # Dovrebbe essere 665 per Binance

# Verificare che il TTL sia sano:
redis-cli TTL 'tick:binance:BTCUSDT'   # Dovrebbe essere 1–15 (non -2 = mancante, non -1 = nessun TTL)

Se le chiavi mancano, controlla i log RMB con DebugMode: true in application.yaml per vedere gli errori di connessione agli exchange.

10.2 I bot colpiscono ancora le API dell'exchange nonostante la modalità Redis

1. Verifica che Redis.Enabled: true nella configurazione di MagicTradeBot
2. Conferma che Redis.Host e Redis.Port in MagicTradeBot corrispondano all'istanza Redis in cui RMB scrive
3. Controlla FallbackWarningLog: true — se vedi avvisi di fallback, RMB è in esecuzione ma una chiave specifica manca o è scaduta
4. Conferma che i nomi degli exchange corrispondano esattamente (sensibili alle maiuscole: "binance" non "Binance")

10.3 I dati MEXC mancano o sono incoerenti

⚠️ Problema noto MEXC

L'API Futures di MEXC è stata offline dal 2022 al 2026 e rilanciata a marzo 2026. I dati potrebbero essere inaffidabili durante la stabilizzazione. Se vedi avvisi [MEXC CAUTION] nei log RMB, questo è un comportamento previsto. Considera di disabilitare MEXC in exchanges.yaml fino a quando l'API non si dimostrerà stabile.

10.4 Errori di limitazione della velocità che compaiono nonostante la modalità Redis

• Gli errori di limitazione della velocità dal piazzamento degli ordini sono normali — i bot piazzano ancora gli ordini direttamente. Solo le letture dei dati sono scaricate su Redis.
• Se vedi limiti di velocità sulle letture dei dati, significa che FallbackToDirectApi si è attivato ripetutamente. Verifica perché RMB non sta scrivendo le chiavi previste.

10.5 Errore frase di accesso KuCoin / Bitget / OKX

Questi exchange richiedono una frase di accesso nelle credenziali del bot per il piazzamento degli ordini. Questo è un requisito di trading lato bot, non correlato a Redis o RedisMarketBridge. Imposta la frase di accesso nella sezione delle credenziali dell'exchange di ogni bot — è separata dalle credenziali RMB exchanges.yaml (che sono opzionali per i dati pubblici).

10.6 Monitoraggio dello stato di salute

Configura avvisi Discord o Telegram in settings/notifications.yaml:

Notifications:
  Discord:
    Enabled: true
    WebhookUrl: "https://discord.com/api/webhooks/YOUR_WEBHOOK_URL"
    AlertOn:
      - ExchangeDisconnect
      - RedisConnectionLost
      - HighLatencyWarning
      - MexcCaution

  Telegram:
    Enabled: false
    BotToken: ""
    ChatId: ""

11. Passaggio alla versione Pro

I livelli Gratuito (3 exchange, 1.751 simboli) e Pro (12 exchange, 4.081+ simboli) utilizzano lo stesso binario. L'upgrade è istantaneo — nessuna reinstallazione, nessuna modifica alla configurazione oltre alla chiave di licenza.

Passi:

1. Acquista una licenza Pro su magictradebot.com
2. Ricevi la tua chiave di licenza via email
3. Apri settings/license.yaml e imposta:

License:
  Key: "YOUR-LICENSE-KEY-HERE"

4. Riavvia RedisMarketBridge
5. Decommenta gli exchange aggiuntivi in exchanges.yaml
6. Riavvia di nuovo RedisMarketBridge — tutti i 12 worker degli exchange si avvieranno

Cosa attiva la versione Pro:

• ✅ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC
• ✅ 12 worker exchange paralleli (ogni exchange completamente indipendente)
• ✅ 4.081+ simboli perpetual USDT
• ✅ 66 coppie di arbitraggio cross-exchange (contro 3 nel livello gratuito)
• ✅ Punteggio segnale arbitraggio v2 (spread + funding + ponderazione liquidità)
• ✅ Segnali CVD e OFI sbloccati
• ✅ Copertura completa dei tassi di funding su tutti i 12 exchange

12. Riferimento rapido

Lista di controllo all'avvio

• Redis è in esecuzione e accessibile (redis-cli ping → PONG)
• RedisMarketBridge è in esecuzione e scrive chiavi (redis-cli KEYS 'tick:*')
• MagicTradeBot ha Redis.Enabled: true e Host/Port corretti
• I nomi degli exchange del bot corrispondono esattamente ai nomi degli exchange in RMB exchanges.yaml
• Le chiavi API del bot sono impostate per il piazzamento degli ordini (separate dalle credenziali RMB)
• FallbackToDirectApi: true impostato come rete di sicurezza

Comandi chiave

# Avviare Redis
docker compose up -d redis

# Avviare RedisMarketBridge
./redis-market-bridge

# Verificare che i dati fluiscano
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (livello gratuito Binance)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Verificare che i TTL siano sani (dovrebbero essere > 0)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# Monitorare l'output di RMB in tempo reale
redis-cli MONITOR

# Contare il totale delle chiavi in Redis
redis-cli DBSIZE

Riepilogo livelli exchange

Supporto