Digitale Währung Optionen Quantitative Handelstools aus der Box

Digitale Währung Optionen Quantitative Handelstools aus der Box

1. Die Quantisierung von digitalen Währungsoptionen, die Prozedurisierung von Transaktionen

In jüngster Zeit haben zahlreiche Börsen die Handelsfunktionalität des Derivates der digitalen Währung Option eröffnet. In Kombination mit traditionellen Optionen und Futures können viele Handelsstrategien und Handelsmethoden kombiniert werden. Obwohl es viele Quantifizierungs-Handelsmittel mit Open Source auf dem Markt gibt, erfordern diese Tools eine Kenntnis der Grundlagen des Rahmens, Kenntnis der Programmiersprache des Rahmens oder eine manuelle Komplexität.

Erfinder quantifizierenFMZ.COMIn den frühen Architekturentwürfen wurde die Unterstützung für die Quantifizierung verschiedener Finanzderivate und die Programmierung von Transaktionen berücksichtigt. Der Zugang zum Optionsgeschäft war sehr schnell. Der Optionsgeschäft ähnelte grundsätzlich dem des Futuresgeschäfts oder war sogar einfacher.

2. Zugriff auf die Deribit-Börse direkt in der nativen Programmiersprache

Wir nehmen als Beispiel Optionskontrakte an der Börse Deribit, z. B. wenn wir den Indexpreis eines aktuellen Optionskontrakts erhalten wollen.

Das Programm wird in der Sprache Go realisiert:

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"])
}

Man kann sehen, dass nur um diese Daten zu erhalten, N mehr Code geschrieben wurde.

3. Schnittstellen, die von den Erfindern für die Quantifizierung der Plattform verpackt wurden

Wir haben es mit zwei einfachen Sätzen gelöst:

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)               # 打印需要的数据，观察
}

Wie Sie sehen können, ist es mit nur wenigen Zeilen Code sehr einfach, die Daten zu erhalten, die Sie benötigen.

Dies ist lediglich eine öffentliche API-Schnittstelle, die nicht mit einer Signatur verbunden ist, die auf die Börse zugegriffen wird, und eine private Schnittstelle, die mit einer Signatur verbunden ist, ist viel komplexer.

Jede Schnittstelle muss auch eine Menge von Signaturen, Parametern und anderen Dingen verarbeiten:

        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. Komplexere Bedürfnisse und Funktionen

Darüber hinaus kann es zu logischen Designproblemen kommen, wenn es darum geht, eine Reihe von Datenbanken zu verwenden, die gleichzeitig, asynchronisiert, ausgewertet und ausgewertet werden müssen, und wenn es darum geht, eine asynchrone Codebase zu verarbeiten, muss eine komplexere Asynchronous Processing-Logik geschrieben werden. Wenn es darum geht, ein Diagramm anzuzeigen, dann braucht es eine gewisse Zeit, um einen großen Stapel von Datenbanken zu erlernen, auch für einen programmierenden Quantitative Trader.

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)
    }
}

Mit der von der Plattform zur Verfügung gestellten Template-Library "Draw Line Class Library" können Sie ganz einfach K-Linien-Diagramme erstellen:

Es gibt noch mehr Funktionen, die man entdecken und entwickeln kann!

5. Nachträglich

Wenn sie direkt mit einer ähnlichen Sprache wie go (oder python usw.) realisiert werden, werden möglicherweise neue Schüler direkt abgeschoben >_< Die Strategie für die Optionsausführung von Deribit ist folgender:https://www.fmz.com/strategy/179475