Observação de Oportunidade

Recentemente, descobri acidentalmente que o mercado de STORJ, uma moeda na Binance, é muito estranho. O volume de negociação é muito grande e a frequência de negociação é muito rápida. A linha K específica de um minuto é a seguinte. Você pode ver que o volume de negociação por minuto é bastante consistente, e uma longa sombra inferior pode ser vista na linha do minuto.

Ao observar a linha K de 1 segundo da Binance, encontramos uma pista. Alguém venderia de 10.000 a 20.000 STORJ a cada 5-7 segundos, independentemente do custo, e atingiria diretamente um pequeno buraco na linha K. Ela se recuperará por dentro. Esta operação foi obviamente causada por um robô encomendado pelo Iceberg. Esta operação de venda durou muito tempo, e o valor total foi estimado em dezenas de milhões de dólares. Em muitos casos, o slippage causado atingiu 1/1000, o que significa que o executor desta estratégia perdeu dezenas de milhares de dólares apenas devido ao deslizamento da transação. Dólar. No entanto, tais operações mecânicas e transações ativas criam oportunidades óbvias para criação de mercado e scalping.

Simplesmente modificando a estratégia original de alta frequência, levou apenas alguns minutos para construir este robô que explora especificamente a venda irracional de ordens iceberg.

Pensamento estratégico

Como haverá vendas no mercado a cada poucos segundos, precisamos apenas encontrar uma profundidade de 10.000 no livro de ordens de compra e colocar a ordem na frente. Dessa forma, quando esse iceberg for vendido, há uma grande probabilidade de que o robô market-making consiga recebê-lo. Nesse momento, a negociação é muito ativa, e a queda instantânea do preço também aciona algumas ordens de compra. o mesmo princípio se aplica à colocação de ordens de venda e à venda delas de acordo. Repita a operação. A frequência das transações é muito alta e, mesmo que a taxa de retorno não seja grande, o lucro total ainda é considerável. Claro, a premissa de tudo é ter uma conta com baixas taxas de transação. Se as taxas de transação para compra e venda forem de 0,1%, então esse espaço não é suficiente para pagar as taxas de transação.

Desempenho estratégico

O desempenho da estratégia é o seguinte. No começo, os lucros não eram impressos. Eu mudei esta tarde e imprimi os lucros. O robô de vendas maluco mudou a quantidade para cerca de 5.000 a cada vez, então o melhor período de arbitragem passou. No começo, você pode ganhar cerca de 100-200U por hora. O importante é que seja livre de riscos e de baixo custo. Olhando do outro lado, na verdade, existem muitas técnicas para ordens iceberg. Se você sabe como escrever uma estratégia, pode escrever uma na FMZ em apenas uma dúzia de minutos. Observe a profundidade das ordens de compra para determinar o tamanho da ordem e preço, e observe o tamanho das ordens de compra ativas para ajustar o tamanho da ordem pendente. E a estratégia de confiança do iceberg com características como ocupar o mercado pode facilmente economizar dezenas de milhares de dólares.

Código fonte da estratégia

O código da estratégia é muito simples, apenas 80 linhas. Adequado para iniciantes. Alguns parâmetros, como precisão simples, são codificados no programa. Você pode modificá-los você mesmo. Os parâmetros necessários são mostrados na figura abaixo. É recomendável salvá-los para uso futuro, caso o par de negociação de câmbio tem outra transação maluca. Você pode cobrar juros deles a qualquer momento.

            
            
            
function CancelPendingOrders() {
    var orders = _C(exchange.GetOrders)
    for (var j = 0; j < orders.length; j++) {
        exchange.CancelOrder(orders[j].Id, orders[j])
    }
}

function onexit(){
    CancelPendingOrders()
}

function GetPrice(Type, Depth) {
    var sumAmount = 0
    var checkAmount = Type == "Buy" ? CheckBuyAmount : CheckSellAmount
    var deep = Type == "Buy" ? Depth.Bids : Depth.Asks
    for(var i = 0; i < Math.min(20, deep.length); i++) {
        if(Type == "Buy"  && deep[i].Price == lastBuyPrice && buyId){
            sumAmount += deep[i].Amount - amountBuy //这里要减去自己的挂单
        }else if(Type == "Sell"  && deep[i].Price == lastSellPrice && sellId){
            sumAmount += deep[i].Amount - amountSell
        }else{
            sumAmount += deep[i].Amount
        }
        if(sumAmount >= checkAmount){
            return deep[i].Price
        }
    }
    return deep[19].Price
}

function OnTick() {
    var depth = _C(exchange.GetDepth)
    var buyPrice = _N(Math.min(GetPrice("Buy", depth) + 0.0001, depth.Asks[0].Price-0.0001) , 4) //保证在盘口
    var sellPrice = _N(Math.max(GetPrice("Sell", depth) - 0.0001, depth.Bids[0].Price+0.0001), 4)
    LogStatus('buy_price:'+buyPrice, '  sell price: '+sellPrice)
    if ((sellPrice - buyPrice) < DiffPrice) {
        buyPrice = 0
    }
    if(sellPrice != lastSellPrice && sellId){
        exchange.CancelOrder(sellId);
        sellId = 0
        lastSellPrice = 0
    }
    if(buyPrice != lastBuyPrice && buyId){
        exchange.CancelOrder(buyId);
        buyId = 0
        lastBuyPrice = 0
    }   
    var acc = _C(exchange.GetAccount)
    if(account.Stocks+account.FrozenStocks != acc.Stocks+acc.FrozenStocks){
        LogProfit((acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance - 2000)
        Log('free '+acc.Stocks, ' lock: '+ acc.FrozenStocks, ' total: ' , (acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance)
    }
    account = acc
    amountBuy = _N(Math.min(account.Balance / buyPrice - 0.1, Amount), 0)
    amountSell = _N(account.Stocks, 0)
    if (sellPrice > 0 && amountSell > 40 && sellId == 0) {
        sellId = exchange.Sell(_N(sellPrice,4), amountSell)
        lastSellPrice = sellPrice
    }
    if (buyPrice>0 && amountBuy > 40 && buyId == 0) {
        buyId = exchange.Buy(_N(buyPrice,4), amountBuy)
        lastBuyPrice = buyPrice
    }
    Sleep(Interval)
}
var account = {Stocks:0, FrozenStocks:0, Balance:0, FrozenBalance:0}
var buyId = 0
var sellId = 0
var lastBuyPrice = 0
var lastSellPrice = 0
var amountSell = 0
var amountBuy = 0
function main() {
    CancelPendingOrders()
    while (true) {
        OnTick()
    }
}