//+------------------------------------------------------------------+
//|                                            MEXC_Examples.mq5     |
//|                                Copyright 2026, Rajesh Kumar Nait |
//|              MEXC API v3 (Spot) + Futures — Example & Test File  |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Rajesh Kumar Nait"
#property link      "https://www.mql5.com/en/users/rajeshnait/seller"
#property version   "2.0"
#property script_show_inputs

//+------------------------------------------------------------------+
//| JSON Parser                                                      |
//+------------------------------------------------------------------+
#include <Custom/Crypto_Charting/JAson.mqh>
CJAVal jv(NULL, jtUNDEF);

//+------------------------------------------------------------------+
//| MEXC Config Struct (must match library)                          |
//+------------------------------------------------------------------+
struct MEXCConfig {
   string api_url;        // Spot base: "https://api.mexc.com"
   string api_key;        // API Access Key
   string api_secret;     // API Secret Key
   string api_suffix;     // Spot path: "/api/v3/"
   string futures_url;    // Futures base: "https://contract.mexc.com"
   string futures_suffix; // Futures path: "/api/v1/"
   string symbol_prefix;  // MT5 custom symbol prefix
   bool   debug;          // Debug logging
};

//+------------------------------------------------------------------+
//| Import Library Functions                                         |
//| NOTE: Adjust the path to match your MetaTrader directory layout  |
//+------------------------------------------------------------------+
#import "..\Libraries\Library_MEXC.ex5"

//--- Initialization & Utilities
void   MEXC_Init(MEXCConfig &config);
string GetTime();
string Get_Symbol_Price_Ticker(string symbol);

//--- Symbol & Chart Management
void   CreateSymbols_MEXC();
void   RunUpdate(string symbol, datetime StartDateTime);

//===================================================================
//  SPOT TRADE FUNCTIONS (https://api.mexc.com/api/v3/...)
//  Signature: HMAC-SHA256(totalParams) → &signature= param
//  Header:    X-MEXC-APIKEY
//===================================================================

//--- Test New Order (validates without executing)
string SpotTestNewOrder(
   string symbol, string side, string type,
   string quantity, string quoteOrderQty,
   string price, string newClientOrderId
);

//--- New Order (places a real order)
string SpotNewOrder(
   string symbol, string side, string type,
   string quantity, string quoteOrderQty,
   string price, string newClientOrderId
);

//--- Batch Orders (up to 20 orders, same symbol)
string SpotBatchOrders(string batchOrdersJson);

//--- Cancel Order (by orderId or origClientOrderId)
string SpotCancelOrder(string symbol, string orderId, string origClientOrderId);

//--- Cancel All Open Orders on a Symbol
string SpotCancelAllOpenOrders(string symbol);

//--- Cancel ALL Orders (all symbols)
string SpotCancelAllOrders();

//--- Query Order Status
string SpotQueryOrder(string symbol, string orderId, string origClientOrderId);

//--- Get Current Open Orders (symbol optional)
string SpotCurrentOpenOrders(string symbol);

//--- Get All Orders (active + canceled + filled)
string SpotAllOrders(string symbol, string startTime, string endTime, int limit);

//--- Account Trade List (fills/executions)
string SpotAccountTradeList(string symbol, string orderId, string startTime, string endTime, int limit);

//--- Backward-compatible wrappers
string orderLimit(string symbol, string side, double quantity, double price);
string orderMarket(string symbol, string side, double quantity);
string orderCancel(string symbol, string orderId);
string orderCancelAll(string symbol);
string getWalletBalance(string accountType);
string getPosition(string symbol, string cursor);

//===================================================================
//  FUTURES TRADE FUNCTIONS (https://contract.mexc.com/api/v1/...)
//  Signature: HMAC-SHA256(accessKey + timestamp + paramString)
//  Headers:   ApiKey, Request-Time, Signature
//===================================================================

//--- Place Futures Order
//    side: 1=Open Long, 2=Close Short, 3=Open Short, 4=Close Long
//    type: 1=Limit, 2=Post Only, 3=IOC, 4=FOK, 5=Market
//    openType: 1=Isolated, 2=Cross
string FuturesPlaceOrder(
   string symbol, double price, double vol, int side, int type,
   int openType, int leverage, string externalOid,
   double stopLossPrice, double takeProfitPrice
);

//--- Cancel Futures Order(s) — comma-separated IDs
string FuturesCancelOrder(string orderIds);

//--- Cancel All Futures Orders for a Symbol
string FuturesCancelAllOrders(string symbol);

//--- Switch Leverage
string FuturesSwitchLeverage(int leverage, long positionId, string symbol, int openType, int positionType);
string setLeverage(string symbol, string buyLeverage, string sellLeverage);

//--- Get Leverage
string FuturesGetLeverage(string symbol);

//--- Change Position Margin (type: "ADD" or "SUB")
string FuturesChangeMargin(long positionId, double margin, string type);

//--- Query Single Futures Order
string FuturesQueryOrder(string orderId);

//--- Get Order by External/Client ID
string FuturesGetOrderByExternalId(string symbol, string externalOid);

//--- Batch Query Orders — comma-separated IDs (max 50)
string FuturesBatchQueryOrders(string orderIds);

//--- Get All Open Futures Orders
string FuturesGetAllOpenOrders(string symbol, int pageNum, int pageSize);

//--- Get All Futures Orders (History)
string FuturesGetAllOrders(string symbol, string states, int category, int pageNum, int pageSize, string startTime, string endTime);

//--- Query All Transaction Details (Deals)
string FuturesQueryAllTransactions(string symbol, int pageNum, int pageSize, string startTime, string endTime);

//--- Query Transaction Details for a Specific Order
string FuturesQueryOrderTransactions(string orderId);

//--- Get Force/Liquidation Orders
string FuturesGetForceOrders(string symbol, int category, int pageNum, int pageSize, string startTime, string endTime);

//--- Place Trigger Order (Plan Order)
string FuturesPlaceTriggerOrder(
   string symbol, double price, double vol, int side, int type,
   int openType, int leverage, double triggerPrice,
   int triggerType, int executeCycle, int trend
);

//--- Cancel Trigger Order(s)
string FuturesCancelTriggerOrder(string orderIds);

//--- Cancel All Trigger Orders for a Symbol
string FuturesCancelAllTriggerOrders(string symbol);

//--- Get Open Trigger Orders
string FuturesGetOpenTriggerOrders(string symbol, int pageNum, int pageSize);

//--- Get All Trigger Orders (History)
string FuturesGetAllTriggerOrders(string symbol, string states, int pageNum, int pageSize, string startTime, string endTime);

//--- Place Stop-Limit Order (TP/SL by Position)
string FuturesPlaceStopLimitOrder(
   long positionId, double vol,
   double stopLossPrice, double takeProfitPrice,
   int lossTrend, int profitTrend,
   int stopLossType, double stopLossOrderPrice,
   int takeProfitType, double takeProfitOrderPrice
);

//--- Cancel Stop-Limit Order(s)
string FuturesCancelStopLimitOrder(string orderIds);

//--- Cancel All Stop-Limit Orders for a Symbol
string FuturesCancelAllStopLimitOrders(string symbol);

//--- Get Open Stop-Limit Orders
string FuturesGetOpenStopLimitOrders(string symbol, int pageNum, int pageSize);

//--- Get All Stop-Limit Orders (History)
string FuturesGetAllStopLimitOrders(string symbol, int pageNum, int pageSize, string startTime, string endTime);

//--- Futures Account
string FuturesGetAssets();
string FuturesGetOpenPositions(string symbol);

//--- Backward-compatible wrapper
string setTradingStop(string symbol, string slTrigger, string tpTrigger);

#import

//+------------------------------------------------------------------+
//| USER CONFIGURATION — Edit these values                           |
//+------------------------------------------------------------------+
input bool   MEXC_debug         = true;                    // Debug logging (Expert tab)
input string MEXC_Key           = "mx0vglViL3wdwr80l3";     // MEXC API Key
input string MEXC_Secret        = "d0f917ba34e648c0a03faa6e3ec73e26"; // MEXC API Secret
input string MEXC_URL           = "https://api.mexc.com";  // Spot API Base URL
input string MEXC_FuturesURL    = "https://contract.mexc.com"; // Futures API Base URL
input string MEXC_suffix        = "/api/v3/";              // Spot API Path Prefix
input string MEXC_FuturesSuffix = "/api/v1/";              // Futures API Path Prefix
input string MEXC_SymbolPrefix  = "ms_";                   // MT5 Custom Symbol Prefix

//--- Chart / History
input datetime MaxDate = D'2026-02-01 00:00:00';           // Max date for history download

//+------------------------------------------------------------------+
//| Global Variables                                                 |
//+------------------------------------------------------------------+
MEXCConfig config;
string sym;

//+------------------------------------------------------------------+
//| Script Entry Point                                               |
//+------------------------------------------------------------------+
void OnStart() {

   //=================================================================
   // 1. INITIALIZE CONFIG
   //=================================================================
   config.api_url        = MEXC_URL;
   config.api_key        = MEXC_Key;
   config.api_secret     = MEXC_Secret;
   config.api_suffix     = MEXC_suffix;
   config.futures_url    = MEXC_FuturesURL;
   config.futures_suffix = MEXC_FuturesSuffix;
   config.symbol_prefix  = MEXC_SymbolPrefix;
   config.debug          = MEXC_debug;

   MEXC_Init(config);
   Print("=== MEXC Library Initialized ===");

   //=================================================================
   // 2. SERVER TIME TEST
   //=================================================================
   string serverTime = GetTime();
   Print("Server Time: ", serverTime);


   //=================================================================
   //=================================================================
   //
   //          S P O T   T R A D E   E X A M P L E S
   //
   //  Base URL: https://api.mexc.com/api/v3/...
   //  Auth:     X-MEXC-APIKEY header
   //  Sign:     HMAC-SHA256(totalParams) as &signature= param
   //
   //=================================================================
   //=================================================================

   string s;  // reusable response holder


   //--- 2.1  TEST NEW ORDER (validates params, no real trade) ------
   //    POST /api/v3/order/test
   //    Same params as SpotNewOrder but never executes
   //Print("=== SPOT: Test New Order ===");
   //s = SpotTestNewOrder(
   //   "BTCUSDT",     // symbol
   //   "BUY",         // side: BUY or SELL
   //   "LIMIT",       // type: LIMIT or MARKET
   //   "0.001",       // quantity (base asset)
   //   "",            // quoteOrderQty (only for MARKET buy)
   //   "50000",       // price (required for LIMIT)
   //   ""             // newClientOrderId (optional)
   //);
   //Print("TestNewOrder: ", s);


   //--- 2.2  NEW LIMIT ORDER -----------------------------------------
   //    POST /api/v3/order
//   Print("=== SPOT: New Limit Order ===");
//   s = SpotNewOrder(
//      "BTCUSDT",     // symbol
//      "BUY",         // side
//      "LIMIT",       // type
//      "0.001",       // quantity
//      "",            // quoteOrderQty
//      "50000",       // price
//      ""             // newClientOrderId
//   );
//   Print("NewOrder LIMIT: ", s);
//
//   // Parse orderId from response
//   jv.Deserialize(s);
//   string spotOrderId = jv["orderId"].ToStr();
//   Print("New Order ID: ", spotOrderId);
//
//
//   //--- 2.3  NEW MARKET ORDER ----------------------------------------
//   //    POST /api/v3/order
//   Print("=== SPOT: New Market Order ===");
//   s = SpotNewOrder(
//      "BTCUSDT",     // symbol
//      "BUY",         // side
//      "MARKET",      // type
//      "0.001",       // quantity (base asset amount)
//      "",            // quoteOrderQty (use this instead to buy by USDT amount)
//      "",            // price (not needed for MARKET)
//      ""             // newClientOrderId
//   );
//   Print("NewOrder MARKET: ", s);
//
//
//   //--- 2.4  MARKET ORDER BY QUOTE AMOUNT ----------------------------
//   //    Buy $10 worth of BTC at market price
//   Print("=== SPOT: Market Order by Quote Amount ===");
//   s = SpotNewOrder(
//      "BTCUSDT",     // symbol
//      "BUY",         // side
//      "MARKET",      // type
//      "",            // quantity (leave empty when using quoteOrderQty)
//      "10",          // quoteOrderQty = spend 10 USDT
//      "",            // price
//      ""             // newClientOrderId
//   );
//   Print("NewOrder MARKET (by quote): ", s);
//
//
//   //--- 2.5  CONVENIENCE: LIMIT ORDER (old-style wrapper) -----------
//   Print("=== SPOT: orderLimit (backward-compat) ===");
//   s = orderLimit("BTCUSDT", "BUY", 0.001, 50000.00);
//   Print("orderLimit: ", s);
//
//
//   //--- 2.6  CONVENIENCE: MARKET ORDER (old-style wrapper) ----------
//   Print("=== SPOT: orderMarket (backward-compat) ===");
//   s = orderMarket("BTCUSDT", "BUY", 0.001);
//   Print("orderMarket: ", s);
//
//
//   //--- 2.7  BATCH ORDERS (up to 20 orders, same symbol) ------------
//   //    POST /api/v3/batchOrders
//   Print("=== SPOT: Batch Orders ===");
//   string batchJson =
//      "[{\"symbol\":\"BTCUSDT\",\"side\":\"BUY\",\"type\":\"LIMIT\","
//      "\"quantity\":\"0.001\",\"price\":\"49000\"},"
//      "{\"symbol\":\"BTCUSDT\",\"side\":\"BUY\",\"type\":\"LIMIT\","
//      "\"quantity\":\"0.001\",\"price\":\"48000\"}]";
//   s = SpotBatchOrders(batchJson);
//   Print("BatchOrders: ", s);
//
//
//   //--- 2.8  QUERY ORDER STATUS --------------------------------------
//   //    GET /api/v3/order
//   Print("=== SPOT: Query Order ===");
//   s = SpotQueryOrder(
//      "BTCUSDT",     // symbol
//      spotOrderId,   // orderId (from step 2.2)
//      ""             // origClientOrderId (alternative to orderId)
//   );
//   Print("QueryOrder: ", s);
//   jv.Deserialize(s);
//   Print("  Status:   ", jv["status"].ToStr());
//   Print("  Side:     ", jv["side"].ToStr());
//   Print("  Price:    ", jv["price"].ToStr());
//   Print("  Qty:      ", jv["origQty"].ToStr());
//
//
//   //--- 2.9  GET CURRENT OPEN ORDERS ---------------------------------
//   //    GET /api/v3/openOrders
//   Print("=== SPOT: Current Open Orders ===");
//   s = SpotCurrentOpenOrders("BTCUSDT");  // pass "" for ALL symbols
//   Print("OpenOrders: ", s);
//
//   // Parse and list open orders
//   jv.Deserialize(s);
//   int totalOpen = jv.Size();
//   Print("Total Open Orders: ", totalOpen);
//   for(int i = 0; i < totalOpen && i < 5; i++) {
//      Print("  [", i, "] orderId=", jv[i]["orderId"].ToStr(),
//            " side=", jv[i]["side"].ToStr(),
//            " price=", jv[i]["price"].ToStr(),
//            " qty=", jv[i]["origQty"].ToStr(),
//            " status=", jv[i]["status"].ToStr());
//   }
//
//
//   //--- 2.10 GET ALL ORDERS (history) --------------------------------
//   //    GET /api/v3/allOrders
//   Print("=== SPOT: All Orders (History) ===");
//   s = SpotAllOrders(
//      "BTCUSDT",     // symbol (required)
//      "",            // startTime (ms, optional)
//      "",            // endTime (ms, optional)
//      10             // limit (max 1000)
//   );
//   Print("AllOrders: ", s);
//
//
//   //--- 2.11 ACCOUNT TRADE LIST (fills) ------------------------------
//   //    GET /api/v3/myTrades
//   Print("=== SPOT: Account Trade List ===");
//   s = SpotAccountTradeList(
//      "BTCUSDT",     // symbol (required)
//      "",            // orderId filter (optional)
//      "",            // startTime (optional)
//      "",            // endTime (optional)
//      10             // limit (max 100)
//   );
//   Print("TradeList: ", s);
//
//
//   //--- 2.12 CANCEL ORDER -------------------------------------------
//   //    DELETE /api/v3/order
//   Print("=== SPOT: Cancel Order ===");
//   s = SpotCancelOrder(
//      "BTCUSDT",     // symbol
//      spotOrderId,   // orderId
//      ""             // origClientOrderId (alternative)
//   );
//   Print("CancelOrder: ", s);
//
//   // Backward-compatible version:
//   // s = orderCancel("BTCUSDT", spotOrderId);
//
//
//   //--- 2.13 CANCEL ALL OPEN ORDERS ON SYMBOL -----------------------
//   //    DELETE /api/v3/openOrders
//   Print("=== SPOT: Cancel All Open Orders (Symbol) ===");
//   s = SpotCancelAllOpenOrders("BTCUSDT");
//   Print("CancelAllOpen: ", s);
//
//   // Backward-compatible version:
//   // s = orderCancelAll("BTCUSDT");
//
//
//   //--- 2.14 CANCEL ALL ORDERS (ALL SYMBOLS) -------------------------
//   //    DELETE /api/v3/order/all
//   Print("=== SPOT: Cancel ALL Orders (All Symbols) ===");
//   s = SpotCancelAllOrders();
//   Print("CancelAllOrders: ", s);
//
//
//   //--- 2.15 SPOT WALLET BALANCE ------------------------------------
//   Print("=== SPOT: Wallet Balance ===");
//   s = getWalletBalance("SPOT");
//   Print("SpotBalance: ", s);
//
//   // Parse balances
//   jv.Deserialize(s);
//   if(jv.HasKey("balances")) {
//      for(int i = 0; i < jv["balances"].Size() && i < 10; i++) {
//         string asset = jv["balances"][i]["asset"].ToStr();
//         string free  = jv["balances"][i]["free"].ToStr();
//         string locked = jv["balances"][i]["locked"].ToStr();
//         if(StringToDouble(free) > 0 || StringToDouble(locked) > 0)
//            Print("  ", asset, ": free=", free, " locked=", locked);
//      }
//   }
//
//
//   //--- 2.16 TICKER PRICE -------------------------------------------
//   Print("=== SPOT: Ticker Price ===");
//   s = Get_Symbol_Price_Ticker("BTCUSDT");
//   Print("BTC Price: ", s);



   //=================================================================
   //=================================================================
   //
   //       F U T U R E S   T R A D E   E X A M P L E S
   //
   //  Base URL: https://contract.mexc.com/api/v1/private/...
   //  Auth:     ApiKey + Request-Time + Signature headers
   //  Sign:     HMAC-SHA256(accessKey + timestamp + paramString)
   //  POST:     application/json (camelCase params)
   //  GET:      snake_case query params (sorted alphabetically)
   //
   //  SIDE VALUES:
   //    1 = Open Long    2 = Close Short
   //    3 = Open Short   4 = Close Long
   //
   //  ORDER TYPES:
   //    1 = Limit    2 = Post Only    3 = IOC
   //    4 = FOK      5 = Market
   //
   //  OPEN TYPE:
   //    1 = Isolated    2 = Cross
   //
   //=================================================================
   //=================================================================


//   //--- 3.1  FUTURES: GET ASSETS (Account Balance) -------------------
//   Print("=== FUTURES: Get Assets ===");
   s = FuturesGetAssets();
   Print("FuturesAssets: ", s);
//
//   // Parse Futures balance
   jv.Deserialize(s);
   if(jv.HasKey("data")) {
      for(int i = 0; i < jv["data"].Size() && i < 5; i++) {
         Print("  Currency: ", jv["data"][i]["currency"].ToStr(),
               " AvailableBalance: ", jv["data"][i]["availableBalance"].ToStr(),
               " FrozenBalance: ",    jv["data"][i]["frozenBalance"].ToStr());
      }
   }
//
//   // Backward-compatible version:
//   // s = getWalletBalance("FUTURES");
//
//
//   //--- 3.2  FUTURES: GET LEVERAGE -----------------------------------
//   Print("=== FUTURES: Get Leverage ===");
//   s = FuturesGetLeverage("BTC_USDT");
//   Print("Leverage: ", s);
//
//
//   //--- 3.3  FUTURES: SWITCH LEVERAGE --------------------------------
//   //    POST /api/v1/private/position/change_leverage
//   Print("=== FUTURES: Switch Leverage to 10x ===");
//   s = FuturesSwitchLeverage(
//      10,            // leverage
//      0,             // positionId (0 = no existing position)
//      "BTC_USDT",    // symbol
//      1,             // openType: 1=Isolated, 2=Cross
//      1              // positionType: 1=Long, 2=Short
//   );
//   Print("SwitchLeverage: ", s);
//
//   // Backward-compatible version:
//   // s = setLeverage("BTC_USDT", "10", "10");
//
//
//   //--- 3.4  FUTURES: PLACE LIMIT ORDER (Open Long) -----------------
//   //    POST /api/v1/private/order/create
//   Print("=== FUTURES: Place Limit Order (Open Long) ===");
//   s = FuturesPlaceOrder(
//      "BTC_USDT",    // symbol (note: underscore for futures)
//      50000.0,       // price
//      1,             // vol (quantity in contracts)
//      1,             // side: 1=Open Long
//      1,             // type: 1=Limit
//      1,             // openType: 1=Isolated
//      10,            // leverage: 10x
//      "",            // externalOid (optional client ID)
//      0,             // stopLossPrice (0 = none)
//      0              // takeProfitPrice (0 = none)
//   );
//   Print("FuturesPlaceOrder (Limit Long): ", s);
//
//   // Parse order ID
//   jv.Deserialize(s);
//   string futOrderId = "";
//   if(jv.HasKey("data"))
//      futOrderId = jv["data"].ToStr();
//   Print("Futures Order ID: ", futOrderId);
//
//
//   //--- 3.5  FUTURES: PLACE MARKET ORDER (Open Long) ----------------
//   Print("=== FUTURES: Place Market Order (Open Long) ===");
//   s = FuturesPlaceOrder(
//      "BTC_USDT",    // symbol
//      0,             // price (0 for market)
//      1,             // vol
//      1,             // side: 1=Open Long
//      5,             // type: 5=Market
//      2,             // openType: 2=Cross
//      20,            // leverage
//      "",            // externalOid
//      49000.0,       // stopLossPrice
//      55000.0        // takeProfitPrice
//   );
//   Print("FuturesPlaceOrder (Market Long + SL/TP): ", s);
//
//
//   //--- 3.6  FUTURES: PLACE MARKET ORDER (Open Short) ---------------
//   Print("=== FUTURES: Place Market Order (Open Short) ===");
//   s = FuturesPlaceOrder(
//      "BTC_USDT",    // symbol
//      0,             // price
//      1,             // vol
//      3,             // side: 3=Open Short
//      5,             // type: 5=Market
//      1,             // openType: 1=Isolated
//      10,            // leverage
//      "",            // externalOid
//      0, 0           // no SL/TP
//   );
//   Print("FuturesPlaceOrder (Market Short): ", s);
//
//
//   //--- 3.7  FUTURES: CLOSE LONG (Market) ---------------------------
//   Print("=== FUTURES: Close Long (Market) ===");
//   s = FuturesPlaceOrder(
//      "BTC_USDT",    // symbol
//      0,             // price
//      1,             // vol
//      4,             // side: 4=Close Long
//      5,             // type: 5=Market
//      1,             // openType
//      10,            // leverage
//      "",            // externalOid
//      0, 0           // no SL/TP
//   );
//   Print("FuturesPlaceOrder (Close Long): ", s);
//
//
//   //--- 3.8  FUTURES: CLOSE SHORT (Market) --------------------------
//   Print("=== FUTURES: Close Short (Market) ===");
//   s = FuturesPlaceOrder(
//      "BTC_USDT",    // symbol
//      0,             // price
//      1,             // vol
//      2,             // side: 2=Close Short
//      5,             // type: 5=Market
//      1,             // openType
//      10,            // leverage
//      "",            // externalOid
//      0, 0           // no SL/TP
//   );
//   Print("FuturesPlaceOrder (Close Short): ", s);
//
//
//   //--- 3.9  FUTURES: QUERY ORDER ------------------------------------
//   //    GET /api/v1/private/order/get/{orderId}
//   Print("=== FUTURES: Query Order ===");
//   if(futOrderId != "") {
//      s = FuturesQueryOrder(futOrderId);
//      Print("FuturesQueryOrder: ", s);
//   }
//
//
//   //--- 3.10 FUTURES: GET ALL OPEN ORDERS ----------------------------
//   //    GET /api/v1/private/order/list/open_orders
//   Print("=== FUTURES: Get All Open Orders ===");
//   s = FuturesGetAllOpenOrders(
//      "BTC_USDT",    // symbol (empty for all)
//      1,             // pageNum
//      20             // pageSize (max 100)
//   );
//   Print("FuturesOpenOrders: ", s);
//
//   // Parse open orders
//   jv.Deserialize(s);
//   if(jv.HasKey("data")) {
//      int futTotal = jv["data"].Size();
//      Print("Total Futures Open Orders: ", futTotal);
//      for(int i = 0; i < futTotal && i < 5; i++) {
//         Print("  [", i, "] orderId=", jv["data"][i]["orderId"].ToStr(),
//               " side=",    jv["data"][i]["side"].ToStr(),
//               " price=",   jv["data"][i]["price"].ToStr(),
//               " vol=",     jv["data"][i]["vol"].ToStr(),
//               " state=",   jv["data"][i]["state"].ToStr());
//      }
//   }
//
//
//   //--- 3.11 FUTURES: GET ALL ORDERS (History) -----------------------
//   //    GET /api/v1/private/order/list/history_orders
//   Print("=== FUTURES: Get All Orders (History) ===");
//   s = FuturesGetAllOrders(
//      "BTC_USDT",    // symbol
//      "",            // states: 1=Pending,2=Unfilled,3=Filled,4=Canceled,5=Invalid
//      0,             // category: 0=all, 1=Limit, 2=Liquidation
//      1,             // pageNum
//      20,            // pageSize
//      "",            // startTime (ms)
//      ""             // endTime (ms)
//   );
//   Print("FuturesAllOrders: ", s);
//
//
//   //--- 3.12 FUTURES: BATCH QUERY ORDERS ----------------------------
//   //    GET /api/v1/private/order/batch_query
//   Print("=== FUTURES: Batch Query Orders ===");
//   if(futOrderId != "") {
//      s = FuturesBatchQueryOrders(futOrderId);  // comma-separated IDs
//      Print("FuturesBatchQuery: ", s);
//   }
//
//
//   //--- 3.13 FUTURES: QUERY ALL TRANSACTIONS (Deals) -----------------
//   //    GET /api/v1/private/order/list/order_deals
//   Print("=== FUTURES: Query All Transactions ===");
//   s = FuturesQueryAllTransactions(
//      "BTC_USDT",    // symbol
//      1,             // pageNum
//      20,            // pageSize
//      "",            // startTime
//      ""             // endTime
//   );
//   Print("FuturesAllDeals: ", s);
//
//
//   //--- 3.14 FUTURES: QUERY ORDER TRANSACTIONS -----------------------
//   //    GET /api/v1/private/order/deal_details/{orderId}
//   if(futOrderId != "") {
//      Print("=== FUTURES: Query Order Transactions ===");
//      s = FuturesQueryOrderTransactions(futOrderId);
//      Print("FuturesOrderDeals: ", s);
//   }
//
//
//   //--- 3.15 FUTURES: GET ORDER BY EXTERNAL ID -----------------------
//   //    GET /api/v1/private/order/external/{symbol}/{externalOid}
//   // s = FuturesGetOrderByExternalId("BTC_USDT", "my-custom-id-123");
//   // Print("FuturesByExternalId: ", s);
//
//
//   //--- 3.16 FUTURES: GET FORCE ORDERS (Liquidations) ----------------
//   //    GET /api/v1/private/order/list/history_orders (category=2)
//   Print("=== FUTURES: Get Force Orders ===");
//   s = FuturesGetForceOrders(
//      "BTC_USDT",    // symbol
//      2,             // category: 2=Liquidation, 3=Custody, 4=ADL
//      1,             // pageNum
//      20,            // pageSize
//      "",            // startTime
//      ""             // endTime
//   );
//   Print("FuturesForceOrders: ", s);
//
//
//   //--- 3.17 FUTURES: CANCEL ORDER -----------------------------------
//   //    POST /api/v1/private/order/cancel
//   Print("=== FUTURES: Cancel Order ===");
//   if(futOrderId != "") {
//      s = FuturesCancelOrder(futOrderId);  // comma-separated for multiple
//      Print("FuturesCancelOrder: ", s);
//   }
//
//
//   //--- 3.18 FUTURES: CANCEL ALL ORDERS FOR SYMBOL -------------------
//   //    POST /api/v1/private/order/cancel_all
//   Print("=== FUTURES: Cancel All Orders ===");
//   s = FuturesCancelAllOrders("BTC_USDT");
//   Print("FuturesCancelAll: ", s);
//
//
//   //--- 3.19 FUTURES: CHANGE MARGIN ----------------------------------
//   //    POST /api/v1/private/position/change_margin
//   // s = FuturesChangeMargin(
//   //    12345678,      // positionId
//   //    100.0,         // margin amount
//   //    "ADD"          // type: "ADD" or "SUB"
//   // );
//   // Print("ChangeMargin: ", s);
//
//
//   //--- 3.20 FUTURES: GET OPEN POSITIONS ----------------------------
//   Print("=== FUTURES: Get Open Positions ===");
//   s = FuturesGetOpenPositions("BTC_USDT");  // empty for all
//   Print("OpenPositions: ", s);
//
//   // Parse positions
//   jv.Deserialize(s);
//   if(jv.HasKey("data")) {
//      for(int i = 0; i < jv["data"].Size(); i++) {
//         Print("  Symbol: ",       jv["data"][i]["symbol"].ToStr());
//         Print("  PositionId: ",   jv["data"][i]["positionId"].ToStr());
//         Print("  Side (holdSide): ", jv["data"][i]["holdSide"].ToStr());
//         Print("  Volume: ",       jv["data"][i]["holdVol"].ToStr());
//         Print("  OpenAvgPrice: ", jv["data"][i]["openAvgPrice"].ToStr());
//         Print("  Leverage: ",     jv["data"][i]["leverage"].ToStr());
//         Print("  UnrealizedPnL: ", jv["data"][i]["unrealised"].ToStr());
//         Print("  LiqPrice: ",     jv["data"][i]["liquidatePrice"].ToStr());
//         Print("  ---");
//      }
//   }
//
//   // Backward-compatible:
//   // s = getPosition("BTC_USDT", "");
//
//
//   //=================================================================
//   //  FUTURES TRIGGER ORDERS (Plan Orders)
//   //=================================================================
//
//   //--- 3.21 PLACE TRIGGER ORDER ------------------------------------
//   //    POST /api/v1/private/planorder/place
//   //    Order activates when price hits triggerPrice
//   Print("=== FUTURES: Place Trigger Order ===");
//   s = FuturesPlaceTriggerOrder(
//      "BTC_USDT",    // symbol
//      50000.0,       // price (execution price, 0 for market)
//      1,             // vol (quantity)
//      1,             // side: 1=Open Long
//      1,             // type: 1=Limit
//      1,             // openType: 1=Isolated
//      10,            // leverage
//      49500.0,       // triggerPrice
//      2,             // triggerType: 1= >= trigger, 2= <= trigger
//      1,             // executeCycle: 1=24h, 2=7days
//      1              // trend: 1=Latest, 2=Fair, 3=Index
//   );
//   Print("PlaceTriggerOrder: ", s);
//
//
//   //--- 3.22 GET OPEN TRIGGER ORDERS --------------------------------
//   //    GET /api/v1/private/planorder/list/orders
//   Print("=== FUTURES: Get Open Trigger Orders ===");
//   s = FuturesGetOpenTriggerOrders(
//      "BTC_USDT",    // symbol
//      1,             // pageNum
//      20             // pageSize
//   );
//   Print("OpenTriggerOrders: ", s);
//
//
//   //--- 3.23 GET ALL TRIGGER ORDERS (History) -----------------------
//   Print("=== FUTURES: Get All Trigger Orders ===");
//   s = FuturesGetAllTriggerOrders(
//      "BTC_USDT",    // symbol
//      "",            // states filter
//      1,             // pageNum
//      20,            // pageSize
//      "",            // startTime
//      ""             // endTime
//   );
//   Print("AllTriggerOrders: ", s);
//
//
//   //--- 3.24 CANCEL TRIGGER ORDER -----------------------------------
//   //    POST /api/v1/private/planorder/cancel
//   // s = FuturesCancelTriggerOrder("123456789");  // order ID(s)
//   // Print("CancelTriggerOrder: ", s);
//
//
//   //--- 3.25 CANCEL ALL TRIGGER ORDERS FOR SYMBOL -------------------
//   //    POST /api/v1/private/planorder/cancel_all
//   // s = FuturesCancelAllTriggerOrders("BTC_USDT");
//   // Print("CancelAllTriggerOrders: ", s);
//
//
//   //=================================================================
//   //  FUTURES STOP-LIMIT ORDERS (TP/SL by Position)
//   //=================================================================
//
//   //--- 3.26 PLACE STOP-LIMIT ORDER (TP/SL) -------------------------
//   //    POST /api/v1/private/stoporder/place
//   //    Requires an open position's positionId
//   // s = FuturesPlaceStopLimitOrder(
//   //    12345678,     // positionId
//   //    1,            // vol (quantity)
//   //    49000.0,      // stopLossPrice
//   //    55000.0,      // takeProfitPrice
//   //    1,            // lossTrend: 1=Latest, 2=Fair, 3=Index
//   //    1,            // profitTrend: 1=Latest, 2=Fair, 3=Index
//   //    0,            // stopLossType: 0=Market, 1=Limit
//   //    0,            // stopLossOrderPrice (only if limit SL)
//   //    0,            // takeProfitType: 0=Market, 1=Limit
//   //    0             // takeProfitOrderPrice (only if limit TP)
//   // );
//   // Print("PlaceStopLimitOrder: ", s);
//
//
//   //--- 3.27 GET OPEN STOP-LIMIT ORDERS -----------------------------
//   //    GET /api/v1/private/stoporder/list/orders (is_finished=0)
//   Print("=== FUTURES: Get Open Stop-Limit Orders ===");
//   s = FuturesGetOpenStopLimitOrders(
//      "BTC_USDT",    // symbol
//      1,             // pageNum
//      20             // pageSize
//   );
//   Print("OpenStopLimitOrders: ", s);
//
//
//   //--- 3.28 GET ALL STOP-LIMIT ORDERS (History) --------------------
//   //    GET /api/v1/private/stoporder/list/orders (is_finished=1)
//   Print("=== FUTURES: Get All Stop-Limit Orders ===");
//   s = FuturesGetAllStopLimitOrders(
//      "BTC_USDT",    // symbol
//      1,             // pageNum
//      20,            // pageSize
//      "",            // startTime
//      ""             // endTime
//   );
//   Print("AllStopLimitOrders: ", s);
//
//
//   //--- 3.29 CANCEL STOP-LIMIT ORDER --------------------------------
//   //    POST /api/v1/private/stoporder/cancel
//   // s = FuturesCancelStopLimitOrder("123456789");
//   // Print("CancelStopLimitOrder: ", s);
//
//
//   //--- 3.30 CANCEL ALL STOP-LIMIT ORDERS ----------------------------
//   //    POST /api/v1/private/stoporder/cancel_all
//   // s = FuturesCancelAllStopLimitOrders("BTC_USDT");
//   // Print("CancelAllStopLimitOrders: ", s);
//
//
//   //=================================================================
//   //  CHART / SYMBOL MANAGEMENT
//   //=================================================================
//
//   //--- 4.1 CREATE SYMBOLS FROM EXCHANGE INFO -----------------------
//   //    Run ONCE to create custom symbols in MetaTrader
//   // CreateSymbols_MEXC();
//
//
//   //--- 4.2 DOWNLOAD HISTORY DATA -----------------------------------
//   //    Updates all symbols with prefix matching MEXC_SymbolPrefix
//   // string syms = RemovePrefixFromSymbol();
//   // if(syms != NULL)
//   //    RunUpdate(syms, MaxDate);
//
//
//   Print("=== ALL EXAMPLES COMPLETE ===");
}


//+------------------------------------------------------------------+
//| Helper: Remove symbol prefix to get raw exchange symbol          |
//+------------------------------------------------------------------+
string RemovePrefixFromSymbol() {
   sym = _Symbol;
   string prefix = MEXC_SymbolPrefix;
   int length = StringLen(prefix);
   string resultString;

   if(StringSubstr(sym, 0, length) == prefix) {
      resultString = StringSubstr(sym, length);
      return resultString;
   }

   return NULL;
}
//+------------------------------------------------------------------+