Nicht mehr verfügbares quantitatives Handelsinstrument für digitale Währungsoptionen

Nicht mehr verfügbares quantitatives Handelsinstrument für digitale Währungsoptionen

1. Quantitativer und programmierter Handel mit digitalen Währungsoptionen

In letzter Zeit haben viele Börsen sukzessive die Handelsfunktion von digitalen Währungsoptionen als Derivat eröffnet. Ähnlich wie bei herkömmlichen Optionen können Optionshandel und Futureshandel kombiniert werden, um viele Handelsstrategien und Methoden zu bilden. Obwohl es viele Open-Source-quantitative Handelswerkzeuge auf dem Markt gibt, müssen diese Werkzeuge oft das zugrunde liegende Framework verstehen, mit der Programmiersprache für das Schreiben des Frameworks vertraut sein oder manuell komplexe Debugging, Konfiguration und Modifikation durchführen. Es ist für Anfänger des Programmbetriebens und des quantitativen Handels nicht sehr praktisch. Viel Zeit sollte für Handelsstrategien gewidmet werden, und Handelsideen wurden in Programmbetrieb und Programmiersprachenaufklärung investiert.

In der frühen Architekturgestaltung wurde das FMZ Quant (FMZ.COMDer Handel mit Optionen ist grundsätzlich dem Futures-Handel ähnlich oder sogar einfacher. Darüber hinaus gibt es keine neue Schnittstelle. Benutzer, die mit der FMZ-Plattform vertraut sind, erhöhen keine anderen Lernkosten. Sie können den Optionsvertrag nur als Futures-Kontrakt festlegen, um Marktinformationen zu erhalten, Aufträge zu erteilen, Aufträge zu stornieren, Abfragen zu machen und so weiter.

2. Zugriff auf Deribit Exchange direkt mit native Programmiersprache

Nehmen wir zum Beispiel den Optionsvertrag der Deribit Exchange. Zum Beispiel müssen wir den Indexpreis eines aktuellen Optionsvertrags erhalten.

Implementiert in der Go-Sprache:

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. Verwenden der von der FMZ Quant Trading Plattform eingekapselten Schnittstelle

Wir haben es mit der FMZ-Plattform in zwei einfachen Sätzen beendet.

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
}

Wie wir sehen können, ist es sehr einfach, die benötigten Daten in nur wenigen Codezeilen zu erhalten.

Dies ist nur der Zugriff auf die nicht signierte öffentliche API-Schnittstelle der Börse; der Zugriff auf die signierte private Schnittstelle wäre komplizierter.

Jede Schnittstelle muss viel Signatur, Parameterverarbeitung usw. durchführen.

        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 Anforderungen und Funktionen

Nicht nur das, wenn Sie gleichzeitigen, asynchronen Zugang zum Markt, Bestelloperationen und die Codebibliothek verwenden müssen, um asynchron zu handhaben, müssen Sie komplexere asynchrone Verarbeitungslogik schreiben. Eine Unaufmerksamkeit kann auch zu Logik-Designproblemen wie Sperren führen. Wenn Sie erneut die Diagrammdarstellung verwenden müssen, müssen Sie lernen, wie Sie viele Bibliotheken verwenden. Selbst ein quantitativer Trader mit einer Programmierbasis braucht etwas Zeit zum Lernen. Allerdings ist es viel einfacher, die FMZ Quant-Plattform zu verwenden, da diese Funktionen eingekapselt wurden und die entwickelten Anrufschnittstellen sehr einfach und einfach zu bedienen sind. Sie können sehr wenig Code verwenden, um die Funktionen verschiedener Anforderungen zu implementieren.

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 bereitgestellten Vorlagebibliothek Plot Library kann leicht ein K-Liniendiagramm gezeichnet werden:

Es gibt noch mehr Funktionen zu erforschen und zu entwickeln!

5. Nachschrift

Wenn es direkt in der Go-Sprache (oder Python, etc.) wie oben implementiert wird, können die neuen Schüler direkt entmutigt werden>_< Zum Beispiel Strategien der Optionsoperation Deribit, siehe:https://www.fmz.com/strategy/179475