nd loss", floatProfit, “Highest profit point:”, profitMax, “Start stop loss”); // Output information
balanceAccount(orgAccount, InitAccount); // Balanced account
if (StopLossMode == 0) { // According to the stop loss mode processing, if StopLossMode is equal to 0, the program is exited after the stop loss.
throw “Stop loss exit”; // Throw the error “Stop Loss Exit” strategy to stop.
} else {
return true; // Except for the stop loss exit mode, ie: re-cast the grid after the stop loss.
}
}
}
if (EnableAccountCheck && EnableStopWin) { // If the detection account is turned on and the take profit is turned on
if (floatProfit > StopWin) { // If the floating profit and loss is greater than the take profit
Log(“Current floating profit and loss”, floatProfit, “Start taking profit”); // Output log
balanceAccount(orgAccount, InitAccount); // Balanced account recovery initial (take profit)
if (StopWinMode == 0) { // According to the take profit mode.
throw “Take profit exit”; // Exit after taking profit
} else {
return true; // Return true after take profit, continue to cast the grid
}
}
}
var distance = 0; // Declare a variable to record the distance
if (EnableAccountCheck && AutoMove) { // If account detection is turned on and the grid moves automatically
if (BuyFirst) { // If it is buy first and then sell
distance = ticker.Last - FirstPrice; // Assign a value to distance: the current price minus the first price, calculate the distance
} else { // Other situations: sell first and then buy
distance = FirstPrice - ticker.Last; // Assign a value to distance: the first price minus the current price, calculate the distance
}
var refish = false; // Whether to re-cast the tag variable
if (!isHold && isTimeout()) { // If there is no position (isHold is false) and timeout (isTimeout returns true)
Log(“no position holding for too long, start moving the grid”);
refish = true; // Mark re-cast
}
if (distance > MaxDistance) { // If the current distance is greater than the maximum distance set by the interface parameters, the mark is re-cast
Log("The price is too much beyond the grid interval, start moving the grid, the current distance: ", _N(distance, Precision), “current price:”, ticker.Last);
refish = true;
}
if (refish) { // If refish is true, execute the balance function
balanceAccount(orgAccount, InitAccount);
return true; // This cast function returns true
}
}
var holdDirection, holdAmount = "--", // Declare three variables, position direction, number of positions, position price
holdPrice = "--";
if (isHold) { // When holding a position
if (RestoreProfit && ProfitAsOrg) { // If you start to restore the last profit and the last profit is included in the average price
if (BuyFirst) { // If it is buy first and then sell
money_diff += LastProfit; // Add the last profit to money_diff, that is, the last time the income is converted into the money difference
// (in the case of the first buy, the money difference is negative, that is, the cost),
// which is equivalent to the opening cost.
} else { // If it is sell first, then buy
money_diff -= LastProfit; // The difference between buying and selling is positive, why - ?
}
}
// Dealing with buying first and then selling
holdAmount = amount_diff; // The difference in the value of the coins is given to the number of
// positions (the difference in the coins is the position at the moment)
holdPrice = (-money_diff) / amount_diff; // Calculate the average price of the position by dividing the difference between
// the money and the difference in the coins,
// Note: If money_diff is negative, then amount_diff must be positive, so be sure
// to add a minus sign before money_diff so that the calculated price is a positive number.
// Dealing with selling first and then buying
if (!BuyFirst) { // If it is selling first and then buying, it will trigger the update of the open position and
// the average price of the position.
holdAmount = -amount_diff; // The coins difference is negative, so the counter is reversed
holdPrice = (money_diff) / -amount_diff; // Calculate the average price of the position.
}
holdAmount = _N(holdAmount, 4); // Positions, retain 4 decimal places.
holdPrice = _N(holdPrice, Precision); // The average price of the position, retaining the Precision decimal.
holdDirection = BuyFirst ? "long" : "short"; // According to the "first buy then sell" or "first sell then buy" to holdDirection assigned long or short
} else { // If isHold is false, assign "--" to holdDirection
holdDirection = "--";
}
table = { // Assign an object to the declared table variable to display the table information on the FMZ robot status bar
type: 'table', // See the API documentation LogStatus function, here to initialize the type attribute 'table' for
// display in the status bar as a table
title: 'Operating status', // Title of the table
cols: ['Use funds', 'Holding position', 'Position size', 'Average price of position', 'Total floating profit and loss', 'Current grid profit and loss',
'Number of casting grids', 'Grid offset', 'Real placing order', 'Latest coin price'], // The column name of the table
rows: [ // Progressive data for the table
[_N(actualNeedMondy, 4), holdDirection, holdAmount, holdPrice, _N(floatProfitAll, 4) + ' ( ' + _N(floatProfitAll * 100 / actualNeedMondy, 4) + ' % )',
floatProfit, fishCount, (AutoMove && distance > 0) ? ((BuyFirst ? "up" : "down") + "Deviation: " + _N(distance) + " dollar") : "--", trader.RealLen(), ticker.Last]
// One row of data
]
};
} // Process some tasks every 5 seconds and update the robot status bar table object table
var orders = _C(trader.GetOrders); // Get all unexecuted orders
if (table) { // If the table has been assigned a table object
if (!EnableDynamic) { // If the dynamic order is not activated
table.rows[0][8] = orders.length; // Update the length of the pending order array in the first row and the 9th column of the status bar table.
}
LogStatus('`' + JSON.stringify(table) + '`'); // Call the FMZ platform API LogStatus to display the status bar table of the settings
}
for (var idx = 0; idx < canNum; idx++) { // Traverse the number of available grids nodes.
var openPrice = _N((BuyFirst ? FirstPrice - (idx * PriceGrid) : FirstPrice + (idx * PriceGrid)), Precision); // As the node index idx traverses, construct the opening price
// of each node (the direction is buying first, then sold,
// or selling first and then buy)
var coverPrice = _N((BuyFirst ? openPrice + PriceDiff : openPrice - PriceDiff), Precision); // Open and close position spread, that is, the profit margin of each node
var state = fishTable[idx]; // Assignment status of the fishnet node
var fishId = uuidTable[idx]; // Numbering
// The judgment here is: filtering unfinished orders
if (hasOrder(orders, fishId)) { // If all unexecuted orders, there is an order with the ID fishId in the pending order array
continue; // Skip this loop and continue the loop
}
if (fishId != -1 && IsSupportGetOrder) { // The grid node id is not equal to the initial value, that is, the order is placed,
// and the exchange supports GetOrder
var order = trader.GetOrder(fishId); // Get the order for the fishId number
// The judgment here is as follows: Filter the grid node where the order is not found, the following logic (state == STATE_WAIT_COVER), etc. will not trigger
if (!order) { // Failed to get an order if !order is true
Log("Failed to get order information, ID: ", fishId); // Output log
continue; // Skip this loop and continue the loop
}
// The judgment here is as follows: Filtering the grid nodes that are in a suspended state, not completed, or not fully completed,
// the logic of the following judgment (state == STATE_WAIT_COVER) and so on will not be triggered.
if (order.Status == ORDER_STATE_PENDING) { // If the order status is pending on the exchange
//Log("Order status is not completed, ID: ", fishId);
continue; // Skip this loop and continue to loop
}
}
if (state == STATE_WAIT_COVER) { // If the current node status is waiting to be closed
var coverId = CoverFunc(coverPrice, (BuyFirst ? amountS[idx] : amountB[idx]), (BuyFirst ? 'Complete the buying order:' : 'Complete the selling order:'), openPrice, 'volume:',
(BuyFirst ? amountB[idx] : amountS[idx]));
// Call the closing function CoverFunc to send the closing order
if (typeof(coverId) === 'number' || typeof(coverId) === 'string') { // Determine if the value returned by the closing function is a value (returned directly by the FMZ API)
// or a string (returned by the buy/Sell function of the trader object)
fishTable[idx] = STATE_WAIT_CLOSE; // The closing order has been send and the update status is: STATE_WAIT_CLOSE Waiting for the node task to complete
uuidTable[idx] = coverId; // Store the order number in the idx location corresponding to the uuidTable.
}
} else if (state == STATE_WAIT_OPEN || state == STATE_WAIT_CLOSE) { // If the status is waiting for opening or waiting for completion
var openId = OpenFunc(openPrice, BuyFirst ? amountB[idx] : amountS[idx]); // Open the position order.
if (typeof(openId) === 'number' || typeof(openId) === 'string') { // Determine whether the order placing is successful
fishTable[idx] = STATE_WAIT_COVER; // Update status for waiting for closing
uuidTable[idx] = openId; // Record current node order ID
if (state == STATE_WAIT_CLOSE) { // If it is waiting for completion (it will only be triggered after the open position order is placed)
ProfitCount++; // Cumulative gaining profit times
var account = _C(exchange.GetAccount); // Get current account information
var ticker = _C(exchange.GetTicker); // Get current market information
var initNet = _N(((InitAccount.Stocks + InitAccount.FrozenStocks) * ticker.Buy) + InitAccount.Balance + InitAccount.FrozenBalance, 8);
// Calculate the initial net asset value
var nowNet = _N(((account.Stocks + account.FrozenStocks) * ticker.Buy) + account.Balance + account.FrozenBalance, 8);
// Calculate the current net asset value
var actualProfit = _N(((nowNet - initNet)) * 100 / initNet, 8); // Calculated rate of return
if (AmountType == 0) { // According to the same amount of buy and sell, the custom amount is different.
var profit = _N((ProfitCount * amount * PriceDiff) + LastProfit, 8); // Calculation: the sum of the profit and loss of all profit nodes and the
// last time of the net profit and loss which is the total profit and loss
Log((BuyFirst ? 'Complete the sell order:' : 'Complete the buy order:'), coverPrice, 'volume:', (BuyFirst ? amountS[idx] : amountB[idx]), 'Closing position profit', profit);
// Output order completion information
} else {
Log((BuyFirst ? 'Complete the sell order:' : 'Complete the buy order:'), coverPrice, 'volume:', (BuyFirst ? amountS[idx] : amountB[idx]));
}
}
}
}
}
Sleep(CheckInterval); // Grid logic is mainly while loop detection, each time a pause is checked, CheckInterval is: detection interval
}
return true; // This time of the casting grid is completed, return true
}
function main() { // The main function of the strategy, the program starts from here. if (ResetData) { // RestData is the interface parameter, the default is true, and it controls whether all data is cleared at startup. All are cleared by default. LogProfitReset(); // Execute the API LogProfitReset function to clear all revenue. LogReset(); // Execute the API LogReset function to clear all logs. } // exchange.SetMaxDigits(Precision) // Deprecated, use exchange.SetPrecision instead. exchange.SetPrecision(Precision, 3) // exchange.SetPrecision(2, 3); // Set the price decimal place precision to 2 digits, and the variety order size decimal place precision is 3 digits. // Precision Interface parameter。
if (typeof(AmountType) === 'undefined') { // Order quantity type, 0: "Buy and sell the same amount", 1: "Custom amount", detect if the parameter is undefined, the default setting is 0.
AmountType = 0; // Typeof will detect the type of AmountType. If undefined is "undefined", assign a value of 0 to AmountType.
}
if (typeof(AmountDot) === 'undefined') { // The maximum number of digits of the order quantity decimal point AmountDot is undefined, set AmountDot to 3.
AmountDot = 3; // In fact, it has been set by exchange.SetPrecision(Precision, 3), and it will be truncated at the bottom.
}
if (typeof(EnableDynamic) === 'undefined') { // Check if the dynamic pending order parameter is enabled. If EnableDynamic is undefined, set to false will not be enabled.
EnableDynamic = false;
}
if (typeof(AmountCoefficient) === 'undefined') { // If not defined, the default setting is "*1"
AmountCoefficient = "*1";
}
if (typeof(EnableAccountCheck) === 'undefined') {// If not defined, the Enable Money Verification parameter is set to true, which is turned on.
EnableAccountCheck = true;
}
BuyFirst = (OpType == 0); // Assign value to BuyFirst according to the setting of OpType, OpType sets the grid type, 0: buy first and then sell, 1: sell first and then buy
IsSupportGetOrder = exchange.GetName().indexOf('itstamp') == -1; // Check the name of the exchange, whether it is Bitstamp or not
if (!IsSupportGetOrder) {
Log(exchange.GetName(), "Does not support GetOrder, may affect the stability of the strategy.");
}
SetErrorFilter("502:|503:|S_U_001|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|refused|EOF|When");
// SetErrorFilter Filter error messages
exchange.SetRate(1);
Log('Exchange rate conversion has been disabled, the current currency is', exchange.GetBaseCurrency()); // Disable exchange rate conversion
if (!RestoreProfit) { // If the last profit is restored to false, then LastProfit will be assigned a value of 0, that is, it will not be restored.
LastProfit = 0;
}
var orgAccount = _C(exchange.GetAccount); // Get account information, here record the initial account information when the strategy starts running,
// used to calculate some income, such as: overall floating profit and loss.
// There are several parameters in this strategy that are passed to this variable.
var fishCount = 1; // time of casting grids initial is 1
while (true) { // Strategy main loop
if (!fishing(orgAccount, fishCount)) { // casting grid function fishing
break;
}
fishCount++; // Number of casting grids accumulated
Log("the number of", fishCount, "casting girds..."); // Output Casting grids information.
FirstPriceAuto = true; // Reset first price is automatically true
Sleep(1000); // Polling interval 1000 milliseconds
}
}