Funzioni di Money Management in un Expert Advisor

Introduzione

Il linguaggio MQL5 offre l'opportunità di ottenere una grande quantità di informazioni sulle attuali condizioni del terminale, del programma mql5, nonché dello strumento finanziario e dell’account di trading. Per organizzare le funzioni di gestione del capitale, dovremo studiare le proprietà delle ultime due sezioni elencate, oltre a familiarizzare con le seguenti funzioni:

• SymbolInfoInteger()
• SymbolInfoDouble()
• SymbolInfoString()
• AccountInfoInteger()
• AccountInfoDouble()
• AccountInfoString()

Sebbene in questo articolo l'attenzione principale sia rivolta all'uso delle funzioni negli Expert Advisor, tutte queste descrizioni possono essere applicate agli indicatori e agli script.

Ottenere informazioni sul saldo del tuo account

Le prime due caratteristiche importanti di un account di trading: il saldo e il capitale. Per ottenere questi valori, utilizza la funzione AccountInfoDouble() : 

   double balance=AccountInfoDouble(ACCOUNT_BALANCE);
   double equity=AccountInfoDouble(ACCOUNT_EQUITY);

La prossima cosa che ci interessa, è la quantità dei fondi di deposito per le posizioni aperte e il profitto o la perdita fluttuante totale sull’account, per tutte le posizioni aperte.

   double margin=AccountInfoDouble(ACCOUNT_MARGIN);
   double float_profit=AccountInfoDouble(ACCOUNT_PROFIT);

Per poter aprire nuove posizioni o rafforzare quelle esistenti, abbiamo bisogno di risorse gratuite, non partecipando al deposito.

   double free_margin=AccountInfoDouble(ACCOUNT_FREEMARGIN);

Qui, va notato che i valori di cui sopra sono espressi in termini monetari.

I valori monetari, restituiti dalla funzione AccountInfoDouble(), sono espressi in deposito di valuta. Per scoprire il deposito di valuta, utilizzare la funzione AccountInfoString().

string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

Il livello dei fondi personali

L’account possiede un'altra caratteristica importante: il livello al quale si verifica l'evento Stop Out (una chiusura obbligatoria di una posizione a causa di una carenza di fondi personali necessari per mantenere le posizioni aperte). Per ottenere questo valore, riutilizzare la funzione AccountInfoDouble():

double stopout_level=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);

La funzione restituisce solo il valore stesso, ma non spiega in quale tipo di unità è espresso questo valore. Esistono due modalità di specifica del livello per Stop Out: in percentuale e in valuta. Per scoprirlo, utilizzare la funzione AccountInfoInteger():  

//--- Get account currency
string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

//--- Stop Out level
   double stopout_level=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);

//--- Stop Out mode
   ENUM_ACCOUNT_STOPOUT_MODE so_mode=(ENUM_ACCOUNT_STOPOUT_MODE)AccountInfoInteger(ACCOUNT_MARGIN_SO_MODE);
   if(so_mode==ACCOUNT_STOPOUT_MODE_PERCENT)

      PrintFormat("Stop Out level in percents %.2f%%",stopout_level);
   else
      PrintFormat("Stop Out level in currency %.2f %s",stopout_level,account_currency);

Ulteriori informazioni sull'account

Spesso nei calcoli è necessario conoscere la dimensione della leva dell’account di trading fornita. È possibile tali queste informazioni utilizzando la funzione AccountInfoInteger():

   int leverage=(int)AccountInfoInteger(ACCOUNT_LEVERAGE);

Per evitare di eseguire accidentalmente l'Expert Advisor non regolamentato su un account reale, è necessario conoscere il tipo di account. 

   ENUM_ACCOUNT_TRADE_MODE mode=(ENUM_ACCOUNT_TRADE_MODE)AccountInfoInteger(ACCOUNT_TRADE_MODE);
   switch(mode)
     {
      case ACCOUNT_TRADE_MODE_DEMO:    Comment("Account demo");               break;
      case ACCOUNT_TRADE_MODE_CONTEST: Comment(com,"Account Contest");        break;
      case ACCOUNT_TRADE_MODE_REAL:    Comment(com,"Account Real");           break;
      default:                         Comment(com,"Account unknown type");
     }

Il trading non è possibile su tutti gli account, ad esempio su account competitivi, le operazioni di trading possono essere eseguite solo dopo l'inizio della competizione. Queste informazioni possono essere ottenute anche mediante la funzione AccountInfoInteger():

   bool trade_allowed=(bool)AccountInfoInteger(ACCOUNT_TRADE_ALLOWED);
   if(trade_allowed)
      Print("Trade is allowed");
   else
      Print(com,"Trade is not allowed");

Anche se il trading su questo account è consentito, ciò non significa che l'Expert Advisor abbia il diritto di fare trading. Per verificare se l'Expert Advisor è autorizzato a fare trading, scrivi:

   if(trade_allowed)
     {
      bool trade_expert=(bool)AccountInfoInteger(ACCOUNT_TRADE_EXPERT);
      if(trade_expert)
         Print("Experts are allowed to trade");

      else
         Print("Experts are not allowed to trade");

Questi esempi si trovano nell'allegato Expert Advisor Account_Info.mq5 . Possono essere utilizzati in programmi MQL5 di qualsiasi complessità.

Informazioni sullo strumento

Ogni strumento finanziario ha le sue descrizioni ed è posto su un percorso che questo strumento caratterizza. Se apriamo la finestra delle proprietà EURUSD nel terminale, vedremo qualcosa di simile a questo:

In questo caso, la descrizione per EURUSD è - "EURUSD, Euro vs Dollaro USA". Per ottenere queste informazioni, utilizziamo la funzione SymbolInfoString():

   string symbol=SymbolInfoString(_Symbol,SYMBOL_DESCRIPTION);
   Print("Symbol: "+symbol);

   string symbol_path=SymbolInfoString(_Symbol,SYMBOL_PATH);
   Print("Path: "+symbol_path);

Per scoprire le dimensioni di un contratto standard, utilizzare la funzione SymbolInfoDouble():

   double lot_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE);
   Print("Standard contract: "+DoubleToString(lot_size,2));

Vendere una valuta mentre ne acquista un'altra, è una caratteristica degli strumenti FOREX. Il contratto è indicato nella valuta necessaria per effettuare l'acquisto. Questa è una valuta di base e può essere ottenuta utilizzando la funzione SymbolInfoString():

   string base_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_BASE);
   Print("Base currency: "+base_currency);

Le variazioni di prezzo nello strumento portano a una variazione del prezzo di un bene acquistato e, quindi, a una variazione del profitto per una posizione aperta (il profitto può essere negativo se la posizione è in perdita). Pertanto, la variazione del prezzo porta a cambiamenti a livello di reddito, espressi in una particolare valuta. Questa valuta è chiamata quote currency. Per una coppia di valute EURUSD la base currency è di solito l'Euro e la quote currency è il dollaro USA. Per ottenere la quote currency, è anche possibile utilizzare la funzione SymbolInfoString():

   string profit_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);

   Print("Currency quotes: "+profit_currency);

Per aprire una posizione sullo strumento, hai bisogno di fondi e questi fondi sono anche espressi in una particolare valuta. Questa valuta è chiamata valuta margine o deposito in valuta. Per gli strumenti FOREX,le valute margine o le base currency sono solitamente le stesse.. Per ottenere il valore della valuta di deposito, utilizzare la funzione SymbolInfoString():

   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);
   Print("Currency deposit: "+margin_currency);

Tutte le funzioni descritte sono riportate nel codice dell'Expert Advisor Symbol_Info.mq5.   La figura seguente illustra l'output di informazioni sul simbolo EURUSD, utilizzando la funzione Comment().

Calcolo dell’entità del deposito

Le informazioni sugli strumenti finanziari, più necessarie per i trader, sono le quantità di fondi necessarie per aprire una posizione su di essi. Senza sapere quanto denaro è necessario per acquistare o vendere un determinato numero di lotti, non possiamo implementare il sistema di Expert Advisor per la gestione del capitale. Inoltre, anche il controllo del saldo dell’account diventa complicata.

Se hai difficoltà a capire il resto della discussione, ti consiglio di leggere l'articolo ABC del Forex Trading. Le spiegazioni in esso contenute sono applicabili anche a questo articolo.

Dobbiamo calcolare la dimensione del margine nel deposito in valuta, cioè ricalcolare il deposito dalla valuta ipotecaria alla valuta di deposito, dividendo il valore ottenuto per l'importo della leva dell’account dato. Per fare ciò scriviamo la funzione GetMarginForOpening():

//+------------------------------------------------------------------+
//|  Return amount of equity needed to open position                 |
//+------------------------------------------------------------------+
double GetMarginForOpening(double lot,string symbol,ENUM_POSITION_TYPE direction)
  {
   double answer=0;
//--- 
    ...
//--- Return result - amount of equity in account currency, required to open position in specified volume
   return(answer);
  }

dove:

• lotto - il volume della posizione aperta;
• simbolo - il nome dello strumento finanziario;
• la presunta direzione della posizione.

Quindi, abbiamo le seguenti informazioni per calcolare la dimensione del margine (fondi monetari per l'ipoteca della posizione aperta):

• valuta in deposito
• valuta ipotecaria
• currency quote (potrebbe essere necessario per le coppie Cross Currency)
  
• dimensione del contratto

Scrivi questo nel linguaggio MQL5:

//--- Get contract size
   double lot_size=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);

//--- Get account currency
   string account_currency=AccountInfoString(ACCOUNT_CURRENCY);

//--- Margin currency
   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);

//--- Profit currency
   string profit_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);

//--- Calculation currency
   string calc_currency="";
//--- Reverse quote - true, Direct quote - false
   bool mode;

La variabile mode influenza il modo in cui calcoleremo la dimensione del contratto nella valuta di deposito. Considera questo sulla base di esempi, in tutti gli altri casi supponiamo che la valuta di deposito sia il dollaro USA.

Le coppie di valute sono solitamente divise in tre categorie:

• Coppie di valute dirette - il tasso di cambio del dollaro USA in una particolare valuta. Esempi: USDCHF, USDCAD, USDJPY, USDSEK;
• Coppia di valute inverse - il tasso di cambio di una particolare valuta per il dollaro USA. Esempi: EURUSD, GBPUSD, AUDUSD, NZDUSD;
• coppia di Cross Currency - una coppia di valute, che non riguarda il dollaro USA. Esempi: AUDCAD, EURJPY, EURCAD. 
  

1. EURUSD - coppia di valute inverse

Chiameremo le coppie di valute, in cui la quote currency è la valuta dell’account, coppie di valute inverse. Nei nostri esempi, la valuta dell’account è rappresentata con il dollaro USA; quindi, la nostra classificazione delle coppie di valute coinciderà con la classificazione generalmente accettata. Tuttavia, se il tuo account di trading utilizza una valuta diversa (non USD), non coinciderà. In questo caso, considera la valuta dell’account al fine di comprendere eventuali ulteriori spiegazioni.

La dimensione del contratto per EURUSD - 100 000 euro. Abbiamo bisogno di esprimere 100 000 euro nella valuta del deposito - dollari USA. Per fare questo, è necessario conoscere il tasso di cambio in base al quale l'euro può essere contato in dollari. Introduciamo il concetto divaluta di calcolo, cioè la valuta necessaria per convertire la valuta ipotecaria nella valuta di deposito.

//--- Calculation currency
   string calc_currency="";

Fortunatamente, la coppia di valute EURUSD visualizza il tasso di cambio dell'euro rispetto al dollaro, e quindi, per questo caso, il simbolo di EURUSD, per il quale è necessario calcolare la dimensione del mutuo, è proprio il tasso di cambio:

//--- If profit currency and account currency are equal
   if(profit_currency==account_currency)
     {
      calc_currency=symbol;
      mode=true;
     }

Abbiamo stabilito il valore della modalità come vero, il che significa che per trasferire da euro in dollari (la valuta ipotecata è convertibile nella valuta di deposito), moltiplicheremo il tasso di cambio corrente di EURUSD per la dimensione del contratto. Se mode  = false, dividiamo la dimensione del contratto per il tasso di cambio della valuta di calcolo. Per ottenere i prezzi correnti sullo strumento, utilizzare la funzione SymbolInfoTick().

//--- We know calculation currency, let's get its last prices
   MqlTick tick;
   SymbolInfoTick(calc_currency,tick);

Questa funzione inserisce il prezzo e l'ora correnti dell'ultimo aggiornamento dei prezzi nella variabiledel tipo MqlTick - questa struttura è stata appositamente progettata a tale scopo.  

Pertanto, è sufficiente ottenere l'ultimo prezzo su questo simbolo, moltiplicarlo per la dimensione del contratto e, quindi, per il numero di lotti. Ma quale prezzo di calcolo dovremmo prendere, considerando che esiste un prezzo di acquisto e un prezzo di vendita per questo strumento? Dunque, logicamente: se stiamo acquistando, il prezzo per i calcoli è uguale al prezzo Ask, e se stiamo vendendo, dovremo prendere il prezzo Bid.

//--- Now we have everything for calculation 
   double calc_price;
//--- Calculate for Buy
   if(direction==POSITION_TYPE_BUY)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Buy price for reverse quote
         calc_price=tick.ask;
         answer=lot*lot_size*calc_price;
        }
     }

//--- calculate for Sell
   if(direction==POSITION_TYPE_SELL)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Sell price for reverse quote

         calc_price=tick.bid;
         answer=lot*lot_size*calc_price;
        }
     }

Pertanto, nel nostro esempio, per il simbolo EURUSD la valuta di deposito è Euro, la dimensione del contratto è 100 000 e l'ultimo prezzo Ask = 1.2500. Valuta dell’account- dollaro USA e la valuta di calcolo è la stessa coppia di valute EURUSD. Moltiplica 100.000 per 1.2500 e ottieni 125.000 dollari USA; questo è esattamente un contratto standard per l'acquisto di 1 lotto EURUSD, se il prezzo Ask = 1.2500. 

Possiamo concludere che se la quote currency è uguale alla valuta dell’account, allora per ottenere il valore di un lotto della valuta dell’account moltiplichiamo semplicemente la dimensione del contratto per il relativo prezzo, Bid o Ask, a seconda della direzione prevista della posizione.

margin=lots*lot_size*rate/leverage;

2. USDCHF - coppia di valute dirette

La valuta del mutuo e la valuta dell’account per USDCHF corrispondono - il dollaro USA. Chiameremo coppie di valute dirette quelle coppie di valute in cui la valuta del mutuo e la valuta dell’account sono le stesse. Dimensione del contratto - 100.000. Questa è la situazione più semplice, restituire semplicemente il prodotto.

//--- if the base currency symbol and the deposit currency are the same
   if(margin_currency==account_currency)
     {
      calc_currency=symbol;
      //--- Just return the contract value, multiplied by the number of lots
      return(lot*lot_size);
     }

Se la valuta di deposito coincide con la valuta dell’account, il valore del deposito nella valuta dell’account è uguale al prodotto del contratto standard moltiplicato per il numero di lotti (contratti) diviso per la dimensione della leva.

margin=lots*lot_size/leverage;

3. CADCHF - coppia di cross currency

La coppia di valute CADCHF viene presa a scopo illustrativo e può essere utilizzata qualsiasi altra coppia in cui la valuta di deposito e la quote currency coincidono con la valuta dell’account. Queste coppie di valute sono chiamate cross, perché per calcolare il margine e il profitto su di esse, dobbiamo conoscere il tasso di cambio di qualche altra coppia di valute, che si interseca con quella su una delle valute.

Di solito, le coppie cross-currency sono le coppie, le cui quotazioni non utilizzano il dollaro USA. Ma chiameremo coppie di cross currency tutte quelle le coppie che non includono la valuta dell’account nelle sue quotazioni. Pertanto, se la valuta dell’account è in Euro, la coppia GBPUSD sarà una coppia cross currency, poiché la valuta di deposito è in sterline britanniche mentre le quotazioni valutarie sono in dollari USA. In questo caso, per calcolare il margine, dovremo esprimere la sterlina (GBP) in Euro (EUR).

Tuttavia, continueremo a considerare un esempio in cui il simbolo è la coppia di valute CADCHF. La valuta di deposito è in dollari canadesi (CAD) e non coincide con il dollaro USA (USD). La quote currency è in franchi svizzeri e non coincide nemmeno questa con il dollaro USA.

Possiamo solo dire che il deposito per l'apertura di una posizione in 1 lotto equivale a 100.000 dollari canadesi. Il nostro compito è quello di ricalcolare il deposito nella valuta dell’account in dollari USA. Per fare questo, dobbiamo trovare la coppia di valute il cui tasso di cambio contiene il dollaro USA e la valuta di deposito - dollaro canadese. Vi sono due potenziali opzioni:

• CADUSD
• USDCAD

Abbiamo i dati di output per il CADCHF:

margin_currency=CAD (Canadian dollar)
profit_currency=CHF (Swiss frank)

Non sappiamo in anticipo quale delle coppie di valute esista nel terminale e, in termini di linguaggio MQL5, nessuna delle due opzioni è preferibile. Pertanto, scriviamo la funzione GetSymbolByCurrencies() che per il dato set di valute ci darà la prima coppia di valute corrispondenti per i calcoli.

//+------------------------------------------------------------------+
//| Return symbol with specified margin currency and profit currency |
//+------------------------------------------------------------------+
string GetSymbolByCurrencies(string margin_currency,string profit_currency)
  {
//--- In loop process all symbols, that are shown in Market Watch window
   for(int s=0;s<SymbolsTotal(true);s++)
     {
      //--- Get symbol name by number in Market Watch window
      string symbolname=SymbolName(s,true);

      //--- Get margin currency
      string m_cur=SymbolInfoString(symbolname,SYMBOL_CURRENCY_MARGIN);

      //--- Get profit currency (profit on price change)
      string p_cur=SymbolInfoString(symbolname,SYMBOL_CURRENCY_PROFIT);

      //--- if If symbol matches both currencies, return symbol name
      if(m_cur==margin_currency && p_cur==profit_currency) return(symbolname);
     }
   return(NULL);
  }

Come si può vedere dal codice, iniziamo l'enumerazione di tutti i simboli disponibile nella finestra "Market View" (la funzione SymbolsTotal() con parametro "true" ci darà questo importo). Per ottenere il nome di ogni simbolo dal numero nell'elenco della finestra "Market View", usiamo la funzione SymbolName() con parametro true!  Se impostiamo il parametro su "false", enumereremo tutti i simboli presentati sul server di trading; questo, di solito, è molto più di quello che viene selezionato sul terminale.

  Successivamente, usiamo il nome del simbolo per ottenere il deposito di valuta e le quotazioni e per confrontarle con quelle che passate alla funzione GetSymbolByCurrencies(). In caso di successo, restituiamo il nome del simbolo e il lavoro della funzione viene completato con successo e prima del previsto. Se il ciclo è completato e raggiungiamo l'ultima riga della funzione, allora nulla si adatta e il simbolo non è stato trovato, - restituisce NULL.

Ora che possiamo ottenere la valuta di calcolo per la coppia di cross currency, utilizzando la funzione GetSymbolByCurrencies() faremo due tentativi: nel primo tentativo cercheremo il simbolo, la cui valuta di deposito è la margin_currency (valuta di deposito CADCHF - CAD) e la quote currency è la valuta dell’account(USD). In altre parole, stiamo cercando qualcosa di simile alla coppia di CADUSD.

//--- If calculation currency is still not determined
//--- then we have cross currency
   if(calc_currency="")
     {
      calc_currency=GetSymbolByCurrencies(margin_currency,account_currency);
      mode=true;
      //--- If obtained value is equal to NULL, then this symbol is not found
      if(calc_currency==NULL)
        {
         //--- Lets try to do it reverse
         calc_currency=GetSymbolByCurrencies(account_currency,margin_currency);
         mode=false;
        }
     }

Se il tentativo fallisce, individua un'altra opzione: cerca un simbolo, la cui valuta di deposito sia account_currency (USD) e la quote currency sia margin_currency (valuta di deposito per CADCHF - CAD). Stiamo cercando qualcosa di simile all'USDCAD.

Ora che abbiamo trovato la coppia di valute di calcolo, essa può essere una delle due opzioni: diretta o inversa. La variabile mode assume il valore "true" per la coppia di valute inversa. Se abbiamo una coppia di valute dirette, il valore è uguale a "false". Per il valore "true", lo moltiplichiamo per il tasso di cambio della coppia di valute, per il valore false, lo dividiamo per il valore di deposito di un contratto standard nella valuta dell’account.

Ecco il calcolo finale della dimensione del deposito nella valuta dell’account per la valuta di calcolo trovata. È adatto per entrambe le opzioni: le coppie di valute dirette e inverse.

//--- We know calculation currency, let's get its last prices
   MqlTick tick;
   SymbolInfoTick(calc_currency,tick);

//--- Now we have everything for calculation
   double calc_price;
//--- Calculate for Buy
   if(direction==POSITION_TYPE_BUY)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Buy price for reverse quote
         calc_price=tick.ask;
         answer=lot*lot_size*calc_price;
        }
      //--- Direct quote 
      else
        {
         //--- Calculate using Sell price for direct quote
         calc_price=tick.bid;
         answer=lot*lot_size/calc_price;
        }
     }

//--- Calculate for Sell
   if(direction==POSITION_TYPE_SELL)
     {
      //--- Reverse quote
      if(mode)
        {
         //--- Calculate using Sell price for reverse quote
         calc_price=tick.bid;
         answer=lot*lot_size*calc_price;
        }
      //--- Direct quote 
      else
        {
         //--- Calculate using Buy price for direct quote
         calc_price=tick.ask;
         answer=lot*lot_size/calc_price;
        }
     }

Restituisce il risultato ottenuto.

 //--- Return result - amount of equity in account currency, required to open position in specified volume
return  (Answer);

La funzione GetMarginForOpening() completa il suo lavoro a questo punto. L'ultima cosa che dobbiamo fare è dividere il valore ottenuto per la dimensione della leva fornita e, quindi, otterremo il valore del margine per le posizioni aperte con il volume specificato nella direzione assunta. Tieni presente che per i simboli, che rappresentano le coppie di valute inverse o le coppire cross currency, il valore del margine varierà con ogni tick.

Ecco una parte del codice SymbolInfo_Advanced.mq5 dell’Expert Advisor. Il codice completo viene allegato come file

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- String variable for comment
   string com="\r\n";
   StringAdd(com,Symbol());
   StringAdd(com,"\r\n");

//--- Size of standard contract
   double lot_size=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE);

//--- Margin currency
   string margin_currency=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);
   StringAdd(com,StringFormat("Standard contract: %.2f %s",lot_size,margin_currency));
   StringAdd(com,"\r\n");

//--- Leverage
   int leverage=(int)AccountInfoInteger(ACCOUNT_LEVERAGE);
   StringAdd(com,StringFormat("Leverage: 1/%d",leverage));
   StringAdd(com,"\r\n");

//--- Calculate value of contract in account currency
   StringAdd(com,"Deposit for opening positions in 1 lot consists ");

//--- Calculate margin using leverage
   double margin=GetMarginForOpening(1,Symbol(),POSITION_TYPE_BUY)/leverage;
   StringAdd(com,DoubleToString(margin,2));
   StringAdd(com," "+AccountInfoString(ACCOUNT_CURRENCY));

   Comment(com);
  }

e il risultato del suo lavoro viene riportato sul grafico.

Conclusione

Gli esempi forniti dimostrano quanto sia facile e semplice ottenere informazioni sulle caratteristiche più importanti dell’account di trading e sulle proprietà degli strumenti finanziari.