Outil de négociation quantitative d'options de devises numériques en boîte ouverte

Outil de négociation quantitative d'options de devises numériques en boîte ouverte

1° La quantification des options de monnaie numérique, les transactions procédurales

Récemment, de nombreuses bourses ont ouvert une fonctionnalité de négociation de l'option de crypto-monnaie dérivée, similaire à celle des options traditionnelles, les options et les options futures, qui peuvent être combinées pour combiner de nombreuses stratégies et méthodes de négociation. Bien qu'il existe de nombreux outils de négociation quantitative open source sur le marché, ces outils nécessitent une connaissance de la base du cadre, une connaissance du langage de programmation du cadre ou une configuration manuelle.

发明者量化（FMZ.COM）在早期架构设计时，就考虑了各种金融衍生品量化、程序化交易的支持，非常快捷的接入了期权交易。期权交易基本上和期货交易类似，甚至更加简单。并且没有增加新接口，熟悉使用FMZ的用户不会增加其它学习成本，只用把期权合约当做期货合约一样设置，就可以对期权合约进行行情获取，下单、撤单、查询持仓等操作。

2° Accéder directement à Deribit en langage natif

Prenons l'exemple d'un contrat d'options sur l'échange Deribit, par exemple si nous voulons obtenir le prix indiciel d'un contrat d'options en cours.

Le langage Go est utilisé:

package main 

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



func main() {
    // 获取行情, 访问接口: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("这只是字符串数据ticker:", ret)
    fmt.Println("需要转换为JSON格式") 

    type js struct {
        data interface{}
    }

    ticker := new(js)

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

    fmt.Println("ticker:", ticker) 
    fmt.Println("ticker 中的标记价格数据index_price：", ticker.data.(map[string]interface{})["result"].(map[string]interface{})["index_price"])
}

Vous pouvez voir qu'il y a un tas de code écrit pour obtenir ces données.

3° l'interface utilisée par l'inventeur pour quantifier l'emballage de la plateforme

Nous l'avons fait en utilisant deux phrases simples de FMZ.

function main() {
    exchange.IO("base", "https://test.deribit.com")   # 切换为 交易所提供的模拟盘
    exchange.SetContractType("BTC-3JAN20-7250-P")     # 设置期权合约
    var ticker = exchange.GetTicker()                 # 获取期权行情
    Log(ticker.Info.result.index_price)               # 打印需要的数据，观察
}

Comme vous pouvez le voir, quelques lignes de code suffisent pour obtenir facilement les données dont vous avez besoin.

Il s'agit simplement d'une interface API publique non signée pour accéder à l'échange, ce qui serait plus compliqué si l'on accédait à une interface privée signée.

Chaque interface doit également traiter une multitude de signatures, 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 besoins et des fonctions plus complexes

De plus, si vous utilisez une base de code qui nécessite la synchronisation, l'acquisition asynchrone, les opérations de commande, et pour traiter une base de code asynchrone, vous devez écrire une logique de traitement asynchrone plus complexe, une non-déclaration peut également causer des problèmes de conception logique tels que le bloc mort. Si vous utilisez une nouvelle base de données pour afficher des graphiques, il faut ensuite apprendre à utiliser une grande base de données.

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 de la plate-forme, la " bibliothèque de classes de lignes de dessin ", il est très simple de dessiner un diagramme en K-lignes:

Il y a encore plus de fonctionnalités à explorer et à développer!

5 et note en arrière

Si vous utilisez directement un langage go comme celui ci-dessus (ou python, etc.), vous risquez d'être immédiatement repoussé. Pour plus de détails sur les stratégies de modèle pour les opérations d'options Deribit:https://www.fmz.com/strategy/179475