Utilize o plug-in do terminal de negociação para facilitar a negociação manual
Autora:Bem-estar, Criado: 2020-07-30 11:39:54, Atualizado: 2023-10-25 19:56:42
Introdução
FMZ.COM, como uma plataforma de negociação quantitativa, é principalmente para atender aos traders programáticos. Mas também fornece um terminal de negociação básico. Embora a função seja simples, às vezes pode ser útil. Por exemplo, se a bolsa estiver ocupada e não puder ser operada, mas a API ainda funciona. Neste momento, você pode retirar ordens, colocar ordens e visualizá-las através do terminal. A fim de melhorar a experiência do terminal de negociação, agora são adicionados plug-ins. Às vezes, precisamos de uma pequena função para auxiliar a transação, como ordens pendentes de escada, ordens de iceberg, hedging de um clique, posições de fechamento de um clique e outras operações. Não é necessário olhar para o registro de execução do robô. É um pouco complicado criar um novo plugin. Basta clicar no plugin no terminal, As funções correspondentes podem ser realizadas imediatamente, o que pode facilitar muito as transações manuais.
Princípio de ligação
Existem dois modos de operação do plug-in, operação imediata e operação em segundo plano. A execução em segundo plano é equivalente à criação de um robô (cargas normais). O princípio da operação imediata é o mesmo que a ferramenta de depuração: enviar um pedaço de código para o docker da página do terminal de negociação para execução e suporte para retornar gráficos e tabelas (a ferramenta de depuração também está atualmente atualizada para suporte), o mesmo só pode ser executado por 5 minutos, sem taxas, sem restrições.
Ao escrever uma estratégia, você precisa selecionar o tipo de estratégia como um plug-in.mainfunçãoreturndo plug-in será exibido no terminal após a operação terminar, suportando strings, desenho e tabelas.returnO resultado da execução do plug-in.
Como utilizar
- Adicionar estratégia
Pesquise diretamente na caixa de pesquisa como mostrado na figura. Observe que apenas estratégias de tipo de plug-in de negociação podem ser executadas e clique em Adicionar. Os plug-ins públicos podem ser encontrados no Strategy Square:https://www.fmz.com/square/21/1
- Executar o plugin
Clique na estratégia para entrar na interface de configuração de parâmetros. Se não houver parâmetros, ele será executado diretamente. O docker, o par de negociação e o período de linha K selecionados pelo terminal de negociação são os parâmetros correspondentes padrão. Clique na estratégia de execução para iniciar a execução e selecione o modo
- Parar o plugin
Clique na posição do ícone para parar o plug-in. Como todos os plug-ins são executados em um processo de ferramenta de depuração, todos os plug-ins serão interrompidos.
Exemplos de utilizações de plug-ins
Plug-ins podem executar código por um período de tempo e executar algumas operações simples. Em muitos casos, operações manuais que exigem operações repetidas podem ser implementadas com plug-ins para facilitar transações. A seguir serão apresentados exemplos específicos, e o código fonte fornecido pode ser usado como referência para personalizar sua própria estratégia.
Auxiliar a negociação manual de cobertura intertemporal de futuros
A negociação de hedge intertemporal de futuros é uma estratégia muito comum. Como a frequência não é muito alta, muitas pessoas a operarão manualmente. É necessário fazer um contrato longo e um contrato curto, por isso é melhor analisar a tendência de spread. Usar plug-ins no terminal de negociação economizará sua energia.
A primeira introdução consiste em desenhar o plug-in da diferença de preços entre períodos:
var chart = {
__isStock: true,
title : { text : 'Spread analysis chart'},
xAxis: { type: 'datetime'},
yAxis : {
title: {text: 'Spread'},
opposite: false,
},
series : [
{name : "diff", data : []},
]
}
function main() {
exchange.SetContractType('quarter')
var recordsA = exchange.GetRecords(PERIOD_M5) //Cycle can be customized
exchange.SetContractType('this_week')
var recordsB = exchange.GetRecords(PERIOD_M5)
for(var i=0;i<Math.min(recordsA.length,recordsB.length);i++){
var diff = recordsA[recordsA.length-Math.min(recordsA.length,recordsB.length)+i].Close - recordsB[recordsB.length-Math.min(recordsA.length,recordsB.length)+i].Close
chart.series[0].data.push([recordsA[recordsA.length-Math.min(recordsA.length,recordsB.length)+i].Time, diff])
}
return chart
}
Clique uma vez, a diferença de preço entre os períodos recentes é clara de um olhar, o plug-in endereço de cópia do código fonte:https://www.fmz.com/strategy/187755
Com a análise do spread, é encontrado que o spread está convergindo. É uma oportunidade de curto o contrato trimestral e ir longo para a semana atual. Esta é uma oportunidade de usar o plug-in de hedging de um clique, um clique irá ajudá-lo automaticamente a curto o trimestral e longo o semanal, o que é mais rápido do que a operação manual. O princípio de implementação da estratégia é abrir o mesmo número de posições com um preço deslizante. Você pode correr várias vezes mais para alcançar lentamente sua posição desejada para evitar afetar o mercado. Você pode alterar os parâmetros padrão para colocar ordens mais rapidamente. Endereço de cópia da estratégia:https://www.fmz.com/strategy/191348
function main(){
exchange.SetContractType(Reverse ? Contract_B : Contract_A)
var ticker_A = exchange.GetTicker()
if(!ticker_A){return 'Unable to get quotes'}
exchange.SetDirection('buy')
var id_A = exchange.Buy(ticker_A.Sell+Slip, Amount)
exchange.SetContractType(Reverse ? Contract_B : Contract_A)
var ticker_B = exchange.GetTicker()
if(!ticker_B){return 'Unable to get quotes'}
exchange.SetDirection('sell')
var id_B = exchange.Sell(ticker_B.Buy-Slip, Amount)
if(id_A){
exchange.SetContractType(Reverse ? Contract_B : Contract_A)
exchange.CancelOrder(id_A)
}
if(id_B){
exchange.SetContractType(Reverse ? Contract_B : Contract_A)
exchange.CancelOrder(id_B)
}
return 'Position: ' + JSON.stringify(exchange.GetPosition())
}
À espera que a diferença de preço converja e você precisa fechar a posição, você pode executar o plugin de fechamento de um clique para fechar a posição o mais rápido possível.
function main(){
while(ture){
var pos = exchange.GetPosition()
var ticker = exchange.GetTicekr()
if(!ticker){return 'Unable to get ticker'}
if(!pos || pos.length == 0 ){return 'No holding position'}
for(var i=0;i<pos.length;i++){
if(pos[i].Type == PD_LONG){
exchange.SetContractType(pos[i].ContractType)
exchange.SetDirection('closebuy')
exchange.Sell(ticker.Buy, pos[i].Amount - pos[i].FrozenAmount)
}
if(pos[i].Type == PD_SHORT){
exchange.SetContractType(pos[i].ContractType)
exchange.SetDirection('closesell')
exchange.Buy(ticker.Sell, pos[i].Amount - pos[i].FrozenAmount)
}
}
var orders = exchange.Getorders()
Sleep(500)
for(var j=0;j<orders.length;j++){
if(orders[i].Status == ORDER_STATE_PENDING){
exchange.CancelOrder(orders[i].Id)
}
}
}
}
Plug-in para auxiliar a negociação à vista
O mais comum é a comissão de iceberg, que divide grandes pedidos em pequenos pedidos. Embora possa ser executado como um robô, um plug-in de 5 minutos é realmente suficiente. Existem dois tipos de pedidos de iceberg, um está recebendo pedidos e o outro está pendente.
O seguinte código é o código fonte do plug-in encomendado pelo iceberg:https://www.fmz.com/strategy/191771Para venda:https://www.fmz.com/strategy/191772
function main(){
var initAccount = _C(exchange.GetAccount)
while(true){
var account = _C(exchange.GetAccount)
var dealAmount = account.Stocks - initAccount.Stocks
var ticker = _C(exchange.GetTicker)
if(BUYAMOUNT - dealAmount >= BUYSIZE){
var id = exchange.Buy(ticker.Sell, BUYSIZE)
Sleep(INTERVAL*1000)
if(id){
exchange.CancelOrder(id) // May cause error log when the order is completed, which is all right.
}else{
throw 'buy error'
}
}else{
account = _C(exchange.GetAccount)
var avgCost = (initAccount.Balance - account.Balance)/(account.Stocks - initAccount.Stocks)
return 'Iceberg order to buy is done, avg cost is '+avgCost
}
}
}
É também uma maneira de lentamente
Compra:https://www.fmz.com/strategy/191582
Venda:https://www.fmz.com/strategy/191730
function GetPrecision(){
var precision = {price:0, amount:0}
var depth = exchange.GetDepth()
for(var i=0;i<exchange.GetDepth().Asks.length;i++){
var amountPrecision = exchange.GetDepth().Asks[i].Amount.toString().indexOf('.') > -1 ? exchange.GetDepth().Asks[i].Amount.toString().split('.')[1].length : 0
precision.amount = Math.max(precision.amount,amountPrecision)
var pricePrecision = exchange.GetDepth().Asks[i].Price.toString().indexOf('.') > -1 ? exchange.GetDepth().Asks[i].Price.toString().split('.')[1].length : 0
precision.price = Math.max(precision.price,pricePrecision)
}
return precision
}
function main(){
var initAccount = exchange.GetAccount()
if(!initAccount){return 'Unable to get account information'}
var precision = GetPrecision()
var buyPrice = 0
var lastId = 0
var done = false
while(true){
var account = _C(exchange.GetAccount)
var dealAmount = account.Stocks - initAccount.Stocks
var ticker = _C(exchange.GetTicker)
if(BuyAmount - dealAmount > 1/Math.pow(10,precision.amount) && ticker.Buy > buyPrice){
if(lastId){exchange.CancelOrder(lastId)}
var id = exchange.Buy(ticker.Buy, _N(BuyAmount - dealAmount,precision.amount))
if(id){
lastId = id
}else{
done = true
}
}
if(BuyAmount - dealAmount <= 1/Math.pow(10,precision.amount)){done = true}
if(done){
var avgCost = (initAccount.Balance - account.Balance)/dealAmount
return 'order is done, avg cost is ' + avgCost // including fee cost
}
Sleep(Intervel*1000)
}
}
Às vezes, para vender um melhor
function main() {
var ticker = exchange.GetTicker()
if(!ticker){
return 'Unable to get price'
}
for(var i=0;i<N;i++){
if(Type == 0){
if(exchange.GetName().startsWith('Futures')){
exchange.SetDirection('buy')
}
exchange.Buy(Start_Price-i*Spread,Amount+i*Amount_Step)
}else if(Type == 1){
if(exchange.GetName().startsWith('Futures')){
exchange.SetDirection('sell')
}
exchange.Sell(Start_Price+i*Spread,Amount+i*Amount_Step)
}else if(Type == 2){
exchange.SetDirection('closesell')
exchange.Buy(Start_Price-i*Spread,Amount+i*Amount_Step)
}
else if(Type == 3){
exchange.SetDirection('closebuy')
exchange.Sell(Start_Price+i*Spread,Amount+i*Amount_Step)
}
Sleep(500)
}
return 'order complete'
}
Plug-in para auxiliar a negociação de futuros de mercadorias
O software de negociação de futuros comumente usado tem muitas funções avançadas de ordem pendente, como ordens pendentes de stop-loss, ordens de condição pendentes, etc., que podem ser facilmente escritas como plug-ins.https://www.fmz.com/strategy/187736
var buy = false
var trade_amount = 0
function main(){
while(true){
if(exchange.IO("status")){
exchange.SetContractType(Contract)
if(!buy){
buy = true
if(Direction == 0){
exchange.SetDirection('buy')
exchange.Buy(Open_Price, Amount)
}else{
exchange.SetDirection('sell')
exchange.Sell(Open_Price, Amount)
}
}
var pos = exchange.GetPosition()
if(pos && pos.length > 0){
for(var i=0;i<pos.length;i++){
if(pos[i].ContractType == Contract && pos[i].Type == Direction && pos[i].Amount-pos[i].FrozenAmount>0){
var cover_amount = math.min(Amount-trade_amount, pos[i].Amount-pos[i].FrozenAmount)
if(cover_amount >= 1){
trade_amount += cover_amount
if(Direction == 0){
exchange.SetDirection('closebuy_today')
exchange.Sell(Close_Price, cover_amount)
}else{
exchange.SetDirection('closesell_today')
exchange.Buy(Close_Price, cover_amount)
}
}
}
}
}
} else {
LogStatus(_D(), "CTP is not connected!")
Sleep(10000)
}
if(trade_amount >= Amount){
Log('mission completed')
return
}
Sleep(1000)
}
}
Resumindo
Depois de ler tantas pequenas funções, você também deve ter suas próprias ideias.
- Introdução à arbitragem de lead-lag em criptomoedas (2)
- Introdução ao suporte de Lead-Lag na moeda digital (2)
- Discussão sobre a recepção de sinais externos da plataforma FMZ: uma solução completa para receber sinais com serviço HTTP em estratégia
- Discussão da recepção de sinais externos da plataforma FMZ: estratégias para o sistema completo de recepção de sinais do serviço HTTP embutido
- Introdução à arbitragem de lead-lag em criptomoedas (1)
- Introdução ao suporte de Lead-Lag na moeda digital
- Discussão sobre a recepção de sinais externos da plataforma FMZ: API estendida VS estratégia Serviço HTTP integrado
- Exploração da recepção de sinais externos da plataforma FMZ: API de extensão vs estratégia de serviços HTTP embutidos
- Discussão sobre o método de teste de estratégia baseado no gerador de tickers aleatórios
- Métodos de teste de estratégias baseados em geradores de mercado aleatórios
- Novo recurso do FMZ Quant: Use a função _Serve para criar serviços HTTP facilmente
- Estudo preliminar sobre o backtesting da estratégia de opções de moeda digital
- A diferença entre a negociação quantitativa e a negociação subjetiva
- Estratégia do canal ATR Implementada no mercado de criptomoedas
- Thermostat Strategy usando no mercado de criptomoedas por MyLanguage
- Hans123 estratégia de avanço intradiário
- Estratégia de opções de moeda digital retrospectiva
- Alarme TradingViewWebHook ligado diretamente ao robô FMZ
- Adicionar um despertador à estratégia de negociação
- Estratégia de cobertura de contratos futuros da OKEX utilizando C++
- Estratégia de negociação baseada no fluxo activo de fundos
- Estratégia de negociação de taxas de digitação quantitativa
- Estratégia de equilíbrio e estratégia de rede
- Solução de partilha de cotações de mercado com vários robôs
- Esquema de implementação de mensagens push do robot WeChat
- Estratégias de equilíbrio e estratégias de grelha
- Estratégia de negociação gráfica de Martingale
- Python versão estratégia da comissão iceberg
- A lógica da negociação de futuros de criptomoedas
- Forma inferior da estratégia ZDZB
- Soluções de partilha de mercado multi-robô