Der Eisberg ist ein Auftrag (Käufe) - Jason

Schriftsteller:Jason_MJ, Datum: 2021-04-12 10:00:35
Tags:PythonDer Eisberg

1. Voraussetzung:Das erste Mal, dass ich gelernt habe, Strategie zu schreiben, wurde von Ice Mountain beauftragt: Der Artikel bezieht sich vor allem auf die Strategie von Dawei:https://www.fmz.com/strategy/188435Grundsätzlich ist die Strategie nicht anders als bei den großen Schulen, die Schrift ist etwas grober.

2.前因Bei einem Großhandel mit digitalen Währungen kann der Marktpreis der Währung, die man kaufen/verkaufen möchte, beeinflusst werden, da der Transaktionsbetrag größer ist.ZiehenSie können auch mit einem großen Verkaufsbetrag bezahlen.Die PlatteDas ist nicht wahr. Einer von ihnen: Sie ziehen die Preise nach oben, sie bringen die Währung nach oben. 2 Platten: Sie verkaufen die Münze unabhängig vom Preis, wodurch sie sinken. 3 Handelswährungen: Aktien: Währungen, die für den Handel verwendet werden, zum Beispiel BTC/USDT-Paare.BTC ist eine Handelswährung.4 Bewertungswährung Balance: Die von Benutzern bewertete Währung, beispielsweise das BTC/USDT-Trading-Paar.USDT ist eine Preissteuer

Der Eisberg beauftragte:Operationen: Das ist die automatische Aufteilung von Großaufträgen inMehrere AufträgeDie automatische Auftragsvergabe erfolgt anhand der aktuellsten Kauf-/Verkaufspreise und der vom Kunden festgelegten Preispolitik.Automatische Neuaufgabe, wenn der letzte Auftrag vollständig verkauft wurde oder der letzte Preis deutlich von dem aktuellen abweichtEffekt: Verringerung der Auswirkungen von Großkauf-/Verkaufsaufträgen auf den MarktpreisVerhindern Sie, dass Ihre Einkäufe durch hohe Preise erhöht werdenWenn sie in großen Mengen verkauft werden, können sie es.Verhindern Sie, dass Sie Ihre Verkaufserträge durch hohe Verkaufszahlen und niedrige Preise verringern

Die Datenparameter:

  1. Auftragspreis = der letzte Kaufpreis 1 X ((1- Auftragstiefe)
  2. Tatsächliche Markt Auftragstiefe = (Abschlusspreis - Letzter Auftragspreis) / Letzter Auftragspreis
  3. Anzahl der randomisierten Einzelkäufe = Anzahl der randomisierten Einzelkäufe durchschnittlich X ((100 - Anzahl der randomisierten Einzelkäufe durchschnittlich) % + (Anzahl der randomisierten Einzelkäufe durchschnittlich X2) % X Anzahl der randomisierten Einzelkäufe durchschnittlich X randomisierte Anzahl 0 bis 1
  4. Verfügbarer Betrag = Abrechnungswährung, Zufallsaufnahme, Mindestzahl der übrigen Gesamtsummen
  5. Anzahl der Einkäufe = verfügbare Summe / Auftragspreis
  6. Gesamtbetrag der Überschüsse = Gesamtbetrag der Überschüsse - ((Anfängliche Rechnungskurve - Rechnungskurve)

Die Regeln:

  1. Automatische Rücknahme, wenn der letzte Transaktionspreis vom Auftrag entfernt ist und die Auftragstiefe X2 überschreitet (bedeutet, dass die Abweichung zu groß ist)
  2. Die Strategie stoppt den Auftrag, wenn die Gesamttransaktionen gleich der Gesamtzahl der Auftragszahlen sind
  3. Neue Transaktionspreise höher als Höchstgrenze Kaufpreise stoppen Auftrag
  4. Auftrag zur Wiederaufnahme des Kaufpreises unter dem Höchstgrenzwert der letzten Transaktionspreise

Die wichtigsten Parameter:

  1. Kaufbetrag
  2. Anzahl der Einkäufe
  3. Die Tiefe des Auftrags
  4. Der höchste Preis
  5. Preisintervalle
  6. Anzahl der Einzellagerungen
  7. Minimaler Umsatz

Ich dachte:

  1. Erhalten Sie alle ausstehenden Bestellungen und stornieren Sie sie
  2. Erhalten Sie den Initialausgleich, um zu entscheiden, ob der Gesamtbetrag größer ist als der Kauf
  3. Berechnung des Auftragspreises
  4. Berechnen Sie die Anzahl der Einzelkäufe
  5. Berechnung der verfügbaren Summe
  6. Berechnung der Anzahl der Einkäufe
  7. Kauf durchführen
  8. Festgelegte Pausen
  9. Beurteilen Sie, ob Ihre letzte Bestellung erfolgreich war
  10. Erfolgreich ausgeführt
  11. Versäumnis zu entscheiden, ob die Abweichungen zu groß sind und ob sie widerrufen werden müssen

Empfehlungen

  1. Es wird empfohlen, ETH_USDT zu verwenden

Die Strategie ist nicht perfekt, die Türsteine zeigen auf zwei Punkte, wenn sie vorbeikommen wollen


import random


def main():
    # 获取账户所有未成交订单
    Log("取消所有未成交订单")
    orders = _C(exchange.GetOrders)
    if len(orders) > 0:
        for i in range(len(orders)):
            exchange.CancelOrder(orders[i]["Id"])
            Sleep(priceInterval*1000)

    # 对比账户余额
    Log("获取用户初始化账户")
    initAccount = _C(exchange.GetAccount)
    if initAccount["Balance"] < buyAmount:
        Log("账户余额不足")
        return
    
    #比较单笔购买数量均值*市场买一价是否大于账户余额
    ticker = _C(exchange.GetTicker)
    if (ticker['Last'] * buyNum) > initAccount['Balance']:
        Log("单次购买均值价格大于账户余额,请调整参数")
        return

    lastBuyPrice = 0

    while (True):
        Sleep(priceInterval*1000)
        #获取账户信息
        account = _C(exchange.GetAccount)
        #获取当下行情
        ticker = _C(exchange.GetTicker)
        # 上次购买价格不为空,查看订单是否完成,没有完成则取消
        if lastBuyPrice > 0:
            orders1 = exchange.GetOrders()
            if len(orders1) > 0:
                for j in range(len(orders1)):
                    #计算实际市场委托深度
                    if ticker["Last"] > lastBuyPrice and ((ticker["Last"] - lastBuyPrice)/lastBuyPrice) > (2* (depthStatus/100)):
                        Log("委托价格偏离过多,最新成交价:",ticker["Last"],"委托价",lastBuyPrice)
                        exchange.CancelOrder(orders1[j]["Id"])
                        lastBuyPrice = 0
                continue
            else:
                Log("买单完成, 累计花费:", _N(initAccount["Balance"] - account["Balance"]), "平均买入价:", _N((initAccount["Balance"] - account["Balance"]) / (account["Stocks"] - initAccount["Stocks"])))
                lastBuyPrice = 0
                continue     
        else:
            Log("剩余余额:",account["Balance"])
            #委托价格 = 最新买一价*(1-委托深度/100)
            entrustPrice = _N(ticker["Buy"]*(1-depthStatus/100))
            Log("委托价格:",entrustPrice)
            #判断委托价格是否大于最高价格限定
            if entrustPrice > highPrice:
                continue
            #随机购买数量 = 单次购买数量均值 * ((100-单次均值浮点数)/100)+(单次均值浮点数*2 /100* 单次购买数量均值 *随机数0~1)  
            randomBuyNum = (buyNum*((100-buyOncePoint)/100))+(buyOncePoint*2/100 *buyNum*random.random())
            #可用数量金额 
            useMoney = min(account["Balance"],randomBuyNum,buyAmount - (initAccount["Balance"] - account["Balance"]))
            #购买数量
            orderBuyNum = _N(useMoney/entrustPrice)
            Log("交易数量:",orderBuyNum)
            #判断是否小于最小交易量
            if orderBuyNum < minBuyNum:
                break
            #因为要扣手续费,所以大概为账户99.7%
            if (entrustPrice*orderBuyNum)>(account["Balance"]*0.997):
                Log("金额为",(entrustPrice*orderBuyNum))
                Log("账户余额为",(account["Balance"]))
                continue
            #更新上次购买价格
            lastBuyPrice = entrustPrice
            #下单
            exchange.Buy(entrustPrice,orderBuyNum)
            
    account = _C(exchange.GetAccount)  
    Log("冰山委托买单完成,共计花费:",_N(initAccount["Balance"]-account["Balance"]),"平均单价为:",_N((initAccount["Balance"]-account["Balance"])/(account["Stocks"]-initAccount["Stocks"])))        


Verwandt

Mehr