Outro instrumento de negociação quantitativo disponível para opções de moeda digital

Outro instrumento de negociação quantitativo disponível para opções de moeda digital

1. Negociação quantitativa e programática de opções de moeda digital

Recentemente, muitas bolsas abriram sucessivamente a função de negociação de opções de moeda digital como um derivado. Semelhante às opções tradicionais, a negociação de opções e a negociação de futuros podem ser combinadas para formar muitas estratégias e métodos de negociação. Embora existam muitas ferramentas de negociação quantitativa de código aberto no mercado, essas ferramentas geralmente precisam entender a estrutura subjacente, estar familiarizadas com a linguagem de programação para escrever a estrutura ou executar manualmente depurações, configurações e modificações complexas. Não é muito conveniente para iniciantes de negociação de programas e negociação quantitativa.

No início do projeto de arquitetura, o FMZ Quant (FMZ.COMO mercado de opções de ações é um mercado de ações de ações de ações de ações de ações de ações de ações de ações de ações.

2. Acesse o Deribit Exchange diretamente usando a linguagem de programação nativa

Tomemos o contrato de opção da Deribit Exchange como exemplo.

Implementado na linguagem 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. Usando a interface encapsulada pela plataforma FMZ Quant Trading

Terminámos usando a plataforma FMZ em duas frases 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
}

Como podemos ver, é muito simples obter os dados necessários em apenas algumas linhas de código.

Isso é apenas acessar a interface API pública não assinada da troca; acessar a interface privada assinada seria mais complicado.

Cada interface tem que fazer muita assinatura, processamento de parâmetros, 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. Requisitos e funções mais complexos

Não só isso, se você precisa usar acesso simultâneo e assíncrono ao mercado, operações de ordens e biblioteca de código para lidar assíncrona, você precisa escrever lógica de processamento assíncrona mais complexa. Uma falta de atenção também pode causar problemas de design de lógica, como bloqueio. Se você precisar usar a exibição de gráficos novamente, então você precisa aprender a usar muitas bibliotecas. Mesmo um comerciante quantitativo com uma base de programação precisa de algum tempo para aprender. No entanto, é muito mais fácil usar a plataforma FMZ Quant, porque essas funções foram encapsuladas e as interfaces de chamada projetadas são muito simples e fáceis de usar. Você pode usar muito pouco código para implementar as funções de vários requisitos.

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

Usando a biblioteca de modelos Plot Library fornecida pela plataforma, é fácil desenhar um gráfico de linhas K:

Há mais funções para explorar e desenvolver!

5. Pós-escritura

Se for implementado diretamente na linguagem go (ou Python, etc.) como o acima, os novos alunos podem ser desencorajados diretamente>_< Por exemplo, as estratégias de operação de opções Deribit, ver:https://www.fmz.com/strategy/179475