The grid trading strategy (www.fmz.com) The basic idea of grid trading is very straightforward. Instead of placing one trade, we place multiple trades forming a grid pattern. Usually these are entered as “stop” or “limit” orders around the current price level – but not always. I’ll explain this in more detail below, but that’s the basic idea.
What is grid trading and how does it work? Grid trading is a play on market volatility. There are two reasons why it’s favored by traders. The first is that it doesn’t “require” you to have a definitive prediction on the market direction.
The second is that it works well in volatile markets, where there isn’t a clear trend – these conditions are very common in the currency markets
Grid trading is a type of technical analysis trading that is based on movement within specific grid patterns. Grid trading is popular in foreign exchange trading. Overall the technique seeks to capitalize on normal price volatility in markets by placing buy and sell orders at certain regular intervals above and below a predefined base price. Such buy and sell orders, generally spaced at 10 or 15 units of intervals, create a trading grid.
Grid can customize direction
Basic trading operation: buy first and then sell.
The grid will start to send buying order at the price that below the first price, which is the price follow by the first price (second latest buying price, third latest buying price…and so on). Each buying order is separated by the “price interval” parameter. The number of pending orders is “single quantity”, and will send the order total until the “total quantity” is filled.
After any buying order is completed, the program will be on the basis of the buying price, add the price of the “price difference” parameter to the sell price, after the order has been sold, and then re-start the progress of this grid strategy (checking, place order, wait until it executed, sell)
Selling short first and then buy to cover: the operation is just the opposite
The biggest risk of this strategy is when the market trend is unilateral moving, and the price fluctuations are exceeding the grid.
The following code has made the grid with automatic stop loss and movement function.
Comments:
The strategy uses a virtual pending order design, which provides a great deal of processing for the exchange to limit the number of pending orders, and solves the problem flexibly.
The grid logic is flexible in design and clever in structure.
Profit and loss calculation, each numerical statistical algorithm can be used for reference, and each condition detection design is rigorous. (for minimize the possibility of BUG)
The source code is very worth learning.
For more information，please see：
https://www.fmz.com/strategy/112633
Source Code:
”` // Grid can customize direction // Basic trading operation: buy first and then sell. // The grid will start to send buying order at the price that below the first price, which is the price follow // by the first price (second latest buying price, third latest buying price…and so on). Each buying order is separated by // the “price interval” parameter. The number of pending orders is “single quantity”, and will send the order total until // the “total quantity” is filled. // After any buying order is completed, the program will be on the basis of the buying price, add the price of the “price // difference” parameter to the sell price, after the order has been sold, and then re-start the progress of this // grid strategy (checking, place order, wait until it executed, sell) // Selling short first and then buy to cover: the operation is just the opposite // The biggest risk of this strategy is when the market trend is unilateral moving, and the price fluctuations are exceeding the grid. // The following code has made the grid with automatic stop loss and movement function. // Comments: // The strategy uses a virtual pending order design, which provides a great deal of processing for the exchange to limit the number // of pending orders, and solves the problem flexibly. // The grid logic is flexible in design and clever in structure. // Profit and loss calculation, each numerical statistical algorithm can be used for reference, and each condition detection design // is rigorous. (for minimize the possibility of BUG) // The source code is very worth learning.
// Source Code: /* Interface parameters (shown as global variables in the code) OpType Grid Direction Drop-down box (selected) Buy first then sell | Sell first then buy FirstPriceAuto initial price automatic boolean (true/false) true FirstPrice@!FirstPriceAuto initial price numerical (number) 100 AllNum total number numerical (number) 10 PriceGrid Price Interval numerical (number) 1 PriceDiff spread numerical (number) 2 AmountType order size drop-down box (selected) buy and sell the same amount | custom amount AmountOnce@AmountType==0 Single transaction quantity numerical (number) 0.1 BAmountOnce@AmountType==1 Buying Order Size numerical (number) 0.1 SAmountOnce@AmountType==1 Selling order size numerical (number) 0.1 AmountCoefficient@AmountType==0 Quantity difference String (string) *1 AmountDot The decimal point numerical (number) 3 EnableProtectDiff Turn on spread protection Boolean (true/false) false ProtectDiff@EnableProtectDiff Entry spread Price Protection numerical (number) 20 CancelAllWS stop cancels all pending orders Boolean (true/false) true CheckInterval polling interval number numerical (number) 2000 Interval failure retry interval numerical (number) 1300 RestoreProfit restores last profit Boolean (true/false) false LastProfit@RestoreProfit Last Profit numerical (number) 0 ProfitAsOrg@RestoreProfit Last profit counted as average price Boolean (true/false) false EnableAccountCheck enable balance verification Boolean (true/false) true EnableStopLoss@EnableAccountCheck open Stop Loss Boolean (true/false) false StopLoss@EnableStopLoss maximum floating loss numerical (number) 100 StopLossMode@EnableStopLoss Post-stop loss operation Drop-down box (selected) Recycle and exit | Recycle and re-cast EnableStopWin@EnableAccountCheck Turn on Take Profit Boolean (true/false) false StopWin@EnableStopWin Maximum floating profit Number type (number) 120 StopWinMode@EnableStopWin post-take profit operation drop-down box (selected) Recycle and exit | Recycle and re-cast AutoMove@EnableAccountCheck auto Move Boolean (true/false) false MaxDistance@AutoMove maximum distance numerical (number) 20 MaxIdle@AutoMove maximum idle (seconds) numerical (number) 7200 EnableDynamic Turns on dynamic pending orders Boolean (true/false) false DynamicMax@EnableDynamic order expiration distance Number (number) 30 ResetData clears all data at startup Boolean (true/false) true Precision price decimal length numerical (number) 5 */
function hasOrder(orders, orderId) { // Check if there is an order with order ID in parameter orders for (var i = 0; i < orders.length; i++) { // Traverse orders to check if there are same ids, if there are then return true if (orders[i].Id == orderId) { return true; } } return false; // All traversed, no trigger if means haven’t found the order with the ID orderId, return false }
function cancelPending() { // Cancel all pending order functions var ret = false; // Set return success tag variable while (true) { // while loop if (ret) { // If ret is true then Sleep for a certain time Sleep(Interval); } var orders = _C(exchange.GetOrders); // Call the API to get the order information that the exchange did not executed. if (orders.length == 0) { // If an empty array is returned, the exchange has no unexecuted orders. break; // Jump out of the while loop }
for (var j = 0; j < orders.length; j++) { // Traverse the unfinished order array and use orders[j].Id one by one to cancel the order based on the index j.
exchange.CancelOrder(orders[j].Id, orders[j]);
ret = true; // Once there is a cancel operation, ret is assigned a value of true. Used to trigger above Sleep, wait for re-exchange.GetOrders detection
}
}
return ret; // return ret
}
function valuesToString(values, pos) { // Value converted to a string var result = “; // Declare an empty string result for return if (typeof(pos) === ‘undefined’) { // If the pos parameter is not passed, assign pos a value of 0. pos = 0; } for (var i = pos; i < values.length; i++) { // Process values array according to the passed pos if (i > pos) { // In addition to the first loop, add ‘ ’ a space after the result string result += ‘ ‘; } if (values[i] === null) { // If values (function argument list array) the current index’s element is null then result adds ‘null’ string result += ‘null’; } else if (typeof(values[i]) == ‘undefined’) { // If it is undefined, add ‘undefined’ result += ‘undefined’; } else { // Remaining type do switch detection separately switch (values[i].constructor.name) { // Check the name property of the constructor of values[i], which is the type name case ‘Date’: case ‘Number’: case ‘String’: case ‘Function’: result += values[i].toString(); // If it is a date type, a numeric type, a string type, or a function type, call its toString function and convert it to a string, then add break; default: result += JSON.stringify(values[i]); // In other cases, use the JSON.stringify function to convert to a JSON string. Add to result break; } } } return result; // return result }
function Trader() { // Trader function, using closures.
var vId = 0; // Order increment ID
var orderBooks = []; // Order book
var hisBooks = []; // Historical order book
var orderBooksLen = 0; // Order book length
this.Buy = function(price, amount, extra) { // Buying function, parameters: price, quantity, extended information
if (typeof(extra) === ‘undefined’) { // If the parameter extra is not passed in, ie typeof returns undefined
extra = “; // Assign an empty string to extra
} else {
extra = valuesToString(arguments, 2); // The argument arguments passed when calling this.Buy function is passed to the valuesToString function.
}
vId++; //
var orderId = “V” + vId; //
orderBooks[orderId] = { // Add the attribute orderId to the order book array and initialize it with the constructed object.
Type: ORDER_TYPE_BUY, // Constructed Object Type Property: Type buy
Status: ORDER_STATE_PENDING, // State on hold
Id: 0, // orderID 0
Price: price, // price paramter price
Amount: amount, // Order quantity parameter amount
Extra: extra // Extended information A string processed by valuesToString
};
orderBooksLen++; // The length of the order book is increased by 1
return orderId; // Returns the orderId of the order constructed this time (non-exchange order ID, don’t confuse.)
};
this.Sell = function(price, amount, extra) { // Basically similar to this.Buy, construct a sell order.
if (typeof(extra) === ‘undefined’) {
extra = “;
} else {
extra = valuesToString(arguments, 2);
}
vId++;
var orderId = “V” + vId;
orderBooks[orderId] = {
Type: ORDER_TYPE_SELL,
Status: ORDER_STATE_PENDING,
Id: 0,
Price: price,
Amount: amount,
Extra: extra
};
orderBooksLen++;
return orderId;
};
this.GetOrders = function() { // Get unfinished order information
var orders = _C(exchange.GetOrders); // Call API GetOrders to get unfinished order information Assigned to orders
for (orderId in orderBooks) { // Traversing the orderBooks in the Trader object
var order = orderBooks[orderId]; // Take out the order based on orderId
if (order.Status !== ORDER_STATE_PENDING) { // If the state of order is not equal to the suspended state, skip this loop
continue;
}
var found = false; // Initialize the found variable (marked if found) to true
for (var i = 0; i < orders.length; i++) { // Traversing data for unexecuted orders returned by the API
if (orders[i].Id == order.Id) { // When you find an order with the same order id in orderBooks, assign a value of true to find, which means find.
found = true;
break; // Jump out of the current loop
}
}
if (!found) { // If not found, push orderBooks[orderId] to orders.
orders.push(orderBooks[orderId]); // Why do you want to push like this?
}
}
return orders; // return orders
}
this.GetOrder = function(orderId) { // Get order
if (typeof(orderId) === ‘number’) { // If the passed argument orderId is a numeric type
return exchange.GetOrder(orderId); // Call the API GetOrder to get the order information based on the orderId and return.
}
if (typeof(hisBooks[orderId]) !== ‘undefined’) { // Typeof(hisBooks[orderId]) if not equal to undefined
return hisBooks[orderId]; // Return data in hisBooks with attribute as orderId
}
if (typeof(orderBooks[orderId]) !== ‘undefined’) { // As above, if there is a value of orderId in the orderBooks, this data is returned.
return orderBooks[orderId];
}
return null; // Return null if the above conditions are not met
};
this.Len = function() { // Returns the Trader’s orderBookLen variable, which returns the order book length.
return orderBooksLen;
};
this.RealLen = function() { // Back In the order book Activate the order quantity.
var n = 0; // Initial count is 0
for (orderId in orderBooks) { // Traversing the order book
if (orderBooks[orderId].Id > 0) { // If the Id of the current order in the traversal is greater than 0, that is, 0 other than the initial time,
// indicating that the order has been placed, the order has been activated.
n++; // Cumulatively activated order
}
}
return n; // Returns the value of n, which returns the true order book length. (number of orders activated)
};
this.Poll = function(ticker, priceDiff) { //
var orders = _C(exchange.GetOrders); // Get all unexecuted orders
for (orderId in orderBooks) { // Traversing the order book
var order = orderBooks[orderId]; // Take the current order assign to order
if (order.Id > 0) { // If the order is active, ie order.Id is not 0 (already placed)
var found = false; // Variable found (mark found) is false
for (var i = 0; i < orders.length; i++) { // Find the same order number in the executed order information returned by the exchange
if (order.Id == orders[i].Id) { // If found, assign a value of true to find, which means it has been found.
found = true;
}
}
if (!found) { // If the current orderId represents an order that is not found in the order of the uncompleted order returned by the exchange.
order.Status = ORDER_STATE_CLOSED; // Updates the order corresponding to orderId in orderBooks (ie the current order variable) and updates
// the Status property to ORDER_STATE_CLOSED (ie closed)
hisBooks[orderId] = order; // The completed order is recorded in the historical order book, ie hisBooks, unified, and the unique order number orderId
delete(orderBooks[orderId]); // Delete the attribute of the order book named orderId value. (The completed order is deleted from it)
orderBooksLen–; // Order book length reduction
continue; // The following code skips the loop.
}
}
var diff = _N(order.Type == ORDER_TYPE_BUY ? (ticker.Buy - order.Price) : (order.Price - ticker.Sell));
// Diff is the difference between the planned opening price of the order in the current order book and the current real-time opening price.
var pfn = order.Type == ORDER_TYPE_BUY ? exchange.Buy : exchange.Sell; // Assign the corresponding API function reference to pfn according to the type of the order.
// That is, if the order type is a buy order, pfn is a reference to the exchange.Buy function, the same as the sell order.
if (order.Id == 0 && diff <= priceDiff) { // If the order order in the order book is not activated (ie Id is equal to 0) and the current price is less than or
// equal to the order plan price, the priceDiff passed in the parameter.
var realId = pfn(order.Price, order.Amount, order.Extra + "(distance: " + diff + (order.Type == ORDER_TYPE_BUY ? (" ask price: " + ticker.Buy) : (" bid price: " + ticker.Sell))+")");
// Execute order function, parameter passing price, quantity, order extension information + pending order distance + market data (ask price or bid price), return exchange order id
if (typeof(realId) === 'number') { // If the returned realId is a numeric type
order.Id = realId; // Assign the Id attribute of the current order order to the order book.
}
} else if (order.Id > 0 && diff > (priceDiff + 1)) { // If the order is active and the current distance is greater than the distance passed in by the parameter
var ok = true; // Declare a variable for tagging Initially set true
do { // Execute "do" first and then judge while
ok = true; // Ok assign true
exchange.CancelOrder(order.Id, "unnecessary" + (order.Type == ORDER_TYPE_BUY ? "buying" : "selling"), "placed order price:", order.Price, "volume:", order.Amount, ", distance:",
diff, order.Type == ORDER_TYPE_BUY ? ("ask price: " + ticker.Buy) : ("bid price: " + ticker.Sell));
// Cancel the pending order that is out of range. After canceling the order, print the current order information and the current distance diff.
Sleep(200); // Wait 200 milliseconds
orders = _C(exchange.GetOrders); // Call the API to get an uncompleted order in the exchange.
for (var i = 0; i < orders.length; i++) { // Traverse these unfinished orders.
if (orders[i].Id == order.Id) { // If the cancelled order is found in the list of orders that have not been completed by the exchange
ok = false; // Assign ok this variable to false, that is, no cancellation is successful.
}
}
} while (!ok); // If ok is false, then !ok is true and while will continue to repeat the loop, continue to cancel the order,
// and check if the cancellation is successful.
order.Id = 0; // Assigning a value of 0 to order.Id means that the current order is inactive.
}
}
};
}
function balanceAccount(orgAccount, initAccount) { // Balance Account Function Parameter Initial account information when the strategy is started cancelPending(); // Call the custom function cancelPending() to cancel all pending orders. var nowAccount = _C(exchange.GetAccount); // Declare a variable nowAccount to record the latest information about the account at the moment. var slidePrice = 0.2; // Set the slip price when placing the order as 0.2 var ok = true; // Tag variable initially set true while (true) { // while loop var diff = _N(nowAccount.Stocks - initAccount.Stocks); // Calculate the difference between the current account and the initial account diff if (Math.abs(diff) < exchange.GetMinStock()) { // If the absolute value of the currency difference is less than the minimum transaction volume of the exchange, // the break jumps out of the loop and does not perform balancing operations. break; } var depth = _C(exchange.GetDepth); // Get the exchange depth information Assign to the declared depth variable var books = diff > 0 ? depth.Bids : depth.Asks; // According to the difference of the currency is greater than 0 or less than 0, extract the buy order array or // sell order array in depth (equal to 0 will not be processed, it is break when it is judged to be less than GetMinStock) // The difference between the coins is greater than 0 to sell the balance, so look at the buy order array, // the difference between the coins is less than 0 is the opposite. var n = 0; // Statement n initial is 0 var price = 0; // Statement price initial 0 for (var i = 0; i < books.length; i++) { // Traversing the buy or sell order array n += books[i].Amount; // Accumulate Amount (order quantity) for each order based on the index i traversed if (n >= Math.abs(diff)) { // If the cumulative order quantity n is greater than or equal to the currency difference, then: price = books[i].Price; // Get the price of the current indexed order, assign it to price break; // Jump out of the current for traversal cycle } } var pfn = diff > 0 ? exchange.Sell : exchange.Buy; // Pass the sell order API (exchange.Sell) or the next buy order API (exchange.Buy) reference to the declared pfn // based on the currency difference greater than 0 or less than 0 var amount = Math.abs(diff); // The amount of the order to be balanced is diff, the difference in the currency, assigned to the declared amount variable. var price = diff > 0 ? (price - slidePrice) : (price + slidePrice); // The direction of buying and selling according to the difference in the currency, increase or decrease the // slip price based on the price (slip price is to make it easier to trade), and then assign it to price Log(“start the balance”, (diff > 0 ? “sell” : “buy”), amount, “of coins”); // The number of coins that the output log balances. if (diff > 0) { // According to the direction of the buying and selling, determine whether the account currency or the amount of coins is sufficient. amount = Math.min(nowAccount.Stocks, amount); // Make sure that the order amount will not exceed the available coins of the current account. } else { amount = Math.min(nowAccount.Balance / price, amount); // Make sure that the amount of order placed does not exceed the amount of money available in the current account. } if (amount < exchange.GetMinStock()) { // Check if the final order quantity is less than the minimum order quantity allowed by the exchange Log(“Insufficient funds, unable to balance to the initial state”); // If the order quantity is too small, the information is printed. ok = false; // Tag balance failed break; // Jump out of the while loop } pfn(price, amount); // Execute order API (pfn reference) Sleep(1000); // Pause for 1 second cancelPending(); // Cancel all pending orders. nowAccount = _C(exchange.GetAccount); // Get current account information } if (ok) { // Execute the code inside curly braces when ok is true (balance is successful) LogProfit(_N(nowAccount.Balance - orgAccount.Balance)); // Use the Balance property of the incoming parameter orgAccount (account information before balancing) // to subtract the Balance property of the current account information, that is, the difference in the amount of money. // That is, profit and loss (because the number of coins does not change, there is a slight error because some small // amounts cannot be balanced) Log(“平衡完成”, nowAccount); // The output log is balanced. } }
var STATE_WAIT_OPEN = 0; // Used for the state of each node in the fishTable var STATE_WAIT_COVER = 1; // … var STATE_WAIT_CLOSE = 2; // … var ProfitCount = 0; // Profit and loss record var BuyFirst = true; // Initial interface parameters var IsSupportGetOrder = true; // determine the exchange support the GetOrder API function, a global variable, used to determine the start of the main function var LastBusy = 0; // Record the last processed time object
function setBusy() { // Set Busy time LastBusy = new Date(); // Assign LastBusy to the current time object }
function isTimeout() { // Determine if it times out if (MaxIdle <= 0) { // Maximum idle time (based on whether the grid is automatically moved), // if the maximum idle time MaxIdle is set less than or equal to 0 return false; // Returns false, does not judge the timeout. That is, always return false without timeout. } var now = new Date(); // Get current time object if (((now.getTime() - LastBusy.getTime()) / 1000) >= MaxIdle) { // Use the getTime function of the current time object to get the timestamp and the timestamp of LastBusy to calculate the difference, // Divide by 1000 to calculate the number of seconds between the two time objects. // Determine if it is greater than the maximum idle time MaxIdle LastBusy = now; // If it is greater than, update LastBusy to the current time object now return true; // Returns true, which is a timeout. } return false; // Return false no timeout }
function onexit() { // The closing function when the program exits. if (CancelAllWS) { // To cancel all pending orders when stop, call cancelPending() to cancel all pending orders. Log(“Exiting, try to cancel all pending orders”); cancelPending(); } Log(“Strategy successfully stopped”); Log(_C(exchange.GetAccount)); // Print the account position information when you exit the program. }
function fishing(orgAccount, fishCount) { // Casting parameters: account information, number of casting
setBusy(); // Set LastBuys to the current timestamp
var account = _C(exchange.GetAccount); // Declare an account variable to get the current account information and assign it.
Log(account); // Output the account information at the start of the call to the fishing function.
var InitAccount = account; // Declare a variable InitAccount and assign it with account. Here is the initial account funds recorded before
// this casting, used to calculate floating profit and loss.
var ticker = _C(exchange.GetTicker); // Get the quote value assigned to the declared ticker variable
var amount = _N(AmountOnce); // According to the number of interface parameters, use _N to process the decimal places (_N defaults to 2 bits) and assign them to amount.
var amountB = [amount]; // Declare a variable called amountB is an array, initialize an element with amount
var amountS = [amount]; // Declare a variable called amountS …
if (typeof(AmountType) !== ‘undefined’ && AmountType == 1) { // According to the custom amount, the order size type, if this interface parameter is not undefined,
// And AmountType is set to a custom amount on the interface, that is, the AmountType value is 1 (the index of the drop-down box)
for (var idx = 0; idx < AllNum; idx++) { // The total number of AllNum. If you set a custom amount, cycle amountB/amountS to the order quantity array according to the total number of cycles.
amountB[idx] = BAmountOnce; // Assign value to the buy order array using interface parameters
amountS[idx] = SAmountOnce; // … to the sell order…
}
} else { // else
for (var idx = 1; idx < AllNum; idx++) { // Cycles based on the total number of grids.
switch (AmountCoefficient[0]) { // According to the interface parameter difference, the first character of the string, AmountCoefficient[0] is ‘+’, ‘-’, ‘’, ‘/’
case ‘+’: // According to the interface parameters, a grid with a single addition and increment is constructed.
amountB[idx] = amountB[idx - 1] + parseFloat(AmountCoefficient.substring(1));
break;
case ‘-’: // …
amountB[idx] = amountB[idx - 1] - parseFloat(AmountCoefficient.substring(1));
break;
case ‘’:
amountB[idx] = amountB[idx - 1] * parseFloat(AmountCoefficient.substring(1));
break;
case ‘/’:
amountB[idx] = amountB[idx - 1] / parseFloat(AmountCoefficient.substring(1));
break;
}
amountB[idx] = _N(amountB[idx], AmountDot); // buying order, buying amount, and process the data decimal places.
amountS[idx] = amountB[idx]; // Assignment
}
}
if (FirstPriceAuto) { // If the first parameter is automatically set to true if the interface parameter is set, the code inside the if curly brackets is executed.
FirstPrice = BuyFirst ? _N(ticker.Buy - PriceGrid, Precision) : _N(ticker.Sell + PriceGrid, Precision);
// The interface parameter FirstPrice sets the first price according to the BuyFirst global variable (the initial statement is true,
// and has been assigned according to the OpType at the beginning of the main).
// The price is set by the price ticker and the price parameter PriceGrid price interval.
}
// Initialize fish table
var fishTable = {}; // Declare a grid object
var uuidTable = {}; // Identification code table object
var needStocks = 0; // Required coins variable
var needMoney = 0; // Required money variable
var actualNeedMoney = 0; // Actually needed money
var actualNeedStocks = 0; // Actually needed coins
var notEnough = false; // Underfunded tag variable, initially set to false
var canNum = 0; // Available grid
for (var idx = 0; idx < AllNum; idx++) { // The structure is traversed according to the number of grid AllNum.
var price = _N((BuyFirst ? FirstPrice - (idx * PriceGrid) : FirstPrice + (idx * PriceGrid)), Precision);
// When traversing the construct, the current index idx price setting is set according to BuyFirst. The spacing between each index price is PriceGrid.
needStocks += amountS[idx]; // The number of coins sold is gradually accumulated with the cycle. (accumulated by the sell order quantity array to needStocks one by one)
needMoney += price * amountB[idx]; // The amount of money required to buy is gradually accumulated with the cycle. (….buy the order quantity array one by one…)
if (BuyFirst) { // Handling buy first
if (_N(needMoney) <= _N(account.Balance)) { // If the grid requires less money than the amount of money available on the account
actualNeedMondy = needMoney; // Assigned to the actual amount of money required
actualNeedStocks = needStocks; // Assigning to the actual number of coins required. Is there something wrong with this?
canNum++; // Cumulative number of available grids
} else { // _N(needMoney) <= _N(account.Balance) If this condition is not met, set the underfunded tag variable to true
notEnough = true;
}
} else { // Handling sell first
if (_N(needStocks) <= _N(account.Stocks)) { // Check if the required number of coins is less than the number of coins available in the account
actualNeedMondy = needMoney; // Assignment
actualNeedStocks = needStocks;
canNum++; // Cumulative number of available grids
} else {
notEnough = true; // Set true if the funding conditions are not met
}
}
fishTable[idx] = STATE_WAIT_OPEN; // According to the current index idx, set the state of the idx member (grid node) of the grid object,
// initially STATE_WAIT_OPEN (waiting to open the position)
uuidTable[idx] = -1; // The numbered object also initializes its own idx value (the node corresponding to the fishTable) to -1 based on the current idx.
}
if (!EnableAccountCheck && (canNum < AllNum)) { // If the funds check is not enabled, and the number of grids (the total number of nodes) where the node is smaller
// than the interface parameter setting can be opened.
Log(“Warning, current funds can only be made”, canNum, “of Grids, total grid needs”, (BuyFirst ? needMoney : needStocks), “Please keep sufficient funds”); // Log outputs a warning message.
canNum = AllNum; // Update the number of openable settings for the interface parameters
}
if (BuyFirst) { // buy first
if (EnableProtectDiff && (FirstPrice - ticker.Sell) > ProtectDiff) { // Open spread protection and enter the market price minus the current bid price more than
// the market entry price protection
throw “The first buying price is higher than the market selling price” + _N(FirstPrice - ticker.Sell, Precision) + ‘ dollar’; // Throw an error message.
} else if (EnableAccountCheck && account.Balance < _N(needMoney)) { // If the funds check is enabled and the amount of money available for the account is less than
// the amount of money required for the grid.
if (fishCount == 1) { // If it is the first time to cast the grid
throw “Insufficient funds, need” + _N(needMoney) + “dollar”; // Throw an error, insufficient funds
} else {
Log(“Insufficient funds, need”, _N(needMoney), “dollar, the program only make”, canNum, “of grids #ff0000”); // If it is not the first time to cast a grid, output a message.
}
} else { // In other cases, there is no capital inspection, price protection, etc.
Log(‘Estimated use of funds: ‘, _N(needMoney), “dollar”); // The output is expected to use funds.
}
} else { // sell first， The following is similar to “buy first”
if (EnableProtectDiff && (ticker.Buy - FirstPrice) > ProtectDiff) {
throw “The first selling price is higher than the market buying price” + _N(ticker.Buy - FirstPrice, Precision) + ’ dollar’;
} else if (EnableAccountCheck && account.Stocks < _N(needStocks)) {
if (fishCount == 1) {
throw “Insufficient funds, need” + _N(needStocks) + “ of coins”;
} else {
Log(“Insufficient funds, need”, _N(needStocks), “of coins, program only make”, canNum, “of grids #ff0000”);
}
} else {
Log(‘Estimated use of funds: ‘, _N(needStocks), “coins, approximately”, _N(needMoney), “dollar”);
}
}
var trader = new Trader(); // Constructs a Trader object, assigning it to the trader variable declared here.
var OpenFunc = BuyFirst ? exchange.Buy : exchange.Sell; // According to whether to buy and sell first, set the open function OpenFunc to refer to exchange.Buy or exchange.Sell
var CoverFunc = BuyFirst ? exchange.Sell : exchange.Buy; // same as above
if (EnableDynamic) { // Set OpenFunc/CoverFunc again according to whether the interface parameter EnableDynamic is enabled.
OpenFunc = BuyFirst ? trader.Buy : trader.Sell; // The member function Buy that references the trader object is used for dynamic pending orders (mainly because
// some exchanges limit the number of pending orders, so virtual dynamic pending orders are required)
CoverFunc = BuyFirst ? trader.Sell : trader.Buy; // same as above
}
var ts = new Date(); // Create a time object at this time (assigned to ts) to record the time at the moment.
var preMsg = ""; // Declare a variable to record the last message, the initial set to empty string
var profitMax = 0; // Maximum return
while (true) { // The main logic after the grid is casted
var now = new Date(); // Record the time when the current cycle started
var table = null; // Declare a variable
if (now.getTime() - ts.getTime() > 5000) { // Calculate whether the difference between the current time now and the recorded time ts is greater than 5000 milliseconds
if (typeof(GetCommand) == 'function' && GetCommand() == "Receiving grid") { // Check if the strategy interaction control command "receives the grid" is received,
// stops and balances to the initial state.
Log("Start executing commands to perform grid operations"); // Output information
balanceAccount(orgAccount, InitAccount); // Perform a balancing function to balance the number of coins to the initial state
return false; // This time the grid function is fishing and return false
}
ts = now; // Update ts with current time now for next comparison time
var nowAccount = _C(exchange.GetAccount); // Declare the nowAccount variable and initially been set as the current account information.
var ticker = _C(exchange.GetTicker); // Declare the ticker variable and initially been set as the current market information.
if (EnableDynamic) { // If you enable dynamic pending orders
trader.Poll(ticker, DynamicMax); // Call the Poll function of the trader object to detect and process all orders based on the
// current ticker market and the interface parameter DynamicMax.
}
var amount_diff = (nowAccount.Stocks + nowAccount.FrozenStocks) - (InitAccount.Stocks + InitAccount.FrozenStocks); // Calculate the current coin difference
var money_diff = (nowAccount.Balance + nowAccount.FrozenBalance) - (InitAccount.Balance + InitAccount.FrozenBalance); // Calculate the current money difference
var floatProfit = _N(money_diff + (amount_diff * ticker.Last)); // Calculate the current floating profit and loss of this time of casting grid
var floatProfitAll = _N((nowAccount.Balance + nowAccount.FrozenBalance - orgAccount.Balance - orgAccount.FrozenBalance) + ((nowAccount.Stocks + nowAccount.FrozenStocks
- orgAccount.Stocks - orgAccount.FrozenStocks) * ticker.Last));
// Calculate the overall floating profit and loss
var isHold = Math.abs(amount_diff) >= exchange.GetMinStock(); // If the absolute value of the coin difference at this moment is greater than the minimum trading
// volume of the exchange, it means that the position has been held.
if (isHold) { // If you have already held a position, execute the setBusy() function, which will update the LastBusy time.
setBusy(); // That is, after opening the position, the opening of the opening mechanism is started.
}
profitMax = Math.max(floatProfit, profitMax); // Refresh the maximum floating profit and loss
if (EnableAccountCheck && EnableStopLoss) { // If you initiate account detection and start a stop loss
if ((profitMax - floatProfit) >= StopLoss) { // If the maximum floating profit or loss minus the current floating profit or loss is greater than or equal to
// the maximum floating loss value, execute the code inside the curly braces
Log("Current floating profit a