Outil de négociation quantitatif hors stock pour les options de devises numériques

Outil de négociation quantitatif hors stock pour les options de devises numériques

1. Commerce quantitatif et par programme d'options sur devises numériques

Récemment, de nombreux échanges ont ouvert successivement la fonction de négociation des options de monnaie numérique en tant que dérivé. À l'instar des options traditionnelles, le trading d'options et le trading à terme peuvent être combinés pour former de nombreuses stratégies et méthodes de trading. Bien qu'il existe de nombreux outils de trading quantitatif open source sur le marché, ces outils doivent souvent comprendre le cadre sous-jacent, être familiarisés avec le langage de programmation pour écrire le cadre, ou effectuer manuellement des débogages, des configurations et des modifications complexes.

Dans la première conception de l'architecture, le FMZ Quant (FMZ.COM) a pris en compte le support de la quantification de divers produits financiers dérivés et du programme de négociation, et a rapidement accédé au trading d'options. Le trading d'options est fondamentalement similaire au trading à terme, voire plus simple.

2. Accédez directement à Deribit Exchange en utilisant le langage de programmation natif

Prenons l'exemple du contrat d'option de Deribit Exchange. par exemple, nous devons obtenir le prix d'indice d'un contrat d'option en cours.

Implémenté dans le langage Go:

package main 

import "net/http"
import "io/ioutil"
import "fmt"
import "encoding/json"



func main() {
    // Get ticker, access interface: https://www.deribit.com/api/v2/public/ticker?instrument_name=BTC-27DEC19-7250-P

    resp, err := http.Get("https://www.deribit.com/api/v2/public/ticker?instrument_name=BTC-27DEC19-7250-P")
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    ret := string(body)
    fmt.Println("This is just string data ticker:", ret)
    fmt.Println("Need to convert to JSON format") 

    type js struct {
        data interface{}
    }

    ticker := new(js)

    json.Unmarshal([]byte(ret), &ticker.data)

    fmt.Println("ticker:", ticker) 
    fmt.Println("index_price, marked price data in ticker:", ticker.data.(map[string]interface{})["result"].(map[string]interface{})["index_price"])
}

3. Utiliser l'interface encapsulée par la plateforme de trading FMZ Quant

Nous l'avons terminé en utilisant la plateforme FMZ en deux phrases simples.

function main() {
    exchange.IO("base", "https://test.deribit.com")   # Switch to the demo offered by the exchange
    exchange.SetContractType("BTC-3JAN20-7250-P")     # Set up options contracts
    var ticker = exchange.GetTicker()                 # Get options ticker
    Log(ticker.Info.result.index_price)               # Print the required data and observe
}

Comme nous pouvons le voir, il est très simple d'obtenir les données requises en quelques lignes de code.

Il s'agit simplement d'accéder à l'interface API publique non signée de l'échange; accéder à l'interface privée signée serait plus compliqué.

Chaque interface doit faire beaucoup de signatures, de traitement de paramètres, etc.

        strBody := ""
	strQuery := ""
	ts := toString(time.Now().UnixNano() / 1e6)
	nonce := toString(time.Now().UnixNano() / 1e6)
	uri := resource
	if httpMethod == "GET" {
		strQuery = encodeParams(params, false)
		uri = fmt.Sprintf("%s?%s", resource, strQuery)
	} else if httpMethod == "POST" {
		if len(raw) > 0 && len(raw[0]) > 0 {
			strBody = raw[0]
		} else {
			strBody = json_encode(params)
		}
	}

	strRequestDate := fmt.Sprintf("%s\n%s\n%s\n", httpMethod, uri, strBody)
	strToSign := fmt.Sprintf("%s\n%s\n%s", ts, nonce, strRequestDate)
	h := hmac.New(sha256.New, []byte(p.secretKey))
	h.Write([]byte(strToSign))
	strSign := hex.EncodeToString(h.Sum(nil))

	req := Request{
		Method:  httpMethod,
		Uri:     fmt.Sprintf("%s%s", p.apiBase, uri),
		Timeout: p.timeout,
		Body:    strBody,
	}

4. Des exigences et des fonctions plus complexes

Non seulement cela, si vous avez besoin d'utiliser l'accès asynchrone simultané au marché, les opérations d'ordre et la bibliothèque de code pour gérer les asynchrones, vous devez écrire une logique de traitement asynchrone plus complexe. Une inattention peut également causer des problèmes de conception logique tels que le verrouillage. Si vous avez besoin d'utiliser à nouveau l'affichage de graphiques, vous devez apprendre à utiliser beaucoup de bibliothèques. Même un trader quantitatif ayant une base de programmation a besoin de temps pour apprendre. Cependant, il est beaucoup plus facile d'utiliser la plate-forme FMZ Quant, car ces fonctions ont été encapsulées et les interfaces d'appel conçues sont très simples et faciles à utiliser. Vous pouvez utiliser très peu de code pour implémenter les fonctions de diverses exigences.

function main(){
    exchange.IO("base", "https://test.deribit.com")
    exchange.SetContractType("BTC-27DEC19-7250-P")
    while(1){
        var records = exchange.GetRecords()
        Log(records)
        $.PlotRecords(records, "K")
        Sleep(1000)
    }
}

En utilisant la bibliothèque de modèles Plot Library fournie par la plateforme, il est facile de dessiner un diagramme en K-lignes:

Il y a d'autres fonctions à explorer et à développer!

5. Le post-script

Si elle est mise en œuvre directement dans le langage go (ou python, etc.) comme ci-dessus, les nouveaux étudiants peuvent être découragés directement>_< Par exemple, les stratégies d'opération des options Deribit, voir:https://www.fmz.com/strategy/179475