Ferramenta de negociação quantitativa de opções de moeda digital pronta para uso

1. Negociação quantitativa e programada de opções de moeda digital

Recentemente, muitas bolsas começaram a negociar derivativos de opções de moeda digital. Semelhante às opções tradicionais, a combinação de negociação de opções e negociação de futuros pode criar uma variedade de 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 exigem a compreensão da estrutura subjacente, a familiaridade com a linguagem de programação usada para escrever a estrutura ou a execução manual de depuração, configuração e modificação complexas. Não é muito conveniente para iniciantes em negociação programática e negociação quantitativa. Muito tempo que deveria ser focado em estratégias e ideias de negociação é gasto na depuração de programas e no aprendizado de linguagens de programação.

Ao projetar sua arquitetura inicial, a FMZ.COM levou em consideração o suporte para negociação quantitativa e programada de vários derivativos financeiros e rapidamente se conectou à negociação de opções. A negociação de opções é basicamente semelhante à negociação de futuros, ou até mais simples. E nenhuma nova interface é adicionada. Usuários que estão familiarizados com o uso do FMZ não incorrerão em custos adicionais de aprendizado. Eles só precisam configurar contratos de opção como contratos futuros para obter informações de mercado, fazer pedidos, cancelar pedidos, verificar posições e executar outras operações em contratos de opções.

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

Vamos pegar o contrato de opções de câmbio Deribit como exemplo. Por exemplo, queremos obter o preço do índice de um contrato de opções atual.

Implementado em Go:

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

Você pode ver que muito código foi escrito apenas para obter esses dados.

3. Use a interface encapsulada pela Plataforma de Negociação Quantitativa do Inventor

Usamos o FMZ para fazer isso em apenas duas frases.

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

Como você pode ver, com apenas algumas linhas de código, é muito fácil obter os dados necessários.

Isso é apenas acessar a interface de API pública não assinada da exchange. Acessar a interface privada assinada será mais complicado.

Cada interface também precisa fazer muitos processamentos de assinatura, parâmetros e outros:

        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 complexas

Além disso, se você precisar obter informações de mercado e fazer pedidos de forma simultânea e assíncrona, e usar uma biblioteca de código que lida com operações assíncronas, você precisa escrever uma lógica de processamento assíncrona mais complexa, o que pode causar problemas de design lógico, como deadlocks, se você estiver não tome cuidado. Se você precisar usar a exibição de gráficos novamente, você terá que aprender a usar muitas bibliotecas. Mesmo para um trader quantitativo com conhecimento básico de programação, levará algum tempo para aprender. No entanto, é muito mais simples usar a Quantização do Inventor, 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 várias funções necessárias.

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 “Drawing Line Library” fornecida pela plataforma, é muito fácil desenhar um gráfico K-line:

Há muitos outros recursos para explorar e desenvolver!

5. Posfácio

Se você usar a linguagem Go (ou Python, etc.) como a acima para implementá-la, novos alunos podem ser desencorajados diretamente >_< Para uma estratégia de exemplo sobre opções Deribit, consulte: https://www.fmz.com/strategy/179475