La estrategia de la comisión iceberg

La estrategia de la comisión icebergwww.fmz.comLa comisión del iceberg se refiere a la transacción a gran escala del inversor, con el fin de evitar un impacto excesivo en el mercado, la gran comisión única se divide automáticamente una orden grande en varias órdenes pequeñas, de acuerdo con el último precio de compra / venta actual y el precio de fijación del cliente. La estrategia realiza automáticamente la delegación de pedidos pequeños y vuelve a colocar automáticamente las órdenes cuando el pedido anterior se vende por completo o el último precio se desvía significativamente del precio de colocación actual.

Ejemplo: Si el punto flotante de la media única está fijado en 10, entonces:

El número de cada colocación es de 90% ~ 110% del valor promedio de la colocación única, y el precio de colocación es el último precio de compra digamos 1 vez (menos 1 profundidad de delegación), y se realiza una nueva colocación después de que se complete la última colocación. retire automáticamente el pedido y vuelva a colocar cuando el último precio de transacción sea mayor que la profundidad de colocación * 2.

La colocación se detiene cuando el volumen total de la estrategia es igual a su número total de órdenes. Cuando el último precio de transacción del mercado es superior a su precio máximo de compra, la comisión se detiene, y la comisión se reanuda después de que el último precio de transacción sea inferior al precio de compra más alto.

function CancelPendingOrders() {
    while (true) {
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            return;
        }

        for (var j = 0; j < orders.length; j++) {
            exchange.CancelOrder(orders[j].Id);
            if (j < (orders.length-1)) {
                Sleep(Interval);
            }
        }
    }
}

var LastBuyPrice = 0;
var InitAccount = null;

function dispatch() {
    var account = null;
    var ticker = _C(exchange.GetTicker);
    if (LastBuyPrice > 0) {
        if (_C(exchange.GetOrders).length > 0) {
            if (ticker.Last > LastBuyPrice && ((ticker.Last - LastBuyPrice) / LastBuyPrice) > (2*(EntrustDepth/100))) {
                Log('deviate to much, newest last price:', ticker.Last, 'order buy price', LastBuyPrice);
                CancelPendingOrders();
            } else {
                return true;
            }
        } else {
            account = _C(exchange.GetAccount);
            Log("order finised, total cost:", _N(InitAccount.Balance - account.Balance), "avg buy price:", _N((InitAccount.Balance - account.Balance) / (account.Stocks - InitAccount.Stocks)));
        }
        LastBuyPrice = 0;
    }
    
    var BuyPrice = _N(ticker.Buy * (1 - EntrustDepth/100),PricePerision);
    if (BuyPrice > MaxBuyPrice) {
        return true;
    }
    
    if (!account) {
        account = _C(exchange.GetAccount);
    }


    if ((InitAccount.Balance - account.Balance) >= TotalBuyNet) {
        return false;
    }
    
    var RandomAvgBuyOnce = (AvgBuyOnce * ((100 - FloatPoint) / 100)) + (((FloatPoint * 2) / 100) * AvgBuyOnce * Math.random());
    var UsedMoney = Math.min(account.Balance, RandomAvgBuyOnce, TotalBuyNet - (InitAccount.Balance - account.Balance));
    
    var BuyAmount = _N(UsedMoney / BuyPrice, 3);
    if (BuyAmount < MinStock) {
        return false;
    }
    LastBuyPrice = BuyPrice;
    exchange.Buy(BuyPrice, BuyAmount, 'Cost: ', _N(UsedMoney), 'last price', ticker.Last);
    return true;
}

function main() {
    CancelPendingOrders();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    if (InitAccount.Balance < TotalBuyNet) {
        throw "balance not enough";
    }
    LoopInterval = Math.max(LoopInterval, 1);
    while (dispatch()) {
        Sleep(LoopInterval * 1000);
    }
    Log("All Done", _C(exchange.GetAccount));
}