This article brings two classic strategies for transplantation: Iceberg commission (buy/sell). The strategy is transplanted from the Iceberg commission JavaScript version of the FMZ platform. The strategy address is https://www.fmz.com/square/s:Iceberg/1
Quoting JavaScript version of Iceberg commission trading strategy introduction:
Iceberg commission refers to the fact that when investors conduct large-value transactions, in order to avoid excessive impact on the market, the large order commission is automatically split into multiple commissions, based on the current latest buy 1/sell 1 price and the price set by the trader. The strategy automatically commissions a small order. When the last commission is completely transacted or the latest price deviates significantly from the current commission price, the commission operation is automatically restarted.
Many exchange trading pages come with iceberg commissioning tools, which have rich functions, but if you want to customize some functions or modify some functions according to your own needs, you need a more flexible tool. The FMZ platform is designed to solve this problem correctly. Our strategy square hasn't got too many Python trading strategies. Some traders who want to use Python language to write trading tools and strategies need to refer to examples. Therefore, the classic iceberg commissioning strategy was ported to the Python version.
Iceberg Commission for Python - Buying
import random # Import random number library
def CancelPendingOrders(): # The function of CancelPendingOrders is to cancel all pending orders of the current transaction.
while True: # Loop detection, call GetOrders function to detect the current pending order, if orders is an empty array, that is, len(orders) is equal to 0, indicating that all orders have been cancelled, you can exit the function and call return to exit.
orders = _C(exchange.GetOrders)
if len(orders) == 0 :
return
for j in range(len(orders)): # Traverse the current array of pending orders, and call CancelOrder to cancel the orders one by one.
exchange.CancelOrder(orders[j]["Id"])
if j < len(orders) - 1: # Except for the last order, execute Sleep every time and let the program wait for a while to avoid canceling orders too frequently.
Sleep(Interval)
LastBuyPrice = 0 # Set a global variable to record the the latest buying price.
InitAccount = None # Set a global variable to record the initial account asset information.
def dispatch(): # Main functions of iceberg commission logic
global InitAccount, LastBuyPrice # Reference global variables
account = None # Declare a variable to record the account information obtained in real time for comparison calculation.
ticker = _C(exchange.GetTicker) # Declare a variable to record the latest market quotes.
LogStatus(_D(), "ticker:", ticker) # Output time and latest quotation in the status bar
if LastBuyPrice > 0: # When LastBuyPrice is greater than 0, that is, when the commission has started, the code in the if condition is executed.
if len(_C(exchange.GetOrders)) > 0: # Call the exchange.GetOrders function to get all current pending orders, determine that there are pending orders, and execute the code in the if condition.
if ticker["Last"] > LastBuyPrice and ((ticker["Last"] - LastBuyPrice) / LastBuyPrice) > (2 * (EntrustDepth / 100)): # Detect the degree of deviation, if the condition is triggered, execute the code in the if, and cancel the order.
Log("Too much deviation, the latest transaction price:", ticker["Last"], "Commission price", LastBuyPrice)
CancelPendingOrders()
else :
return True
else : # If there is no pending order, it proves that the order is completely filled.
account = _C(exchange.GetAccount) # Get current account asset information.
Log("The buying order is completed, the cumulative cost:", _N(InitAccount["Balance"] - account["Balance"]), "Average buying price:", _N((InitAccount["Balance"] - account["Balance"]) / (account["Stocks"] - InitAccount["Stocks"]))) # Print transaction information.
LastBuyPrice = 0 # Reset LastBuyPrice to 0
BuyPrice = _N(ticker["Buy"] * (1 - EntrustDepth / 100)) # Calculate the price of pending orders based on current market conditions and parameters.
if BuyPrice > MaxBuyPrice: # Determine whether the maximum price set by the parameter is exceeded
return True
if not account: # If account is null, execute the code in the if statement to retrieve the current asset information and copy it to account
account = _C(exchange.GetAccount)
if (InitAccount["Balance"] - account["Balance"]) >= TotalBuyNet: # Determine whether the total amount of money spent on buying exceeds the parameter setting.
return False
RandomAvgBuyOnce = (AvgBuyOnce * ((100.0 - FloatPoint) / 100.0)) + (((FloatPoint * 2) / 100.0) * AvgBuyOnce * random.random()) # random number 0~1
UsedMoney = min(account["Balance"], RandomAvgBuyOnce, TotalBuyNet - (InitAccount["Balance"] - account["Balance"]))
BuyAmount = _N(UsedMoney / BuyPrice) # Calculate the buying quantity
if BuyAmount < MinStock: # Determine whether the buying quantity is less than the minimum buying quantity limit on the parameter.
return False
LastBuyPrice = BuyPrice # Record the price of this order and assign it to LastBuyPrice
exchange.Buy(BuyPrice, BuyAmount, "spend:￥", _N(UsedMoney), "Last transaction price", ticker["Last"]) # Place orders
return True
def main():
global LoopInterval, InitAccount # Refer to LoopInterval, InitAccount global variables
CancelPendingOrders() # Cancel all pending orders when starting to run
InitAccount = _C(exchange.GetAccount) # Account assets at the beginning of the initial record
Log(InitAccount) # Print initial account information
if InitAccount["Balance"] < TotalBuyNet: # If the initial assets are insufficient, an error will be thrown and the program will stop
raise Exception("Insufficient account balance")
LoopInterval = max(LoopInterval, 1) # Set LoopInterval to at least 1
while dispatch(): # The main loop, the iceberg commission logic function dispatch is called continuously, and the loop stops when the dispatch function returns false.
Sleep(LoopInterval * 1000) # Pause each cycle to control the polling frequency.
Log("委托全部完成", _C(exchange.GetAccount)) # When the loop execution jumps out, the current account asset information is printed.
Iceberg Commission for Python - Selling
The strategy logic is the same as that of buying, with only a slight difference.
import random
def CancelPendingOrders():
while True:
orders = _C(exchange.GetOrders)
if len(orders) == 0:
return
for j in range(len(orders)):
exchange.CancelOrder(orders[j]["Id"])
if j < len(orders) - 1:
Sleep(Interval)
LastSellPrice = 0
InitAccount = None
def dispatch():
global LastSellPrice, InitAccount
account = None
ticker = _C(exchange.GetTicker)
LogStatus(_D(), "ticker:", ticker)
if LastSellPrice > 0:
if len(_C(exchange.GetOrders)) > 0:
if ticker["Last"] < LastSellPrice and ((LastSellPrice - ticker["Last"]) / ticker["Last"]) > (2 * (EntrustDepth / 100)):
Log("Too much deviation, the latest transaction price:", ticker["Last"], "Commission price", LastSellPrice)
CancelPendingOrders()
else :
return True
else :
account = _C(exchange.GetAccount)
Log("The buy order is completed, and the accumulated selling:", _N(InitAccount["Stocks"] - account["Stocks"]), "Average selling price:", _N((account["Balance"] - InitAccount["Balance"]) / (InitAccount["Stocks"] - account["Stocks"])))
LastSellPrice = 0
SellPrice = _N(ticker["Sell"] * (1 + EntrustDepth / 100))
if SellPrice < MinSellPrice:
return True
if not account:
account = _C(exchange.GetAccount)
if (InitAccount["Stocks"] - account["Stocks"]) >= TotalSellStocks:
return False
RandomAvgSellOnce = (AvgSellOnce * ((100.0 - FloatPoint) / 100.0)) + (((FloatPoint * 2) / 100.0) * AvgSellOnce * random.random())
SellAmount = min(TotalSellStocks - (InitAccount["Stocks"] - account["Stocks"]), RandomAvgSellOnce)
if SellAmount < MinStock:
return False
LastSellPrice = SellPrice
exchange.Sell(SellPrice, SellAmount, "Last transaction price", ticker["Last"])
return True
def main():
global InitAccount, LoopInterval
CancelPendingOrders()
InitAccount = _C(exchange.GetAccount)
Log(InitAccount)
if InitAccount["Stocks"] < TotalSellStocks:
raise Exception("Insufficient account currency")
LoopInterval = max(LoopInterval, 1)
while dispatch():
Sleep(LoopInterval)
Log("All commissioned", _C(exchange.GetAccount))
Strategy operation
Use WexApp to simulate exchange test:
Buying:
Selling:
The strategy logic is not complicated. When the strategy is executed, it will dynamically place and cancel orders based on the strategy parameters and the current market price. When the transaction amount/coin number reaches or approaches the parameter setting number, the strategy stops. The strategy code is very simple and suitable for beginners. Interested readers can modify it and design a strategy that suits their trading style.