Aller au contenu

Conversion de taux de symbole

La conversion de taux de symbole est une action essentielle si vous voulez que votre application inclue des fonctionnalités liées aux calculs de P&P.

Cas d'utilisation

Il est nécessaire d'effectuer des conversions de taux de symbole lors du calcul des commissions, des swaps et des dividendes. Les commissions, les swaps et les dividendes sont généralement libellés en USD. Cependant, selon votre courtier et vos préférences, la devise de dépôt de votre compte peut être dans n'importe quel autre actif que l'USD. Pour définir avec précision les commissions, les swaps et les dividendes, vous devriez connaître le taux de change entre l'USD et la devise de dépôt de votre compte.

Chaînes de conversion

Considérez le prix de chaque symbole individuel comme un taux de conversion entre son actif de base et son actif de cotation. La tâche d'obtenir des taux de conversion devient compliquée s'il n'y a pas de symboles qui relient directement un actif donné à un autre actif. Heureusement, le backend de cTrader peut automatiquement créer des chaînes de conversion qui agissent comme les chemins de conversion les plus courts possibles d'un actif à un autre.

Par exemple, si vous voulez convertir EUR en NZD, et qu'il n'y a pas de symbole EURNZD sur le serveur de trading, cTrader proposera une chaîne qui servira d'étapes intermédiaires dans le processus de conversion. Selon la disponibilité des symboles, une telle chaîne pourrait ressembler à EURUSD-USDCAD-CADNZD, EURCFH-CFHUSD-USDNZD, ou même EURCAD-CADUSD-USDCFH-CFHNZD.

Pour convertir entre deux actifs, votre application doit effectuer les actions suivantes :

  • Accéder aux ID des actifs que vous voulez convertir.
  • Obtenir une chaîne de conversion qui inclut un ou plusieurs symboles légers.
  • S'abonner et gérer les événements spot.
  • Suivre la chaîne de conversion et renvoyer le taux de conversion final.

Ci-dessous, nous expliquons chacune de ces actions en détail.

Accéder aux ID des actifs

Les ID des actifs peuvent être accessibles directement en tant que propriétés de l'entité de symbole léger (représentée par le message modèle ProtoOALightSymbol). De plus, vous pouvez obtenir l'ID de la devise de dépôt d'un compte directement à partir de son entité ProtoOaTrader associée.

Notez que l'exemple ci-dessous n'obtient les ID d'actifs que pour un seul symbole. Pour effectuer la même opération pour plusieurs symboles, vous devriez ajouter une boucle ou utiliser une autre solution appropriée (par exemple, une méthode map() ou équivalente).

Travailler avec JSON

Lorsque vous travaillez avec JSON, vous pouvez toujours réutiliser le code ci-dessous et d'autres extraits de code de ce tutoriel. Cependant, assurez-vous de remplacer les noms des classes Proto... par les noms de vos classes personnalisées et faites les modifications nécessaires pour tenir compte de votre client TCP et WebSocket préféré.

symbol est une variable de type ProtoOALightSymbol. Si vous utilisez JSON, elle peut être de n'importe quel type personnalisé représentant le message ProtoOALightSymbol.

1
2
int baseAssetId = symbol.BaseAsset.AssetId; 
int quoteAssetId = symbol.QuoteAsset.AssetId;

Dans l'exemple ci-dessous, nous obtenons l'ID de la devise de dépôt de l'objet account qui est de type ProtoOATrader.

1
int depositAssetId = account.DepositAssetId;

symbol est une variable représentant un message de type ProtoOALightSymbol.

1
2
baseAssetId = symbol.BaseAsset.AssetId
quoteAssetId = symbol.QuoteAsset.AssetId

Dans l'exemple ci-dessous, nous obtenons l'ID de la devise de dépôt de l'objet account qui représente le message modèle ProtoOATrader.

1
depositAssetId = account.depositAssetId

Obtenir une chaîne de conversion

Pour obtenir une chaîne de conversion valide, votre application doit envoyer le message ProtoOASymbolsForConversionReq avec ses champs firstAssetId et lastAssetId définis sur les ID des actifs que vous voulez convertir. Lorsque vous recevez une réponse de type ProtoOASymbolsForConversionRes, stockez son champ répété symbol dans une collection.

Voici comment vous pouvez effectuer cette action via les SDK officiels.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
List<ProtoOALightSymbol> lightSymbolsForConversion = new List<ProtoOALightSymbol>();

var symbolsResult = await GetConversionSymbols(accountId, isLive, baseAssetId, quoteAssetId);

lightSymbolsForConversion.AddRange(symbolsResult);

public Task<ProtoOALightSymbol[]> GetConversionSymbols(long accountId, bool isLive, long baseAssetId, long quoteAssetId)
{
    VerifyConnection();

    var client = GetClient(isLive);

    var taskCompletionSource = new TaskCompletionSource<ProtoOALightSymbol[]>();

    IDisposable disposable = null;

    disposable = client.OfType<ProtoOASymbolsForConversionRes>().Where(response => response.CtidTraderAccountId == accountId)
        .Subscribe(response =>
        {
            taskCompletionSource.SetResult(response.Symbol.ToArray());

            disposable?.Dispose();
        });

    var requestMessage = new ProtoOASymbolsForConversionReq
    {
        CtidTraderAccountId = accountId,
        FirstAssetId = baseAssetId,
        LastAssetId = quoteAssetId
    };

    EnqueueMessage(requestMessage, ProtoOAPayloadType.ProtoOASymbolsForConversionReq, client);

    return taskCompletionSource.Task;
}

1
2
3
4
5
def sendProtoOASymbolsForConversionReq(accountId, firstAssetId, lastAssetId):
    request = ProtoOASymbolsForConversionReq()
    request.ctidTraderAccountId = accountId
    request.firstAssedId = firstAssetId
    request.lastAssetId = lastAssetId

Ajoutez également la condition suivante au callback onMessageReceived.

1
2
3
elif message.payloadType == ProtoOASymbolsForConversionRes().payloadType:
    ProtoOASymbolsForConversionRes = Protobuf.extract(message)
    conversionSymbols = ProtoOASymbolsForConversionRes.symbol

Remarque

Nous recommandons vivement d'obtenir tous les symboles de chaîne de conversion pour chaque actif lorsque vous demandez et recevez pour la première fois les données d'actif du serveur. Sinon, vous devrez envoyer le message ProtoOASymbolsForConversionReq chaque fois que vous aurez besoin de convertir des taux, ce qui, dans certains cas, peut être plusieurs fois par seconde.

Remarque

Comme les entités ProtoOALightSymbol ne contiennent aucun champ représentant les prix bid ou ask, nous recommandons vivement de créer des classes Symbol personnalisées ou équivalentes afin que vous puissiez facilement créer de nouveaux symboles par programmation et mettre à jour leurs propriétés lorsque certains événements sont déclenchés. Vous devrez convertir les symboles légers en objets de cette classe séparément.

S'abonner et gérer les événements spot

Pour suivre la chaîne de conversion du début à la fin, vous devez vous abonner au ProtoOASpotEvent pour tous les symboles inclus dans la chaîne. Voici comment procéder via les SDK officiels.

Avant d'effectuer les opérations listées ci-dessous, créez une classe Symbol ou équivalente afin que vous puissiez facilement créer de nouveaux symboles par programmation et mettre à jour leurs propriétés lorsque certains événements sont déclenchés. Dans les exemples ci-dessous, notre classe Symbol inclut des objets ProtoOASymbol et ProtoOALightSymbol comme propriétés.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public Task<ProtoOASubscribeSpotsRes> SubscribeToSpots(long accountId, bool isLive, params long[] symbolIds)
{
    var client = GetClient(isLive);

    var taskCompletionSource = new TaskCompletionSource<ProtoOASubscribeSpotsRes>();

    IDisposable disposable = null;

    disposable = client.OfType<ProtoOASubscribeSpotsRes>().Where(response => response.CtidTraderAccountId == accountId).Subscribe(response =>
    {
        taskCompletionSource.SetResult(response);

        disposable?.Dispose();
    });

    var requestMessage = new ProtoOASubscribeSpotsReq
    {
        CtidTraderAccountId = accountId,
    };

    requestMessage.SymbolId.AddRange(symbolIds);

    EnqueueMessage(requestMessage, ProtoOAPayloadType.ProtoOaSubscribeSpotsReq, client);

    return taskCompletionSource.Task;
}

Nous devons également nous abonner aux événements spot et les gérer. Dans l'exemple ci-dessous, nous accédons à la collection symbols qui stocke nos symboles légers. Nous trouvons l'objet symbole dont l'ID correspond au champ symbolId du ProtoOASpotEvent que nous venons de recevoir. Enfin, nous mettons à jour les propriétés bid et ask du symbol en utilisant la méthode auxiliaire GetPriceFromRelative.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
client.OfType<ProtoOASpotEvent>().Subscribe(OnSpotEvent);

private void OnSpotEvent(ProtoOASpotEvent spotEvent) 
{
    var symbol = symbols.FirstOrDefault(iSymbol => iSymbol.Id == spotEvent.SymbolId);

    double bid;
    double ask;

    if (spotEvent.HasBid) bid = symbol.Data.GetPriceFromRelative((long)spotEvent.Bid);
    if (spotEvent.HasAsk) ask = symbol.Data.GetPriceFromRelative((long)spotEvent.Ask);

    if (bid != symbol.Bid) 
    {
        symbol.Bid = bid;
        RaisePropertyChanged(nameof(Bid));
    }

    if (ask != symbol.Ask) 
    {
        symbol.Ask = ask
        RaisePropertyChanged(nameof(Ask));
    }

}

Nous pouvons utiliser la fonction suivante pour nous abonner à ProtoOASpotEvent pour un symbole particulier. Notez qu'elle ne s'abonne qu'à un seul symbole, ce qui signifie que vous devriez appeler cette fonction pour chaque symbole léger dans votre collection de symboles de conversion.

1
2
3
4
5
6
7
def sendProtoOASubscribeSpotsReq(symbolId, subscribeToSpotTimestamp = False, clientMsgId = None):
    request = ProtoOASubscribeSpotsReq()
    request.ctidTraderAccountId = currentAccountId
    request.symbolId.append(int(symbolId))
    request.subscribeToSpotTimestamp = subscribeToSpotTimestamp if type(subscribeToSpotTimestamp) is bool else bool(subscribeToSpotTimestamp)
    deferred = client.send(request, clientMsgId = clientMsgId)
    deferred.addErrback(onError)

Pour gérer les événements spot, nous pouvons ajouter les conditions suivantes à notre callback onMessageReceived.

1
2
3
elif message.paloadType == ProtoOASpotEvent().payloadType:
    ProtoOASpotEvent = Protobuf.extract(message)
    onSpotEvent(ProtoOASpotEvent)

Enfin, voici notre callback onSpotEvent.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def onSpotEvent(ProtoOASpotEvent):
    iterableConversionSymbols = iter(conversionSymbols)
    symbol = next(s for s in iterableConversionSymbols if s.symbolId == ProtoOASpotEvent.symbolId)

    if symbol is None:
        return

    if ProtoOASpotEvent.hasBid == true:
        bid = symbol.data.getPipsFromRelative()
    if ProtoOASpotEvent.hasAsk == true:
        ask = symbol.data.getPipsFromRelative()

    if bid != symbol.bid:
        symbol.bid = bid
    if ask != symbol.ask
        symbol.ask = ask

Dans notre classe Symbol, la fonction getPipsFromRelative est définie comme suit :

1
2
3
4
    import math

    def getPipsFromRelative(self, relative):
    return round((relative / 100000.0) / symbol.pipPosition, symbol.digits - symbol.pipPosition)

Notez que les valeurs des propriétés pipPosition et digits doivent être obtenues séparément.

Suivez la chaîne de conversion et retournez le taux de conversion final

À ce stade, tous les symboles de votre chaîne de conversion devraient recevoir des taux spot et vous devriez pouvoir accéder aux prix acheteur et vendeur précis pour chaque symbole. Il ne reste plus qu'à parcourir la chaîne de conversion et à retourner le taux final. Cela peut être fait comme suit :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private double GetConversionRate(List<Symbol> conversionSymbols) 
{
    double conversionRate = 1;

    var currentAsset = conversionSymbols.First().BaseAsset;

    foreach (var symbol in conversionSymbols)
    {
        var closePrice = symbol.Bid; //Replaced by symbol.Ask when calculating P&Ls for short positions

        if (symbol.BaseAsset == currentAsset)
        {
            conversionRate = conversionRate * closePrice;
            currentAsset = symbol.QuoteAsset;
        }
        else
        {
            conversionRate = conversionRate * 1 / closePrice;
            currentAsset = symbol.BaseAsset;
        }
    }

    return conversionRate;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def getConversionRate(conversionSymbols):
    conversionRate = 1
    currentAsset = conversionSymbols[0].baseAsset

    for symbol in conversionSymbols:
        closePrice = symbol.bid #Replaced by symbol.ask when calculating P&L for short positions

        if symbol.baseAsset == currentAsset:
            conversionRate = conversionRate * closePrice
            currentAsset = symbol.quoteAsset

        else:
            conversionRate = conversionRate * 1 / closePrice
            currentAsset = symbol.baseAsset