Creazione di un algoritmo di market making in MQL5

Che cos'è la liquidità?

La liquidità dei mercati finanziari è la "saturazione" del mercato con denaro sotto forma di ordini e posizioni. Ciò consente ai trader di vendere rapidamente azioni (o valute) per grandi quantità. Maggiore è la liquidità del mercato, più facile è vendere o acquistare un asset per grandi quantità senza subire perdite significative dovute allo slippage. 

Lo slippage è il principale problema dei grandi operatori: i fondi più importanti notano che non è così facile gestire una posizione di grandi dimensioni e spesso la transazione viene chiusa in perdita proprio a causa dello "slippage" dell'ordine. Lo slittamento dell'ordine si verifica quando una transazione viene aperta a un determinato prezzo ed eseguita a un prezzo diverso da quello previsto. Quando un trader possiede solo poche centinaia di dollari, di solito non ci sono problemi di liquidità (ad eccezione dei mercati completamente illiquidi delle criptovalute di terza categoria). Ma quando si ha a che fare con centinaia di milioni di dollari, è difficile aprire e chiudere una posizione contemporaneamente. Ciò è direttamente correlato alla liquidità del mercato.

La liquidità del mercato viene garantita grazie ai market maker. Il loro compito principale è quello di mantenere la liquidità. Questi operatori di mercato fanno tutto il possibile per rendere le transazioni il più agevoli possibile, in modo che non vi siano brusche discrepanze nelle quotazioni e che sia compratori che venditori ricevano sempre prezzi a loro congeniali.

In un mercato privo di market maker, si osservano molto spesso forti oscillazioni di prezzo in una direzione, enormi fluttuazioni degli asset e gap di quotazioni.

Come funziona un market maker e perché non è un "burattinaio"?

Molti trader sono convinti che il market maker sia una sorta di burattinaio, un manipolatore che muove i prezzi a suo piacimento, rompe i livelli di stop, inganna la folla inducendola a emettere ordini di stop, e così via.

In realtà, il market maker non ha affatto bisogno di far perdere denaro alla "gente". La "massa" del mercato perde denaro a causa di spread, commissioni e swap. 

Per quanto riguarda gli spostamenti del mercato nella giusta direzione, anche questo non è compito del market maker. In base all'accordo stipulato con la borsa, un market maker è tenuto a fornire un prezzo di acquisto a un acquirente e un prezzo di vendita a un venditore, oltre a colmare, se necessario la “profondità di mercato”.

Senza i market maker, il mercato sarebbe completamente diverso: assisteremmo costantemente a gap di prezzo, gap di quotazione, continue compressioni in entrambe le direzioni, nonché enormi balzi di prezzo in entrambe le direzioni. Tutto ciò si può ancora riscontrare oggi in quei mercati in cui non è profittevole per un market maker essere presente, ad esempio in molti titoli azionari a basso prezzo (penny stock) statunitensi.

Nuove tecnologie AMM nel mercato delle criptovalute

Ma cosa succederebbe se sostituissimo un partecipante con uno smart contract? In altre parole, cosa succederebbe se, invece di market maker, creassimo un sistema automatico per regolare domanda e offerta, nonché le quotazioni generali?

È più o meno così che sono nati gli exchange decentralizzati (DEX). Sono stati i primi a utilizzare il meccanismo AMM (Automated Market Making). L'algoritmo AMM funziona tramite uno speciale pool di liquidità che utilizza le risorse dei partecipanti per le transazioni tra di loro. Il prezzo e il volume degli scambi sono sempre controllati dall'algoritmo. Ciò permette di mettere in contatto tutti i venditori con tutti gli acquirenti, presumibilmente senza perdite per i partecipanti. In realtà, però, tutti i DEX presentano un enorme slittamento di prezzo. In caso di elevato volume di transazioni, è garantito che perderai un'alta percentuale sullo scambio di token.

Inoltre, questa innovazione non ha eliminato le manipolazioni del mercato. Ce ne sono molti su un DEX. Anche i creatori di token su un DEX possono facilmente gonfiare il valore dei propri token e incassare l'intera liquidità disponibile.

In che modo i market maker contrastano le manipolazioni dei prezzi?

Sebbene non sia responsabilità dei market maker, questi spesso stroncano sul nascere i tentativi di organizzare uno schema "pump and dump" quando i prezzi iniziano appena a essere spinti al rialzo da partecipanti fraudolenti. In queste fasi iniziali, il market maker invia un'enorme quantità di ordini limite all'operatore che sta cercando di spingere al rialzo i prezzi di mercato. Questo estingue la domanda, quindi i nuovi operatori dei sistemi di pompaggio spesso si scontrano duramente con il market maker. Ma se la manipolazione del prezzo è ben pianificata, l'afflusso di numerosi ordini di mercato, che muovono con forza il prezzo, costringe il market maker ad abbandonare temporaneamente il mercato.

Quando i market maker abbandonano il mercato?

La maggior parte dei market maker, nei propri accordi con le borse, prevede la disattivazione degli algoritmi e l'abbandono del mercato durante le festività, i periodi di attività anomala e i periodi di pubblicazione di notizie importanti. Ciò è dovuto al desiderio dei MM di preservare il proprio capitale. 

Possiamo notare che il market maker sta abbandonando immediatamente il mercato a causa dell'ampio spread. Avete notato come lo spread si allarga persino sugli ECN in seguito alla pubblicazione di importanti notizie globali? La consueta ristrettezza dello spread si ottiene grazie all'operato dei market maker. Pertanto, senza di loro, ci troveremmo ad affrontare condizioni di trading molto negative, tra cui spread ampi, larghi slittamenti di prezzo, cali improvvisi e impennate dei prezzi - tutte cose tipiche dei mercati selvaggi.

Che cos'è il rischio di invenduto del market maker?

Molti pensano che un market maker non si assuma alcun rischio. Tuttavia, non è così. Il rischio principale per un market maker è il rischio di invenduto. Questo rischio risiede nel fatto che una posizione può muoversi bruscamente in una direzione senza la possibilità di chiuderla e guadagnare sullo spread. Ad esempio, quando un gruppo in preda al panico vende un asset, il market maker è costretto ad acquistare l'intera offerta. Di conseguenza, il prezzo scende in territorio negativo, causando perdite al MM. 

Le aziende cercano di evitare questo rischio utilizzando equazioni speciali per il centraggio dello spread e determinando il prezzo ottimale per l'acquisto e la vendita. Ma questo non è sempre realizzabile. Anche se il prezzo non è ottimale, il compito dei MM è quello di fornire liquidità al mercato, e devono svolgere questo compito, anche se opera temporaneamente in perdita. 

Analisi dei dati del più grande market maker del pianeta - l'azienda di Kenneth Griffin.

Analizzando l'attività del più grande market maker al mondo, Citadel Securities fondata da Kenneth Griffin, emerge chiaramente l'importanza del suo ruolo nei mercati finanziari.

I report dell'azienda mostrano un impatto notevole: 7 trade su 10 nel mercato azionario statunitense dipendono dalla liquidità fornita da questo market maker. Questa attività dimostra il ruolo significativo di Citadel Securities nel mantenere la stabilità e la disponibilità di liquidità in questo mercato.

Per valutare la portata dell'influenza della società di Griffin, basti pensare che circa 900 milioni di lotti di azioni statunitensi transitano quotidianamente attraverso i suoi algoritmi. Questo significativo volume di scambi riflette l'elevata attività e l'influenza della società sulla borsa statunitense.

A proposito, l'evoluzione di Kenneth Griffin, dal trading diretto al market making, è molto interessante. La società di Griffin si sta espandendo attivamente nei mercati globali, esplorando in particolare le borse asiatiche e fornendo liquidità in tali mercati.

 

Preparazione di un EA market maker

Quindi, abbiamo capito la teoria. È ora di iniziare a creare un EA market maker! Naturalmente, il nostro algoritmo sarà molto semplice. Non svilupperemo strategie di spread trading basate su equazioni particolari. 

Invece, implementeremo l'algoritmo più semplice che manterrà costantemente aperti due ordini limite - un ordine limite di vendita e un ordine limite di acquisto.

La più semplice implementazione del market making in MQL5

Analizziamo il codice del nostro algoritmo. Intestazione del codice. Questa sezione definisce i parametri di base della strategia, come la dimensione del lotto, i livelli di profitto, il magic number dell'EA, le coppie di valute selezionate per il trading, ecc.

//+------------------------------------------------------------------+
//|                                                  MarketMaker.mq5 |
//|                                Copyright 2023, Evgeniy Koshtenko |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, Evgeniy Koshtenko"
#property link      "https://www.mql5.com/en/users/koshtenko"
#property version   "1.00"

#include <Trade\Trade.mqh>        // Include the CTrade trading class

//--- input parameters
input double Lots       = 0.1;    // lot
input double Profit     = 0.1;    // profit
input double BProfit    = 11;     // buy profit
input double SProfit    = 11;     // sell profit
input int StopLoss      = 0;      // stop loss
input int TakeProfit    = 0;      // take profit
input int    Count      = 5;      // number of orders
input int    Delta      = 55;     // delta
input int    Magic      = 123;    // magic number

input bool   BuyLimit   = 1;      // Buy Limit
input bool   SellLimit  = 1;      // Sell Limit

input string Symbol1    = "EURUSD";
input string Symbol2    = "GBPUSD";
input string Symbol3    = "USDCHF";
input string Symbol4    = "USDJPY";
input string Symbol5    = "USDCAD";
input string Symbol6    = "AUDUSD";
input string Symbol7    = "NZDUSD";
input string Symbol8    = "EURGBP";
input string Symbol9    = "CADCHF";
input int MaxOrders = 20; // Max number of orders
CTrade trade;

datetime t=0;
int delta=0;

Include impostazioni di base come il delta tra gli ordini, il profitto di chiusura (totale, profitto di acquisto e profitto di vendita), il magic number dell'EA, l'importazione della libreria di trading, nonché la selezione delle coppie di valute per il trading e il limite del numero di ordini.

Le funzioni di inizializzazione e deinizializzazione sono generalmente standard. La funzione OnInit() viene chiamata all'avvio dell'EA, mentre OnDeinit() viene chiamata alla sua terminazione. OnInit() imposta il numero magico dell'EA e il timer della funzione di trading:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   // Set a timer with a resolution of 10000 milliseconds (10 seconds) 
   EventSetMillisecondTimer(100000);
   trade.SetExpertMagicNumber(Magic);
//---
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {// Disable timer
   EventKillTimer();
   Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Ecco le funzioni per il conteggio degli ordini aperti e delle posizioni aperte. Le funzioni CountOrders e CountTrades conteggiano gli ordini aperti e le posizioni per un simbolo specifico, tenendo conto del numero magico dell'EA.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(string symbol, ENUM_ORDER_TYPE orderType) {
  int count = 0;
  
  for(int i = OrdersTotal()-1; i >= 0; i--) {
      
    ulong ticket = OrderGetTicket(i);
      
    if(!OrderSelect(ticket)) {
      continue;
    }
      
    if(OrderGetInteger(ORDER_TYPE) != orderType) {
      continue;
    }
    
    if(PositionGetString(POSITION_SYMBOL) != symbol ||
       PositionGetInteger(POSITION_MAGIC) != Magic) {
      continue; 
    }
      
    count++;
  }
  
  return count;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades(string symbol, ENUM_POSITION_TYPE type) {
  int count = 0;
  
  for(int i=PositionsTotal()-1; i>=0; i--) {
    
    ulong ticket=PositionGetTicket(i);
      
    if(!PositionSelectByTicket(ticket)) {
      continue;
    }
    
    if(PositionGetString(POSITION_SYMBOL)==symbol && 
       PositionGetInteger(POSITION_TYPE)==type) {
        
      count++;
    }
  }
  
  return count;
}

Ecco le funzioni per eliminare gli ordini, calcolare i profitti e chiudere gli ordini. DelOrder elimina tutti gli ordini relativi a uno specifico simbolo utilizzando un numero magico. AllProfit calcola il profitto totale o il profitto derivante dalle operazioni di acquisto/vendita per uno specifico simbolo, tenendo conto del numero magico.

//+------------------------------------------------------------------+
//|  Position Profit                                                 |
//+------------------------------------------------------------------+
double AllProfit(string symbol, int positionType = -1) {

  double profit = 0;

  for(int i = PositionsTotal()-1; i >= 0; i--) {

    ulong ticket = PositionGetTicket(i);

    if(!PositionSelectByTicket(ticket)) {
      continue;
    }

    if(PositionGetString(POSITION_SYMBOL) != symbol ||
       PositionGetInteger(POSITION_MAGIC) != Magic) {
      continue;
    }

    if(positionType != -1 && 
       PositionGetInteger(POSITION_TYPE) != positionType) {
      continue;
    }

    profit += PositionGetDouble(POSITION_PROFIT);

  }

  return profit;

}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll(string symbol, int positionType = -1) {

  for(int i = PositionsTotal()-1; i >= 0; i--) {

    ulong ticket = PositionGetTicket(i);

    if(!PositionSelectByTicket(ticket)) {
      continue;
    }

    if(PositionGetString(POSITION_SYMBOL) != symbol ||
       PositionGetInteger(POSITION_MAGIC) != Magic) {
      continue;
    }

    if(positionType != -1 && 
       PositionGetInteger(POSITION_TYPE) != positionType) {
      continue;  
    }

    trade.PositionClose(ticket);

  }

}

Infine, le due funzioni principali sono la funzione di trading e la funzione tick. Trade si occupa di inserire ordini limite di acquisto e di vendita, tenendo conto dei parametri specificati. OnTimer richiama la funzione Trade per negoziare il simbolo selezionato e visualizza le informazioni sui profitti relativi a tale simbolo.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade(string symb)
  {
   double sl = 0, tp = 0;
   double pr=0;
   double Bid=SymbolInfoDouble(symb,SYMBOL_BID);
  
   if(AllProfit(symb)>Profit && Profit>0)
      CloseAll(symb);
   
   if(AllProfit(symb)>Profit && Profit>0)
      CloseAll(symb);
      
   if(AllProfit(symb,0)>BProfit && BProfit>0)
      CloseAll(symb,0);
  
      for(int i=1; i<=Count; i++)
        {
         if(BuyLimit)
           {
           
            if (StopLoss > 0)
                sl = NormalizeDouble(Bid - (StopLoss) * Point(), _Digits);
            if (TakeProfit > 0)
                tp = NormalizeDouble(Bid + (TakeProfit) * Point(), _Digits);
                
            pr=NormalizeDouble(Bid-(Delta+Step)*_Point*i,_Digits);
            trade.BuyLimit(Lots,pr,symb,sl, tp,0,0,"");
           }
         if(SellLimit)
           {
            
            if (StopLoss > 0)
                sl = NormalizeDouble(Bid + (_Point * StopLoss) * Point(), _Digits);
            if (TakeProfit > 0)
                tp = NormalizeDouble(Bid - (_Point * TakeProfit) * Point(), _Digits);
                
            pr=NormalizeDouble(Bid+(Delta+Step)*_Point*i,_Digits);
            trade.SellLimit(Lots,pr,symb,sl, tp,0,0,"");
           }
         
        }
     
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTimer()
  {
   DelOrder();
   Trade(Symbol1);
   Trade(Symbol2);
   Trade(Symbol3);
   Comment("\n All Profit: ",AllProfit(Symbol1),
           "\n Buy Profit: ",AllProfit(Symbol1,0),
           "\n Sell Profit: ",AllProfit(Symbol1,1));
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+--------+

Questo è l'intero codice di questo semplice Expert Advisor (EA).

Risultati del test

Quindi, avviamo l'EA con le impostazioni predefinite nel tester. Ecco i risultati dell’EA per EURUSD, GBPUSD, EURGBP, USDJPY e EURJPY dal 1° febbraio 2023 al 18 febbraio 2024:

I drawdown rispetto agli utili sono molto consistenti. Il drawdown sul capitale netto è generalmente superiore all'utile annuo. L'EA si comporta in modo non molto diverso dai normali EA a griglia. Ecco le statistiche del test:

A quanto pare, questo Expert Advisor non compensa in alcun modo i rischi. Come qualsiasi algoritmo senza un livello di stop, è una bomba a orologeria. Nonostante non mostri perdite, nessuno può garantire che il mercato non subisca un crollo delle valute del 10-15% al giorno. Personalmente, gli ultimi quattro anni mi hanno insegnato che sul mercato tutto è possibile e che persino gli scenari più incredibili possono avverarsi, quindi un Expert Advisor versatile deve essere preparato a tutto. Questo Expert Advisor non soddisfa i miei criteri di valutazione, quindi ho deciso di pubblicarlo.

Conclusioni

Abbiamo quindi creato un esempio del più semplice algoritmo di market maker. Naturalmente, questo esempio è illustrativo e molto semplice. Ovviamente, nessun market maker opera in questo modo sul mercato da tempo. Oggi i loro algoritmi sono al passo con i tempi, utilizzano l'apprendimento automatico e le reti neurali, applicano il deep learning basato su dati in streaming provenienti dal book degli ordini e tengono conto di numerose variabili e caratteristiche di prezzo. Ormai nessuno effettua più ordini al di sopra o al di sotto del prezzo indicato - questo comporta un elevato rischio di invenduto. In futuro, potrebbe essere opportuno sperimentare la creazione di un market maker basato sull'apprendimento automatico, in grado di determinare autonomamente il delta ottimale tra gli ordini.