Upload 25 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+SUM3API[[:space:]](local)/MQL5/Libraries/libsodium.dll filter=lfs diff=lfs merge=lfs -text
+SUM3API[[:space:]](local)/MQL5/Libraries/libzmq.dll filter=lfs diff=lfs merge=lfs -text

SUM3API (local)/MQL5/Experts/ZmqPublisher.mq5

@@ -0,0 +1,450 @@
+//+------------------------------------------------------------------+
+//|                                                 ZmqPublisher.mq5 |
+//|                                    Copyright 2024, Antigravity   |
+//|                                                                  |
+//+------------------------------------------------------------------+
+#property copyright "Antigravity"
+#property link      ""
+#property version   "2.00"
+
+// Include our ZMQ wrapper
+#include <Zmq/Zmq.mqh>
+
+// Include trading functions
+#include <Trade/Trade.mqh>
+
+// Input parameters
+input string InpPubAddress = "tcp://0.0.0.0:5555"; // Tick Publisher Address
+input string InpRepAddress = "tcp://0.0.0.0:5556"; // Order Handler Address
+input double InpDefaultSlippage = 10;              // Default Slippage (points)
+
+CZmq *g_publisher;  // PUB socket for tick data
+CZmq *g_responder;  // REP socket for order handling
+CTrade g_trade;     // Trading helper
+
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+  {
+   Print("Initializing ZmqPublisher v2.0 with Order Support...");
+   
+   // Initialize tick publisher (PUB socket)
+   g_publisher = new CZmq();
+   if(!g_publisher.Init(ZMQ_PUB)) {
+      Print("Failed to initialize ZMQ Publisher");
+      return(INIT_FAILED);
+   }
+   if(!g_publisher.Bind(InpPubAddress)) {
+      Print("Failed to bind publisher to ", InpPubAddress);
+      return(INIT_FAILED);
+   }
+   Print("Tick Publisher bound to ", InpPubAddress);
+   
+   // Initialize order responder (REP socket)
+   g_responder = new CZmq();
+   if(!g_responder.Init(ZMQ_REP)) {
+      Print("Failed to initialize ZMQ Responder");
+      return(INIT_FAILED);
+   }
+   if(!g_responder.Bind(InpRepAddress)) {
+      Print("Failed to bind responder to ", InpRepAddress);
+      return(INIT_FAILED);
+   }
+   Print("Order Responder bound to ", InpRepAddress);
+   
+   // Configure trade settings
+   g_trade.SetDeviationInPoints((ulong)InpDefaultSlippage);
+   g_trade.SetTypeFilling(ORDER_FILLING_IOC);
+   
+   return(INIT_SUCCEEDED);
+  }
+
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+   Print("Deinitializing ZmqPublisher...");
+   if(g_publisher != NULL) {
+      g_publisher.Shutdown();
+      delete g_publisher;
+      g_publisher = NULL;
+   }
+   if(g_responder != NULL) {
+      g_responder.Shutdown();
+      delete g_responder;
+      g_responder = NULL;
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Process incoming order request                                   |
+//+------------------------------------------------------------------+
+//+------------------------------------------------------------------+
+//| Process incoming order request                                   |
+//+------------------------------------------------------------------+
+string ProcessOrderRequest(string request)
+  {
+   // Expected JSON format:
+   // {"type":"market_buy"|"close_position"|"cancel_order"|..., 
+   //  "symbol":"XAUUSDc", "volume":0.01, "price":2000.0, "ticket":12345}
+   
+   string orderType = ExtractJsonString(request, "type");
+   string symbol = ExtractJsonString(request, "symbol");
+   double volume = ExtractJsonDouble(request, "volume");
+   double price = ExtractJsonDouble(request, "price");
+   ulong ticket = (ulong)ExtractJsonDouble(request, "ticket"); // Simple extraction
+   
+   if(symbol == "") symbol = _Symbol;
+   if(volume <= 0) volume = 0.01;
+   
+   Print("Order request: type=", orderType, " symbol=", symbol, " vol=", volume, " price=", price, " ticket=", ticket);
+   
+   bool success = false;
+   ulong resultTicket = 0;
+   string errorMsg = "";
+   
+   // Execute order based on type
+   if(orderType == "market_buy") {
+      double askPrice = SymbolInfoDouble(symbol, SYMBOL_ASK);
+      success = g_trade.Buy(volume, symbol, askPrice, 0, 0, "Rust GUI Order");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "market_sell") {
+      double bidPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
+      success = g_trade.Sell(volume, symbol, bidPrice, 0, 0, "Rust GUI Order");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "limit_buy") {
+      success = g_trade.BuyLimit(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Limit");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "limit_sell") {
+      success = g_trade.SellLimit(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Limit");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "stop_buy") {
+      success = g_trade.BuyStop(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Stop");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "stop_sell") {
+      success = g_trade.SellStop(volume, price, symbol, 0, 0, ORDER_TIME_GTC, 0, "Rust GUI Stop");
+      if(success) resultTicket = g_trade.ResultOrder();
+      else errorMsg = GetLastErrorDescription();
+   }
+   else if(orderType == "close_position") {
+      if(ticket > 0) {
+         success = g_trade.PositionClose(ticket);
+         if(success) errorMsg = "Position closed";
+         else errorMsg = GetLastErrorDescription();
+      } else {
+         errorMsg = "Invalid ticket for close_position";
+      }
+   }
+   else if(orderType == "cancel_order") {
+      if(ticket > 0) {
+         success = g_trade.OrderDelete(ticket);
+         if(success) errorMsg = "Order deleted";
+         else errorMsg = GetLastErrorDescription();
+      } else {
+         errorMsg = "Invalid ticket for cancel_order";
+      }
+   }
+   else if(orderType == "download_history") {
+       // Format: {type: "download_history", symbol: "XAUUSD", timeframe: "M1", start: "2024.01.01", end: "2024.01.02", mode: "OHLC"|"TICKS"}
+       string tfStr = ExtractJsonString(request, "timeframe");
+       string startStr = ExtractJsonString(request, "start");
+       string endStr = ExtractJsonString(request, "end");
+       string mode = ExtractJsonString(request, "mode");
+       
+       if(mode == "") mode = "OHLC";
+       
+       success = DownloadHistory(symbol, tfStr, startStr, endStr, mode, errorMsg);
+   }
+   else {
+      errorMsg = "Unknown order type: " + orderType;
+   }
+   
+   // Build response JSON
+   string response;
+   if(success) {
+      if(orderType == "download_history") {
+          // ensure errorMsg contains the filename if success
+          StringConcatenate(response, "{\"success\":true,\"message\":\"", errorMsg, "\"}");
+      } else {
+          StringConcatenate(response, "{\"success\":true,\"ticket\":", IntegerToString(resultTicket), "}");
+      }
+   } else {
+      StringConcatenate(response, "{\"success\":false,\"error\":\"", errorMsg, "\"}");
+   }
+   
+   return response;
+  }
+
+//+------------------------------------------------------------------+
+//| Download History - Returns CSV content via ZMQ                   |
+//+------------------------------------------------------------------+
+bool DownloadHistory(string symbol, string tfStr, string startStr, string endStr, string mode, string &resultMsg)
+  {
+   datetime start = StringToTime(startStr);
+   datetime end = StringToTime(endStr);
+   if(start == 0) start = D'2024.01.01 00:00'; // Default fallback
+   if(end == 0) end = TimeCurrent();
+   
+   ENUM_TIMEFRAMES tf = PERIOD_M1;
+   if(tfStr == "M5") tf = PERIOD_M5;
+   else if(tfStr == "M15") tf = PERIOD_M15;
+   else if(tfStr == "H1") tf = PERIOD_H1;
+   else if(tfStr == "H4") tf = PERIOD_H4;
+   else if(tfStr == "D1") tf = PERIOD_D1;
+   
+   string csvContent = "";
+   int count = 0;
+   
+   // Use |NL| as line separator (JSON-safe, Rust will convert to real newlines)
+   string NL = "|NL|";
+   
+   if(mode == "TICKS") {
+      MqlTick ticks[];
+      int received = CopyTicksRange(symbol, ticks, COPY_TICKS_ALL, start * 1000, end * 1000);
+      
+      if(received > 0) {
+         csvContent = "Time,Bid,Ask,Volume" + NL;
+         for(int i=0; i<received && i<50000; i++) {  // Limit to 50k rows
+            csvContent += TimeToString(ticks[i].time, TIME_DATE|TIME_SECONDS) + "," +
+                         DoubleToString(ticks[i].bid, _Digits) + "," +
+                         DoubleToString(ticks[i].ask, _Digits) + "," +
+                         IntegerToString(ticks[i].volume) + NL;
+         }
+         count = MathMin(received, 50000);
+      }
+   } 
+   else {
+      // OHLC
+      MqlRates rates[];
+      ArraySetAsSeries(rates, false);
+      int received = CopyRates(symbol, tf, start, end, rates);
+      
+      if(received > 0) {
+         csvContent = "Time,Open,High,Low,Close,TickVol,Spread" + NL;
+         for(int i=0; i<received && i<100000; i++) {  // Limit to 100k rows
+            csvContent += TimeToString(rates[i].time, TIME_DATE|TIME_MINUTES) + "," +
+                         DoubleToString(rates[i].open, _Digits) + "," +
+                         DoubleToString(rates[i].high, _Digits) + "," +
+                         DoubleToString(rates[i].low, _Digits) + "," +
+                         DoubleToString(rates[i].close, _Digits) + "," +
+                         IntegerToString(rates[i].tick_volume) + "," +
+                         IntegerToString(rates[i].spread) + NL;
+         }
+         count = MathMin(received, 100000);
+      }
+   }
+   
+   if(count > 0) {
+      // Return CSV content in a special format that Rust can parse
+      // We use ||CSV_DATA|| as delimiter to separate count info from actual data
+      resultMsg = IntegerToString(count) + " records||CSV_DATA||" + csvContent;
+      return true;
+   } else {
+      resultMsg = "No data found for period";
+      return false;
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Extract string value from JSON                                   |
+//+------------------------------------------------------------------+
+string ExtractJsonString(string json, string key)
+  {
+   string searchKey = "\"" + key + "\":\"";
+   int startPos = StringFind(json, searchKey);
+   if(startPos < 0) return "";
+   
+   startPos += StringLen(searchKey);
+   int endPos = StringFind(json, "\"", startPos);
+   if(endPos < 0) return "";
+   
+   return StringSubstr(json, startPos, endPos - startPos);
+  }
+
+//+------------------------------------------------------------------+
+//| Extract double value from JSON                                   |
+//+------------------------------------------------------------------+
+double ExtractJsonDouble(string json, string key)
+  {
+   string searchKey = "\"" + key + "\":";
+   int startPos = StringFind(json, searchKey);
+   if(startPos < 0) return 0.0;
+   
+   startPos += StringLen(searchKey);
+   
+   // Find end of number (comma, }, or end of string)
+   int endPos = startPos;
+   int len = StringLen(json);
+   while(endPos < len) {
+      ushort ch = StringGetCharacter(json, endPos);
+      if(ch == ',' || ch == '}' || ch == ' ') break;
+      endPos++;
+   }
+   
+   string valueStr = StringSubstr(json, startPos, endPos - startPos);
+   return StringToDouble(valueStr);
+  }
+
+//+------------------------------------------------------------------+
+//| Get human-readable error description                             |
+//+------------------------------------------------------------------+
+string GetLastErrorDescription()
+  {
+   int err = GetLastError();
+   return "Error " + IntegerToString(err) + ": " + ErrorDescription(err);
+  }
+
+//+------------------------------------------------------------------+
+//| Error description helper                                         |
+//+------------------------------------------------------------------+
+string ErrorDescription(int error)
+  {
+   switch(error) {
+      case 0: return "No error";
+      case 10004: return "Requote";
+      case 10006: return "Request rejected";
+      case 10007: return "Request canceled by trader";
+      case 10010: return "Request rejected - only part of the request was fulfilled";
+      case 10011: return "Request error";
+      case 10012: return "Request canceled due to timeout";
+      case 10013: return "Invalid request";
+      case 10014: return "Invalid volume";
+      case 10015: return "Invalid price";
+      case 10016: return "Invalid stops";
+      case 10017: return "Trade disabled";
+      case 10018: return "Market is closed";
+      case 10019: return "Not enough money";
+      case 10020: return "Prices changed";
+      case 10021: return "No quotes to process request";
+      case 10022: return "Invalid order expiration date";
+      case 10023: return "Order state changed";
+      case 10024: return "Too many requests";
+      case 10025: return "No changes in request";
+      case 10026: return "Autotrading disabled by server";
+      case 10027: return "Autotrading disabled by client terminal";
+      case 10028: return "Request locked for processing";
+      case 10029: return "Long positions only allowed";
+      case 10030: return "Maximum position volume exceeded";
+      default: return "Unknown error";
+   }
+  }
+
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+  {
+   // Handle order requests (non-blocking)
+   if(g_responder != NULL) {
+      string request = g_responder.Receive(true);
+      if(request != "") {
+         Print("Received order request: ", request);
+         string response = ProcessOrderRequest(request);
+         g_responder.Send(response, false);  // Blocking send for REP pattern
+         Print("Sent response: ", response);
+      }
+   }
+   
+   // Publish tick data with account info
+   if(g_publisher == NULL) return;
+   
+   MqlTick tick;
+   if(SymbolInfoTick(_Symbol, tick)) {
+      // Get account info
+      double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+      double equity = AccountInfoDouble(ACCOUNT_EQUITY);
+      double margin = AccountInfoDouble(ACCOUNT_MARGIN);
+      double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+      
+      // Get symbol trading constraints
+      double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
+      double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
+      double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
+      
+      // Get Active Positions (Only for current symbol to simplify)
+      string positionsJson = "[";
+      int posCount = PositionsTotal();
+      bool firstPos = true;
+      for(int i = 0; i < posCount; i++) {
+         ulong ticket = PositionGetTicket(i);
+         if(PositionSelectByTicket(ticket)) {
+            if(PositionGetString(POSITION_SYMBOL) == _Symbol) {
+               if(!firstPos) StringAdd(positionsJson, ",");
+               
+               string posType = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ? "BUY" : "SELL";
+               StringAdd(positionsJson, "{\"ticket\":" + IntegerToString(ticket) + 
+                         ",\"type\":\"" + posType + "\"" +
+                         ",\"volume\":" + DoubleToString(PositionGetDouble(POSITION_VOLUME), 2) +
+                         ",\"price\":" + DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN), _Digits) +
+                         ",\"profit\":" + DoubleToString(PositionGetDouble(POSITION_PROFIT), 2) + 
+                         "}");
+               firstPos = false;
+            }
+         }
+      }
+      StringAdd(positionsJson, "]");
+      
+      // Get Pending Orders (Only for current symbol)
+      string ordersJson = "[";
+      int orderCount = OrdersTotal();
+      bool firstOrder = true;
+      for(int i = 0; i < orderCount; i++) {
+         ulong ticket = OrderGetTicket(i);
+         if(OrderSelect(ticket)) {
+            if(OrderGetString(ORDER_SYMBOL) == _Symbol) {
+               if(!firstOrder) StringAdd(ordersJson, ",");
+               
+               ENUM_ORDER_TYPE type = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
+               string orderTypeStr = "UNKNOWN";
+               if(type == ORDER_TYPE_BUY_LIMIT) orderTypeStr = "BUY LIMIT";
+               else if(type == ORDER_TYPE_SELL_LIMIT) orderTypeStr = "SELL LIMIT";
+               else if(type == ORDER_TYPE_BUY_STOP) orderTypeStr = "BUY STOP";
+               else if(type == ORDER_TYPE_SELL_STOP) orderTypeStr = "SELL STOP";
+               
+               StringAdd(ordersJson, "{\"ticket\":" + IntegerToString(ticket) + 
+                         ",\"type\":\"" + orderTypeStr + "\"" +
+                         ",\"volume\":" + DoubleToString(OrderGetDouble(ORDER_VOLUME_INITIAL), 2) +
+                         ",\"price\":" + DoubleToString(OrderGetDouble(ORDER_PRICE_OPEN), _Digits) +
+                         "}");
+               firstOrder = false;
+            }
+         }
+      }
+      StringAdd(ordersJson, "]");
+      
+      // Create JSON with tick data + account info + positions + orders
+      string json;
+      StringConcatenate(json, "{\"symbol\":\"", _Symbol, 
+                        "\",\"bid\":", DoubleToString(tick.bid, _Digits),
+                        ",\"ask\":", DoubleToString(tick.ask, _Digits),
+                        ",\"time\":", IntegerToString(tick.time),
+                        ",\"volume\":", IntegerToString(tick.volume),
+                        ",\"balance\":", DoubleToString(balance, 2),
+                        ",\"equity\":", DoubleToString(equity, 2),
+                        ",\"margin\":", DoubleToString(margin, 2),
+                        ",\"free_margin\":", DoubleToString(freeMargin, 2),
+                        ",\"min_lot\":", DoubleToString(minLot, 2),
+                        ",\"max_lot\":", DoubleToString(maxLot, 2),
+                        ",\"lot_step\":", DoubleToString(lotStep, 2),
+                        ",\"positions\":", positionsJson,
+                        ",\"orders\":", ordersJson,
+                        "}");
+                        
+      g_publisher.Send(json);
+      // Print("Published: ", json); // Uncomment for debugging (spammy)
+   }
+  }
+  
+//+------------------------------------------------------------------+

SUM3API (local)/MQL5/Include/Zmq/Zmq.mqh

@@ -0,0 +1,144 @@
+//+------------------------------------------------------------------+
+//|                                                          Zmq.mqh |
+//|                                    Copyright 2026, Algorembrant  |
+//|                                                                  |
+//+------------------------------------------------------------------+
+#property copyright "Algorembrant"
+#property link      "https://github.com/ContinualQuasars/SUM3API"
+#property version   "2.00"
+#property strict
+
+// Define ZMQ constants
+#define ZMQ_PUB 1
+#define ZMQ_SUB 2
+#define ZMQ_REQ 3
+#define ZMQ_REP 4
+
+#define ZMQ_NOBLOCK 1
+
+// Import functions from libzmq.dll
+// NOTE: Make sure libzmq.dll is in your MQL5/Libraries folder
+// Handles are void* (64-bit on x64), so using 'long' works for both 32 (too big but safe) and 64 bit
+#import "libzmq.dll"
+   long zmq_ctx_new();
+   int zmq_ctx_term(long context);
+   long zmq_socket(long context, int type);
+   int zmq_close(long socket);
+   int zmq_bind(long socket, uchar &endpoint[]);
+   int zmq_connect(long socket, uchar &endpoint[]);
+   int zmq_send(long socket, uchar &buf[], int len, int flags);
+   int zmq_recv(long socket, uchar &buf[], int len, int flags);
+   int zmq_errno();
+#import
+
+class CZmq {
+private:
+   long m_context;
+   long m_socket;
+   bool m_initialized;
+
+public:
+   CZmq() {
+      m_context = 0;
+      m_socket = 0;
+      m_initialized = false;
+   }
+
+   ~CZmq() {
+      Shutdown();
+   }
+
+   bool Init(int type) {
+      if(m_initialized) return true;
+      
+      m_context = zmq_ctx_new();
+      if(m_context == 0) {
+         Print("ZMQ Init failed: Context creation error");
+         return false;
+      }
+      
+      m_socket = zmq_socket(m_context, type);
+      if(m_socket == 0) {
+         Print("ZMQ Init failed: Socket creation error");
+         return false;
+      }
+      
+      m_initialized = true;
+      return true;
+   }
+
+   bool Bind(string endpoint) {
+      if(!m_initialized) return false;
+      
+      uchar data[];
+      StringToCharArray(endpoint, data, 0, WHOLE_ARRAY, CP_UTF8);
+      
+      int rc = zmq_bind(m_socket, data);
+      if(rc != 0) {
+         Print("ZMQ Bind failed. Error: ", zmq_errno());
+         return false;
+      }
+      return true;
+   }
+
+   bool Connect(string endpoint) {
+      if(!m_initialized) return false;
+      
+      uchar data[];
+      StringToCharArray(endpoint, data, 0, WHOLE_ARRAY, CP_UTF8);
+      
+      int rc = zmq_connect(m_socket, data);
+      if(rc != 0) {
+         Print("ZMQ Connect failed. Error: ", zmq_errno());
+         return false;
+      }
+      return true;
+   }
+
+   int Send(string message, bool nonBlocking = true) {
+      if(!m_initialized) return -1;
+      
+      uchar data[];
+      StringToCharArray(message, data, 0, WHOLE_ARRAY, CP_UTF8);
+      // StringToCharArray includes null terminator, we might not want to send it
+      // ZMQ messages are just bytes.
+      // -1 because array size includes null char, usually we check ArraySize(data)
+      int len = ArraySize(data) - 1; 
+      if (len < 0) len = 0;
+
+      int flags = 0;
+      if(nonBlocking) flags = ZMQ_NOBLOCK;
+      
+      int bytesSent = zmq_send(m_socket, data, len, flags);
+      return bytesSent;
+   }
+
+   // Non-blocking receive - returns empty string if no message available
+   string Receive(bool nonBlocking = true) {
+      if(!m_initialized) return "";
+      
+      uchar buffer[4096];
+      ArrayInitialize(buffer, 0);
+      
+      int flags = 0;
+      if(nonBlocking) flags = ZMQ_NOBLOCK;
+      
+      int bytesReceived = zmq_recv(m_socket, buffer, ArraySize(buffer) - 1, flags);
+      
+      if(bytesReceived <= 0) return "";
+      
+      return CharArrayToString(buffer, 0, bytesReceived, CP_UTF8);
+   }
+
+   void Shutdown() {
+      if(m_socket != 0) {
+         zmq_close(m_socket);
+         m_socket = 0;
+      }
+      if(m_context != 0) {
+         zmq_ctx_term(m_context);
+         m_context = 0;
+      }
+      m_initialized = false;
+   }
+};

SUM3API (local)/MQL5/Libraries/libsodium.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7745aad20b9578c70b0fff48b3ee5f982c840e0f17b3dc7239a23d4fb36b0717
+size 302592

SUM3API (local)/MQL5/Libraries/libzmq.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19567709cb7ef4664249d46a796f23c06abbe6ba91db3c650aeaa372b4fbf989
+size 451072

SUM3API (local)/Rustmt5-chart/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "Rustmt5-chart"
+version = "0.1.0"
+edition = "2026"
+
+[dependencies]
+eframe = "0.27.1"
+egui = "0.27.1"
+egui_plot = "0.27.1"
+zeromq = "0.5.0-pre"
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+tokio = { version = "1.36.0", features = ["full"] }
+futures = "0.3.30"
+chrono = "0.4.43"

SUM3API (local)/Rustmt5-chart/src/main.rs

@@ -0,0 +1,852 @@
+//+------------------------------------------------------------------+
+//|                                                          main.rs |
+//|                                    Copyright 2026, Algorembrant  |
+//|                                                                  |
+//+------------------------------------------------------------------+
+//property copyright "Algorembrant"
+//property link      "https://github.com/ContinualQuasars/SUM3API"
+//property version   "2.00"
+//property strict
+
+use eframe::egui;
+use egui_plot::{Line, Plot, PlotPoints};
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::PathBuf;
+
+// ============================================================================
+// Data Structures
+// ============================================================================
+
+#[derive(Clone, Debug, Deserialize)]
+#[allow(dead_code)]
+struct PositionData {
+    ticket: u64,
+    #[serde(rename = "type")]
+    pos_type: String, // "BUY" or "SELL"
+    volume: f64,
+    price: f64,
+    profit: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[allow(dead_code)]
+struct PendingOrderData {
+    ticket: u64,
+    #[serde(rename = "type")]
+    order_type: String, // "BUY LIMIT", "SELL STOP", etc.
+    volume: f64,
+    price: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct TickData {
+    symbol: String,
+    bid: f64,
+    ask: f64,
+    time: i64,
+    #[serde(default)]
+    volume: u64,
+    // Account info
+    #[serde(default)]
+    balance: f64,
+    #[serde(default)]
+    equity: f64,
+    #[serde(default)]
+    margin: f64,
+    #[serde(default)]
+    free_margin: f64,
+    // Trading constraints
+    #[serde(default)]
+    min_lot: f64,
+    #[serde(default)]
+    max_lot: f64,
+    #[serde(default)]
+    lot_step: f64,
+    
+    // Active trades
+    #[serde(default)]
+    positions: Vec<PositionData>,
+    #[serde(default)]
+    orders: Vec<PendingOrderData>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+struct OrderRequest {
+    #[serde(rename = "type")]
+    order_type: String,
+    symbol: String,
+    volume: f64,
+    price: f64,
+    #[serde(default)]
+    ticket: u64, // For close/cancel
+    // History params
+    #[serde(skip_serializing_if = "Option::is_none")]
+    timeframe: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    start: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    end: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    mode: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    request_id: Option<u64>,  // Unique ID for history downloads
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct OrderResponse {
+    success: bool,
+    ticket: Option<i64>,
+    error: Option<String>,
+    message: Option<String>,
+}
+
+// Struct for tracking order execution breaklines on chart
+#[derive(Clone, Debug)]
+struct OrderBreakline {
+    index: usize,        // Data index where order was executed
+    order_type: String,  // "BUY" or "SELL" variant
+    ticket: i64,         // Order ticket number
+}
+
+// ============================================================================
+// Application State
+// ============================================================================
+
+struct Mt5ChartApp {
+    // Tick data
+    tick_receiver: mpsc::Receiver<TickData>,
+    data: Vec<TickData>,
+    symbol: String,
+    
+    // Latest account info
+    balance: f64,
+    equity: f64,
+    margin: f64,
+    free_margin: f64,
+    min_lot: f64,
+    max_lot: f64,
+    lot_step: f64,
+    
+    // Order handling
+    order_sender: mpsc::Sender<OrderRequest>,
+    response_receiver: mpsc::Receiver<OrderResponse>,
+    
+    // UI state for order panel
+    lot_size: f64,
+    lot_size_str: String,
+    limit_price: String,
+    #[allow(dead_code)]
+    stop_price: String,
+    last_order_result: Option<String>,
+    
+    // History Download UI
+    history_start_date: String,
+    history_end_date: String,
+    history_tf: String,
+    history_mode: String,
+    
+    // Live Recording
+    is_recording: bool,
+    live_record_file: Option<std::fs::File>,
+    
+    // Live Trade Data
+    positions: Vec<PositionData>,
+    pending_orders: Vec<PendingOrderData>,
+    
+    // CSV Output Management
+    output_dir: PathBuf,
+    request_counter: u64,
+    
+    // Order Breaklines for Chart
+    order_breaklines: Vec<OrderBreakline>,
+    pending_order_type: Option<String>,  // Track what type of order is pending
+    
+    // Pending history request info for CSV naming
+    pending_history_request: Option<(u64, String, String, String)>, // (id, symbol, tf, mode)
+}
+
+impl Mt5ChartApp {
+    fn new(
+        tick_receiver: mpsc::Receiver<TickData>,
+        order_sender: mpsc::Sender<OrderRequest>,
+        response_receiver: mpsc::Receiver<OrderResponse>,
+    ) -> Self {
+        // Defaults dates to "yyyy.mm.dd"
+        let now = chrono::Local::now();
+        let today_str = now.format("%Y.%m.%d").to_string();
+        
+        // Ensure output directory exists
+        let output_dir = PathBuf::from("output");
+        fs::create_dir_all(&output_dir).ok();
+        
+        Self {
+            tick_receiver,
+            data: Vec::new(),
+            symbol: "Waiting for data...".to_string(),
+            balance: 0.0,
+            equity: 0.0,
+            margin: 0.0,
+            free_margin: 0.0,
+            min_lot: 0.01,
+            max_lot: 100.0,
+            lot_step: 0.01,
+            order_sender,
+            response_receiver,
+            lot_size: 0.01,
+            lot_size_str: "0.01".to_string(),
+            limit_price: "0.0".to_string(),
+            stop_price: "0.0".to_string(),
+            last_order_result: None,
+            
+            history_start_date: today_str.clone(),
+            history_end_date: today_str,
+            history_tf: "M1".to_string(),
+            history_mode: "OHLC".to_string(),
+            
+            is_recording: false,
+            live_record_file: None,
+            
+            positions: Vec::new(),
+            pending_orders: Vec::new(),
+            
+            // Initialize new fields
+            output_dir,
+            request_counter: 0,
+            order_breaklines: Vec::new(),
+            pending_order_type: None,
+            pending_history_request: None,
+        }
+    }
+    
+    fn send_order(&mut self, order_type: &str, price: Option<f64>, ticket: Option<u64>) {
+        let price_val = price.unwrap_or(0.0);
+        let ticket_val = ticket.unwrap_or(0);
+        
+        // Track order type for breakline visualization (only for market orders)
+        if order_type.contains("market") {
+            self.pending_order_type = Some(order_type.to_string());
+        }
+        
+        let request = OrderRequest {
+            order_type: order_type.to_string(),
+            symbol: self.symbol.clone(),
+            volume: self.lot_size,
+            price: price_val,
+            ticket: ticket_val,
+            timeframe: None,
+            start: None,
+            end: None,
+            mode: None,
+            request_id: None,
+        };
+        
+        self.send_request_impl(request);
+    }
+    
+    fn send_download_request(&mut self) {
+        // Increment counter for unique history download ID
+        self.request_counter += 1;
+        
+        // Store request info for CSV filename generation when response arrives
+        self.pending_history_request = Some((
+            self.request_counter,
+            self.symbol.replace("/", "-"),
+            self.history_tf.clone(),
+            self.history_mode.clone(),
+        ));
+        
+        let request = OrderRequest {
+            order_type: "download_history".to_string(),
+            symbol: self.symbol.clone(),
+            volume: 0.0,
+            price: 0.0,
+            ticket: 0,
+            timeframe: Some(self.history_tf.clone()),
+            start: Some(self.history_start_date.clone()),
+            end: Some(self.history_end_date.clone()),
+            mode: Some(self.history_mode.clone()),
+            request_id: Some(self.request_counter),
+        };
+        
+        self.send_request_impl(request);
+    }
+    
+    fn send_request_impl(&mut self, request: OrderRequest) {
+        if let Err(e) = self.order_sender.try_send(request) {
+            self.last_order_result = Some(format!("Failed to send: {}", e));
+        } else {
+            self.last_order_result = Some("Request sent...".to_string());
+        }
+    }
+    
+    fn adjust_lot_size(&mut self, delta: f64) {
+        let new_lot = self.lot_size + delta;
+        // Round to lot_step
+        let steps = (new_lot / self.lot_step).round();
+        self.lot_size = (steps * self.lot_step).max(self.min_lot).min(self.max_lot);
+        self.lot_size_str = format!("{:.2}", self.lot_size);
+    }
+    
+    fn toggle_recording(&mut self) {
+        self.is_recording = !self.is_recording;
+        if self.is_recording {
+            // Increment counter for unique ID
+            self.request_counter += 1;
+            let filename = format!(
+                "{}/Live_{}_ID{:04}_{}.csv",
+                self.output_dir.display(),
+                self.symbol.replace("/", "-"),
+                self.request_counter,
+                chrono::Local::now().format("%Y%m%d_%H%M%S")
+            );
+            match OpenOptions::new().create(true).append(true).open(&filename) {
+                Ok(mut file) => {
+                    let _ = writeln!(file, "Time,Bid,Ask,Volume");
+                    self.live_record_file = Some(file);
+                    self.last_order_result = Some(format!("Recording to {}", filename));
+                }
+                Err(e) => {
+                    self.is_recording = false;
+                    self.last_order_result = Some(format!("Rec Error: {}", e));
+                }
+            }
+        } else {
+            self.live_record_file = None;
+            self.last_order_result = Some("Recording Stopped".to_string());
+        }
+    }
+}
+
+impl eframe::App for Mt5ChartApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        // Receive all available tick data from the channel without blocking
+        while let Ok(tick) = self.tick_receiver.try_recv() {
+            self.symbol = tick.symbol.clone();
+            
+            // Record if active
+            if self.is_recording {
+                if let Some(mut file) = self.live_record_file.as_ref() {
+                     let _ = writeln!(file, "{},{},{},{}", tick.time, tick.bid, tick.ask, tick.volume);
+                }
+            }
+            
+            // Update account info from latest tick
+            if tick.balance > 0.0 {
+                self.balance = tick.balance;
+                self.equity = tick.equity;
+                self.margin = tick.margin;
+                self.free_margin = tick.free_margin;
+                self.min_lot = tick.min_lot;
+                self.max_lot = tick.max_lot;
+                if tick.lot_step > 0.0 {
+                    self.lot_step = tick.lot_step;
+                }
+            }
+            
+            // Update active trades
+            self.positions = tick.positions.clone();
+            self.pending_orders = tick.orders.clone();
+            
+            self.data.push(tick);
+            // Keep only last 2000 points
+            if self.data.len() > 2000 {
+                self.data.remove(0);
+            }
+        }
+        
+        // Check for order responses
+        while let Ok(response) = self.response_receiver.try_recv() {
+            if response.success {
+                // Check if this is a history download with CSV data
+                if let Some(ref msg) = response.message {
+                    if msg.contains("||CSV_DATA||") {
+                        // Parse CSV data from response
+                        let parts: Vec<&str> = msg.splitn(2, "||CSV_DATA||").collect();
+                        if parts.len() == 2 {
+                            let info_part = parts[0];
+                            let csv_content = parts[1];
+                            
+                            // Generate filename using pending request info
+                            if let Some((id, symbol, tf, mode)) = self.pending_history_request.take() {
+                                let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S");
+                                let filename = format!(
+                                    "{}/History_{}_{}_{}_ID{:04}_{}.csv",
+                                    self.output_dir.display(),
+                                    symbol, tf, mode, id, timestamp
+                                );
+                                
+                                // Convert |NL| placeholders back to real newlines
+                                let csv_with_newlines = csv_content.replace("|NL|", "\n");
+                                
+                                // Save CSV to output folder
+                                match std::fs::write(&filename, csv_with_newlines) {
+                                    Ok(_) => {
+                                        self.last_order_result = Some(format!(
+                                            "✓ {} → Saved to {}",
+                                            info_part, filename
+                                        ));
+                                    }
+                                    Err(e) => {
+                                        self.last_order_result = Some(format!(
+                                            "✗ Failed to save CSV: {}",
+                                            e
+                                        ));
+                                    }
+                                }
+                            } else {
+                                self.last_order_result = Some(format!("✓ {}", info_part));
+                            }
+                        } else {
+                            self.last_order_result = Some(format!("✓ {}", msg));
+                        }
+                    } else {
+                        self.last_order_result = Some(format!("✓ {}", msg));
+                    }
+                } else {
+                    // Add breakline for successful market orders
+                    if let Some(ref order_type) = self.pending_order_type.take() {
+                        let breakline = OrderBreakline {
+                            index: self.data.len().saturating_sub(1),
+                            order_type: order_type.clone(),
+                            ticket: response.ticket.unwrap_or(0),
+                        };
+                        self.order_breaklines.push(breakline);
+                        // Keep only last 50 breaklines
+                        if self.order_breaklines.len() > 50 {
+                            self.order_breaklines.remove(0);
+                        }
+                    }
+                    
+                    self.last_order_result = Some(format!(
+                        "✓ Order executed! Ticket: {}",
+                        response.ticket.unwrap_or(0)
+                    ));
+                }
+            } else {
+                self.pending_order_type = None; // Clear pending on failure
+                self.pending_history_request = None; // Clear pending history request
+                self.last_order_result = Some(format!(
+                    "✗ Failed: {}",
+                    response.error.unwrap_or_else(|| "Unknown error".to_string())
+                ));
+            }
+        }
+
+        // ====================================================================
+        // Side Panel - Trading Controls
+        // ====================================================================
+        egui::SidePanel::left("trading_panel")
+            .min_width(280.0) // Widen slightly
+            .show(ctx, |ui| {
+                ui.heading("📊 Trading Panel");
+                ui.separator();
+                
+                // Account Info
+                ui.collapsing("💰 Account Info", |ui| {
+                    egui::Grid::new("account_grid")
+                        .num_columns(2)
+                        .spacing([10.0, 4.0])
+                        .show(ui, |ui| {
+                            ui.label("Balance:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 200, 100), format!("${:.2}", self.balance));
+                            ui.end_row();
+                            ui.label("Equity:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 180, 255), format!("${:.2}", self.equity));
+                            ui.end_row();
+                            ui.label("Margin Used:");
+                            ui.colored_label(egui::Color32::from_rgb(255, 200, 100), format!("${:.2}", self.margin));
+                            ui.end_row();
+                            ui.label("Free Margin:");
+                            ui.colored_label(egui::Color32::from_rgb(100, 255, 200), format!("${:.2}", self.free_margin));
+                            ui.end_row();
+                        });
+                });
+                
+                ui.separator();
+                
+                // Historical Data Section
+                ui.heading("📂 Historical Data");
+                ui.add_space(5.0);
+                
+                egui::Grid::new("history_grid").num_columns(2).spacing([10.0, 5.0]).show(ui, |ui| {
+                    ui.label("Start (yyyy.mm.dd):");
+                    ui.add(egui::TextEdit::singleline(&mut self.history_start_date).desired_width(100.0));
+                    ui.end_row();
+                    
+                    ui.label("End (yyyy.mm.dd):");
+                    ui.add(egui::TextEdit::singleline(&mut self.history_end_date).desired_width(100.0));
+                    ui.end_row();
+                    
+                    ui.label("Timeframe:");
+                    egui::ComboBox::from_id_source("tf_combo")
+                        .selected_text(&self.history_tf)
+                        .show_ui(ui, |ui| {
+                            ui.selectable_value(&mut self.history_tf, "M1".to_string(), "M1");
+                            ui.selectable_value(&mut self.history_tf, "M5".to_string(), "M5");
+                            ui.selectable_value(&mut self.history_tf, "M15".to_string(), "M15");
+                            ui.selectable_value(&mut self.history_tf, "H1".to_string(), "H1");
+                            ui.selectable_value(&mut self.history_tf, "D1".to_string(), "D1");
+                        });
+                    ui.end_row();
+                    
+                    ui.label("Mode:");
+                    egui::ComboBox::from_id_source("mode_combo")
+                        .selected_text(&self.history_mode)
+                        .show_ui(ui, |ui| {
+                             ui.selectable_value(&mut self.history_mode, "OHLC".to_string(), "OHLC");
+                             ui.selectable_value(&mut self.history_mode, "TICKS".to_string(), "TICKS");
+                        });
+                    ui.end_row();
+                });
+                
+                ui.add_space(5.0);
+                if ui.button("⬇ Download History (CSV)").clicked() {
+                    self.send_download_request();
+                }
+                
+                ui.separator();
+                
+                // Live Recording
+                ui.heading("🔴 Live Recording");
+                ui.horizontal(|ui| {
+                   ui.label(if self.is_recording { "Recording..." } else { "Idle" });
+                   if ui.button(if self.is_recording { "Stop" } else { "Start Recording" }).clicked() {
+                       self.toggle_recording();
+                   }
+                });
+                
+                ui.separator();
+
+                // Order Controls
+                ui.heading("📦 Trade Controls");
+                
+                // Lot Size
+                ui.horizontal(|ui| {
+                    if ui.button("−").clicked() { self.adjust_lot_size(-self.lot_step); }
+                    let response = ui.add(egui::TextEdit::singleline(&mut self.lot_size_str).desired_width(60.0));
+                    if response.lost_focus() {
+                        if let Ok(parsed) = self.lot_size_str.parse::<f64>() {
+                            self.lot_size = parsed.max(self.min_lot).min(self.max_lot);
+                            self.lot_size_str = format!("{:.2}", self.lot_size);
+                        }
+                    }
+                    if ui.button("+").clicked() { self.adjust_lot_size(self.lot_step); }
+                    
+                    ui.label(format!("Lots (Max: {:.1})", self.max_lot));
+                });
+                
+                ui.add_space(5.0);
+                ui.label("Market Orders:");
+                ui.horizontal(|ui| {
+                    if ui.button("BUY").clicked() { self.send_order("market_buy", None, None); }
+                    if ui.button("SELL").clicked() { self.send_order("market_sell", None, None); }
+                });
+                
+                ui.add_space(5.0);
+                ui.label("Pending Orders:");
+                 ui.horizontal(|ui| {
+                    ui.label("@ Price:");
+                    ui.add(egui::TextEdit::singleline(&mut self.limit_price).desired_width(70.0));
+                });
+                ui.horizontal(|ui| {
+                    let p = self.limit_price.parse().unwrap_or(0.0);
+                    if ui.small_button("Buy Limit").clicked() { self.send_order("limit_buy", Some(p), None); }
+                    if ui.small_button("Sell Limit").clicked() { self.send_order("limit_sell", Some(p), None); }
+                    if ui.small_button("Buy Stop").clicked() { self.send_order("stop_buy", Some(p), None); }
+                    if ui.small_button("Sell Stop").clicked() { self.send_order("stop_sell", Some(p), None); }
+                });
+
+                ui.separator();
+
+                // Order result feedback
+                if let Some(ref result) = self.last_order_result {
+                    ui.heading("📨 Last Message");
+                    ui.label(result); // Allow wrapping
+                }
+                
+                ui.separator();
+                
+                // Active Positions - Close Management
+                ui.collapsing("💼 Active Positions", |ui| {
+                    if self.positions.is_empty() {
+                        ui.label("No active positions");
+                    } else {
+                        let positions_clone = self.positions.clone();
+                        for pos in positions_clone {
+                            ui.horizontal(|ui| {
+                                let color = if pos.pos_type == "BUY" {
+                                    egui::Color32::from_rgb(100, 200, 100)
+                                } else {
+                                    egui::Color32::from_rgb(255, 100, 100)
+                                };
+                                ui.colored_label(color, format!(
+                                    "#{} {} {:.2}@{:.5} P:{:.2}",
+                                    pos.ticket, pos.pos_type, pos.volume, pos.price, pos.profit
+                                ));
+                                if ui.small_button("Close").clicked() {
+                                    self.send_order("close_position", Some(pos.price), Some(pos.ticket));
+                                }
+                            });
+                        }
+                    }
+                });
+                
+                // Pending Orders - Cancel Management
+                ui.collapsing("⏳ Pending Orders", |ui| {
+                    if self.pending_orders.is_empty() {
+                        ui.label("No pending orders");
+                    } else {
+                        let orders_clone = self.pending_orders.clone();
+                        for order in orders_clone {
+                            ui.horizontal(|ui| {
+                                let color = if order.order_type.contains("BUY") {
+                                    egui::Color32::from_rgb(100, 150, 255)
+                                } else {
+                                    egui::Color32::from_rgb(255, 150, 100)
+                                };
+                                ui.colored_label(color, format!(
+                                    "#{} {} {:.2}@{:.5}",
+                                    order.ticket, order.order_type, order.volume, order.price
+                                ));
+                                if ui.small_button("Cancel").clicked() {
+                                    self.send_order("cancel_order", Some(order.price), Some(order.ticket));
+                                }
+                            });
+                        }
+                    }
+                });
+            });
+
+        // ====================================================================
+        // Central Panel - Chart
+        // ====================================================================
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading(format!("📈 {}", self.symbol));
+            
+            // Header Info
+            if let Some(last_tick) = self.data.last() {
+                ui.horizontal(|ui| {
+                    ui.label(format!("{:.5} / {:.5}", last_tick.bid, last_tick.ask));
+                });
+            }
+            
+            ui.separator();
+
+            // Price chart - Index-based X Axis
+            let time_map: Vec<i64> = self.data.iter().map(|t| t.time).collect();
+            
+            let plot = Plot::new("mt5_price_plot")
+                .legend(egui_plot::Legend::default())
+                .allow_boxed_zoom(true)
+                .allow_drag(true)
+                .allow_scroll(true)
+                .allow_zoom(true)
+                .x_axis_formatter(move |x, _range, _width| {
+                    let idx = x.value.round() as isize;
+                    if idx >= 0 && (idx as usize) < time_map.len() {
+                        let timestamp = time_map[idx as usize];
+                        let seconds = timestamp % 60;
+                        let minutes = (timestamp / 60) % 60;
+                        let hours = (timestamp / 3600) % 24;
+                        return format!("{:02}:{:02}:{:02}", hours, minutes, seconds);
+                    }
+                    "".to_string()
+                });
+
+            plot.show(ui, |plot_ui| {
+                let bid_points: PlotPoints = self.data
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| [i as f64, t.bid])
+                    .collect();
+                
+                let ask_points: PlotPoints = self.data
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| [i as f64, t.ask])
+                    .collect();
+
+                plot_ui.line(Line::new(bid_points).name("Bid").color(egui::Color32::from_rgb(100, 200, 100)));
+                plot_ui.line(Line::new(ask_points).name("Ask").color(egui::Color32::from_rgb(200, 100, 100)));
+                
+                // Draw Active Positions (horizontal lines)
+                for pos in &self.positions {
+                    let color = if pos.pos_type == "BUY" {
+                        egui::Color32::from_rgb(50, 100, 255) 
+                    } else {
+                        egui::Color32::from_rgb(255, 50, 50) 
+                    };
+                    
+                    plot_ui.hline(
+                        egui_plot::HLine::new(pos.price)
+                            .color(color)
+                            .name(format!("{} #{}", pos.pos_type, pos.ticket))
+                            .style(egui_plot::LineStyle::Dashed { length: 10.0 })
+                    );
+                }
+                
+                // Draw Order Breaklines (vertical lines at execution points)
+                for breakline in &self.order_breaklines {
+                    let color = if breakline.order_type.contains("buy") {
+                        egui::Color32::from_rgb(0, 200, 100) // Bright green for BUY
+                    } else {
+                        egui::Color32::from_rgb(255, 80, 80) // Bright red for SELL
+                    };
+                    
+                    plot_ui.vline(
+                        egui_plot::VLine::new(breakline.index as f64)
+                            .color(color)
+                            .name(format!("Order #{}", breakline.ticket))
+                            .width(2.0)
+                    );
+                }
+            });
+        });
+
+        // Request a repaint to update the chart continuously
+        ctx.request_repaint();
+    }
+}
+
+// ============================================================================
+// Main Entry Point
+// ============================================================================
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Channels for tick data
+    let (tick_tx, tick_rx) = mpsc::channel(100);
+    
+    // Channels for order requests and responses
+    let (order_tx, mut order_rx) = mpsc::channel::<OrderRequest>(10);
+    let (response_tx, response_rx) = mpsc::channel::<OrderResponse>(10);
+
+    // ========================================================================
+    // Spawn ZMQ Tick Subscriber task
+    // ========================================================================
+    tokio::spawn(async move {
+        let mut socket = zeromq::SubSocket::new();
+        match socket.connect("tcp://127.0.0.1:5555").await {
+            Ok(_) => println!("Connected to ZMQ Tick Publisher on port 5555"),
+            Err(e) => eprintln!("Failed to connect to ZMQ tick publisher: {}", e),
+        }
+        
+        let _ = socket.subscribe("").await;
+
+        loop {
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(payload_bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(payload_bytes) {
+                            match serde_json::from_str::<TickData>(json_str) {
+                                Ok(tick) => {
+                                    if let Err(e) = tick_tx.send(tick).await {
+                                        eprintln!("Tick channel error: {}", e);
+                                        break;
+                                    }
+                                }
+                                Err(e) => eprintln!("JSON Parse Error: {}. Msg: {}", e, json_str),
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("ZMQ Tick Recv Error: {}", e);
+                    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+                }
+            }
+        }
+    });
+
+    // ========================================================================
+    // Spawn ZMQ Order Request/Response task
+    // ========================================================================
+    tokio::spawn(async move {
+        let mut socket = zeromq::ReqSocket::new();
+        match socket.connect("tcp://127.0.0.1:5556").await {
+            Ok(_) => println!("Connected to ZMQ Order Handler on port 5556"),
+            Err(e) => {
+                eprintln!("Failed to connect to ZMQ order handler: {}", e);
+                return;
+            }
+        }
+
+        while let Some(order_request) = order_rx.recv().await {
+            // Serialize order request to JSON
+            let json_request = match serde_json::to_string(&order_request) {
+                Ok(json) => json,
+                Err(e) => {
+                    eprintln!("Failed to serialize order request: {}", e);
+                    continue;
+                }
+            };
+            
+            println!("Sending request: {}", json_request);
+            
+            // Send request
+            if let Err(e) = socket.send(json_request.into()).await {
+                eprintln!("Failed to send: {}", e);
+                let _ = response_tx.send(OrderResponse {
+                    success: false,
+                    ticket: None,
+                    error: Some(format!("Send failed: {}", e)),
+                    message: None,
+                }).await;
+                continue;
+            }
+            
+            // Wait for response
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(payload_bytes) = msg.get(0) {
+                        if let Ok(json_str) = std::str::from_utf8(payload_bytes) {
+                            println!("Received response: {}", json_str);
+                            match serde_json::from_str::<OrderResponse>(json_str) {
+                                Ok(response) => {
+                                    let _ = response_tx.send(response).await;
+                                }
+                                Err(e) => {
+                                    let _ = response_tx.send(OrderResponse {
+                                        success: false,
+                                        ticket: None,
+                                        error: Some(format!("Parse error: {}", e)),
+                                        message: None,
+                                    }).await;
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Response recv error: {}", e);
+                    let _ = response_tx.send(OrderResponse {
+                        success: false,
+                        ticket: None,
+                        error: Some(format!("Recv failed: {}", e)),
+                        message: None,
+                    }).await;
+                }
+            }
+        }
+    });
+
+    // ========================================================================
+    // Run the egui application
+    // ========================================================================
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_inner_size([1200.0, 800.0])
+            .with_title("Rust + ZMQ + MT5 Trading Chart"),
+        ..Default::default()
+    };
+    
+    eframe::run_native(
+        "Rust + ZMQ + MT5 Trading Chart",
+        options,
+        Box::new(|_cc| Box::new(Mt5ChartApp::new(tick_rx, order_tx, response_rx))),
+    ).map_err(|e| e.into())
+}

mql-rust/.gitignore

@@ -0,0 +1 @@
+/target

mql-rust/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "mql-rust"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+chrono = "0.4.44"
+crossbeam = "0.8.4"
+eframe = "0.33.3"
+egui = "0.33.3"
+egui_plot = "0.34.1"
+futures = "0.3.32"
+ndarray = "0.17.2"
+nom = "8.0.0"
+rayon = "1.11.0"
+rfd = "0.17.2"
+serde = "1.0.228"
+serde_json = "1.0.149"
+tokio = "1.50.0"
+zeromq = "0.5.0"

mql-rust/src/compiler/ast.rs

@@ -0,0 +1,63 @@
+use crate::compiler::lexer::Token;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum AstNode {
+    Program(Vec<AstNode>),
+    
+    // Declarations
+    VarDecl {
+        var_type: Token,
+        is_input: bool,
+        name: String,
+        init_value: Option<Box<AstNode>>,
+    },
+    
+    FunctionDecl {
+        return_type: Token,
+        name: String,
+        params: Vec<AstNode>, // VarDecl
+        body: Box<AstNode>,   // Block
+    },
+    
+    Block(Vec<AstNode>),
+    
+    // Statements
+    IfStatement {
+        condition: Box<AstNode>,
+        then_branch: Box<AstNode>,
+        else_branch: Option<Box<AstNode>>,
+    },
+    
+    ReturnStatement(Option<Box<AstNode>>),
+    ExpressionStatement(Box<AstNode>),
+    
+    // Expressions
+    BinaryOp {
+        left: Box<AstNode>,
+        op: Token,
+        right: Box<AstNode>,
+    },
+    
+    UnaryOp {
+        op: Token,
+        expr: Box<AstNode>,
+    },
+    
+    FunctionCall {
+        name: String,
+        args: Vec<AstNode>,
+    },
+    
+    // Built-in MQL5 logic
+    OrderSendCall {
+        symbol: String,
+        cmd: Token, // OP_BUY, OP_SELL (represented as tokens or mapped strings)
+        volume: f64,
+        price: f64,
+        sl: f64,
+        tp: f64,
+    },
+    
+    Identifier(String),
+    Literal(Token),
+}

mql-rust/src/compiler/lexer.rs

@@ -0,0 +1,64 @@
+use std::fmt;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Token {
+    // Keywords
+    Int,
+    Double,
+    String,
+    Bool,
+    Void,
+    If,
+    Else,
+    For,
+    While,
+    Return,
+    Input,
+    
+    // Built-in MQL5 Types
+    MqlTick,
+    MqlRates,
+    
+    // Identifiers & Literals
+    Identifier(String),
+    IntLiteral(i64),
+    DoubleLiteral(f64),
+    StringLiteral(String),
+    BoolLiteral(bool),
+    
+    // Operators
+    Plus,       // +
+    Minus,      // -
+    Star,       // *
+    Slash,      // /
+    Assign,     // =
+    Equals,     // ==
+    NotEquals,  // !=
+    Greater,    // >
+    Less,       // <
+    GreaterEq,  // >=
+    LessEq,     // <=
+    And,        // &&
+    Or,         // ||
+    Not,        // !
+    
+    // Punctuation
+    OpenParen,  // (
+    CloseParen, // )
+    OpenBrace,  // {
+    CloseBrace, // }
+    OpenBracket,// [
+    CloseBracket,//]
+    Comma,      // ,
+    Semicolon,  // ;
+    Dot,        // .
+    
+    // EOF
+    Eof,
+}
+
+impl fmt::Display for Token {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}

mql-rust/src/compiler/mod.rs

@@ -0,0 +1,4 @@
+pub mod ast;
+pub mod lexer;
+pub mod parser;
+pub mod transpiler;

mql-rust/src/compiler/parser.rs

@@ -0,0 +1,136 @@
+use nom::{
+    branch::alt,
+    bytes::complete::{tag, take_while1, take_until, take_while},
+    character::complete::{alpha1, alphanumeric1, char, digit1, multispace0, multispace1, anychar},
+    combinator::{map, map_res, recognize, value, eof, opt},
+    multi::many0,
+    sequence::{delimited, pair, preceded, tuple},
+    IResult,
+};
+use crate::compiler::lexer::Token;
+use std::str::FromStr;
+
+pub struct Lexer;
+
+impl Lexer {
+    pub fn tokenize(input: &str) -> IResult<&str, Vec<Token>> {
+        many0(preceded(
+            // Skip whitespace and comments
+            alt((
+                multispace1,
+                // Line comment //
+                recognize(pair(tag("//"), take_while(|c| c != '\n' && c != '\r'))),
+                // Block comment /* */
+                recognize(delimited(tag("/*"), take_until("*/"), tag("*/"))),
+            )),
+            // Parse tokens
+            alt((
+                // Keywords & Types
+                Self::parse_keyword,
+                
+                // Literals
+                Self::parse_double_literal,
+                Self::parse_int_literal,
+                Self::parse_string_literal,
+                Self::parse_bool_literal,
+                
+                // Identifiers
+                Self::parse_identifier,
+                
+                // Operators & Punctuation (Order matters for prefix matching, e.g. == before =)
+                Self::parse_operator,
+                Self::parse_punctuation,
+            ))
+        ))(input)
+    }
+
+    fn parse_keyword(input: &str) -> IResult<&str, Token> {
+        alt((
+            value(Token::Int, tag("int")),
+            value(Token::Double, tag("double")),
+            value(Token::String, tag("string")),
+            value(Token::Bool, tag("bool")),
+            value(Token::Void, tag("void")),
+            value(Token::Input, tag("input")),
+            value(Token::If, tag("if")),
+            value(Token::Else, tag("else")),
+            value(Token::For, tag("for")),
+            value(Token::While, tag("while")),
+            value(Token::Return, tag("return")),
+            value(Token::MqlTick, tag("MqlTick")),
+            value(Token::MqlRates, tag("MqlRates")),
+        ))(input)
+    }
+    
+    fn parse_bool_literal(input: &str) -> IResult<&str, Token> {
+        alt((
+            value(Token::BoolLiteral(true), tag("true")),
+            value(Token::BoolLiteral(false), tag("false")),
+        ))(input)
+    }
+
+    fn parse_identifier(input: &str) -> IResult<&str, Token> {
+        map(
+            recognize(pair(
+                alt((alpha1, tag("_"))),
+                take_while(|c: char| c.is_alphanumeric() || c == '_')
+            )),
+            |s: &str| Token::Identifier(s.to_string())
+        )(input)
+    }
+
+    fn parse_int_literal(input: &str) -> IResult<&str, Token> {
+        map_res(digit1, |s: &str| s.parse::<i64>().map(Token::IntLiteral))(input)
+    }
+
+    fn parse_double_literal(input: &str) -> IResult<&str, Token> {
+        map_res(
+            recognize(tuple((
+                digit1,
+                char('.'),
+                digit1
+            ))),
+            |s: &str| s.parse::<f64>().map(Token::DoubleLiteral)
+        )(input)
+    }
+
+    fn parse_string_literal(input: &str) -> IResult<&str, Token> {
+        map(
+            delimited(char('"'), take_while(|c| c != '"'), char('"')),
+            |s: &str| Token::StringLiteral(s.to_string())
+        )(input)
+    }
+
+    fn parse_operator(input: &str) -> IResult<&str, Token> {
+        alt((
+            value(Token::Equals, tag("==")),
+            value(Token::NotEquals, tag("!=")),
+            value(Token::GreaterEq, tag(">=")),
+            value(Token::LessEq, tag("<=")),
+            value(Token::And, tag("&&")),
+            value(Token::Or, tag("||")),
+            value(Token::Assign, tag("=")),
+            value(Token::Greater, tag(">")),
+            value(Token::Less, tag("<")),
+            value(Token::Plus, tag("+")),
+            value(Token::Minus, tag("-")),
+            value(Token::Star, tag("*")),
+            value(Token::Slash, tag("/")),
+            value(Token::Not, tag("!")),
+        ))(input)
+    }
+    
+    fn parse_punctuation(input: &str) -> IResult<&str, Token> {
+        alt((
+            value(Token::OpenParen, tag("(")),
+            value(Token::CloseParen, tag(")")),
+            value(Token::OpenBrace, tag("{")),
+            value(Token::CloseBrace, tag("}")),
+            value(Token::OpenBracket, tag("[")),
+            value(Token::CloseBracket, tag("]")),
+            value(Token::Comma, tag(",")),
+            value(Token::Semicolon, tag(";")),
+            value(Token::Dot, tag(".")),
+        ))(input)
+    }
+}

mql-rust/src/compiler/transpiler.rs

@@ -0,0 +1,191 @@
+use crate::compiler::ast::AstNode;
+use crate::compiler::lexer::Token;
+
+pub struct Transpiler;
+
+impl Transpiler {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn transpile(&self, ast: &AstNode) -> Result<String, String> {
+        let mut output = String::new();
+        
+        output.push_str("// Auto-generated by MQL-Rust Transpiler\n");
+        output.push_str("use crate::engine::backtester::{Backtester, OrderType};\n\n");
+        
+        self.visit_node(ast, &mut output)?;
+        
+        Ok(output)
+    }
+
+    fn visit_node(&self, node: &AstNode, out: &mut String) -> Result<(), String> {
+        match node {
+            AstNode::Program(nodes) => {
+                for n in nodes {
+                    self.visit_node(n, out)?;
+                    out.push('\n');
+                }
+            }
+            AstNode::VarDecl { var_type, is_input, name, init_value } => {
+                // Convert input variables to public struct fields (for UI configuration) or global consts
+                let type_str = self.mql_to_rust_type(var_type)?;
+                if *is_input {
+                    // For now, hardcode inputs as consts to simplify the transpiler proof-of-concept
+                    out.push_str(&format!("pub const {}: {} = ", name.to_uppercase(), type_str));
+                } else {
+                    out.push_str(&format!("let mut {}: {} = ", name, type_str));
+                }
+                
+                if let Some(val) = init_value {
+                    self.visit_node(val, out)?;
+                } else {
+                    out.push_str("Default::default()");
+                }
+                out.push_str(";\n");
+            }
+            AstNode::FunctionDecl { return_type, name, params, body } => {
+                let ret_str = self.mql_to_rust_type(return_type)?;
+                
+                // Special handling for MQL5 entry points
+                if name == "OnInit" || name == "OnDeinit" || name == "OnTick" || name == "OnTimer" {
+                    // Passing the backtester context
+                    out.push_str(&format!("pub fn mql_{}(bt_ctx: &mut Backtester", name));
+                } else {
+                    out.push_str(&format!("fn {}(", name));
+                }
+
+                // Add params explicitly handling
+                if !params.is_empty() {
+                    if name.starts_with("On") { out.push_str(", "); } // Add comma if context was added
+                    for (i, p) in params.iter().enumerate() {
+                        if let AstNode::VarDecl { var_type, name: p_name, .. } = p {
+                            let p_type = self.mql_to_rust_type(var_type)?;
+                            out.push_str(&format!("{}: &{}", p_name, p_type));
+                            if i < params.len() - 1 { out.push_str(", "); }
+                        }
+                    }
+                }
+                
+                out.push_str(")");
+                if *return_type != Token::Void {
+                    out.push_str(&format!(" -> {}", ret_str));
+                }
+                out.push_str(" ");
+                self.visit_node(body, out)?;
+            }
+            AstNode::Block(nodes) => {
+                out.push_str("{\n");
+                for n in nodes {
+                    self.visit_node(n, out)?;
+                    out.push('\n');
+                }
+                out.push_str("}\n");
+            }
+            AstNode::ExpressionStatement(expr) => {
+                self.visit_node(expr, out)?;
+                out.push_str(";");
+            }
+            AstNode::ReturnStatement(opt_expr) => {
+                out.push_str("return ");
+                if let Some(expr) = opt_expr {
+                    self.visit_node(expr, out)?;
+                }
+                out.push_str(";");
+            }
+            AstNode::IfStatement { condition, then_branch, else_branch } => {
+                out.push_str("if ");
+                self.visit_node(condition, out)?;
+                out.push_str(" ");
+                self.visit_node(then_branch, out)?;
+                if let Some(e) = else_branch {
+                    out.push_str(" else ");
+                    self.visit_node(e, out)?;
+                }
+            }
+            AstNode::BinaryOp { left, op, right } => {
+                self.visit_node(left, out)?;
+                let op_str = match op {
+                    Token::Plus => " + ",
+                    Token::Minus => " - ",
+                    Token::Star => " * ",
+                    Token::Slash => " / ",
+                    Token::Assign => " = ",
+                    Token::Equals => " == ",
+                    Token::NotEquals => " != ",
+                    Token::GreaterEq => " >= ",
+                    Token::LessEq => " <= ",
+                    Token::Greater => " > ",
+                    Token::Less => " < ",
+                    Token::And => " && ",
+                    Token::Or => " || ",
+                    _ => return Err(format!("Unsupported binary operator {:?}", op)),
+                };
+                out.push_str(op_str);
+                self.visit_node(right, out)?;
+            }
+            AstNode::UnaryOp { op, expr } => {
+                let op_str = match op {
+                    Token::Not => "!",
+                    Token::Minus => "-",
+                    _ => return Err(format!("Unsupported unary operator {:?}", op)),
+                };
+                out.push_str(op_str);
+                self.visit_node(expr, out)?;
+            }
+            AstNode::FunctionCall { name, args } => {
+                // If it's a built in order function, route to the context
+                if name == "OrderSend" { // Simulating simpler logic
+                    out.push_str("bt_ctx.market_order(");
+                } else {
+                    out.push_str(&format!("{}(", name));
+                }
+                
+                for (i, arg) in args.iter().enumerate() {
+                    self.visit_node(arg, out)?;
+                    if i < args.len() - 1 { out.push_str(", "); }
+                }
+                out.push_str(")");
+            }
+            AstNode::OrderSendCall { symbol, cmd, volume, price, sl, tp } => {
+                // Specialized mapping for trading commands
+                let cmd_str = if *cmd == Token::Identifier("ORDER_TYPE_BUY".to_string()) {
+                    "OrderType::Buy"
+                } else {
+                    "OrderType::Sell"
+                };
+                out.push_str(&format!(
+                    "bt_ctx.market_order(\"{}\", {}, {}, Some({}), Some({}), \"Time_Sim\".to_string())",
+                    symbol, cmd_str, volume, sl, tp
+                ));
+            }
+            AstNode::Identifier(id) => {
+                out.push_str(id);
+            }
+            AstNode::Literal(tok) => {
+                match tok {
+                    Token::IntLiteral(i) => out.push_str(&i.to_string()),
+                    Token::DoubleLiteral(d) => out.push_str(&format!("{:.5}", d)),
+                    Token::BoolLiteral(b) => out.push_str(if *b { "true" } else { "false" }),
+                    Token::StringLiteral(s) => out.push_str(&format!("\"{}\"", s)),
+                    _ => return Err(format!("Unexpected literal token {:?}", tok)),
+                }
+            }
+            _ => return Err("Unsupported AST Node".to_string()),
+        }
+        Ok(())
+    }
+
+    fn mql_to_rust_type(&self, mql_type: &Token) -> Result<&'static str, String> {
+        match mql_type {
+            Token::Int => Ok("i64"),
+            Token::Double => Ok("f64"),
+            Token::Bool => Ok("bool"),
+            Token::String => Ok("String"),
+            Token::Void => Ok("()"),
+            Token::MqlTick => Ok("crate::data::parser::Tick"),
+            Token::MqlRates => Ok("crate::data::parser::Ohlcv"),
+            _ => Err(format!("Unknown or unmapped MQL5 type: {:?}", mql_type)),
+        }
+    }
+}

mql-rust/src/data/mod.rs

@@ -0,0 +1,2 @@
+pub mod mt5_client;
+pub mod parser;

mql-rust/src/data/mt5_client.rs

@@ -0,0 +1,64 @@
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+
+#[derive(Clone, Debug, Serialize)]
+pub struct HistoryRequest {
+    #[serde(rename = "type")]
+    pub req_type: String, // "download_history"
+    pub symbol: String,
+    pub timeframe: String,
+    pub start: String,
+    pub end: String,
+    pub mode: String, // "OHLC" or "TICKS"
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct HistoryResponse {
+    pub success: bool,
+    pub error: Option<String>,
+    pub message: Option<String>,
+}
+
+pub struct Mt5Client {
+    pub rep_address: String,
+}
+
+impl Mt5Client {
+    pub fn new(rep_address: &str) -> Self {
+        Self {
+            rep_address: rep_address.to_string(),
+        }
+    }
+
+    pub async fn download_history(&self, request: HistoryRequest) -> Result<String, String> {
+        let mut socket = zeromq::ReqSocket::new();
+        socket.connect(&self.rep_address).await.map_err(|e| format!("Failed to connect: {}", e))?;
+
+        let json_request = serde_json::to_string(&request).map_err(|e| format!("Serialization error: {}", e))?;
+        
+        socket.send(json_request.into()).await.map_err(|e| format!("Send error: {}", e))?;
+
+        let msg = socket.recv().await.map_err(|e| format!("Receive error: {}", e))?;
+        let payload = msg.get(0).ok_or("Empty response")?;
+        let json_str = std::str::from_utf8(payload).map_err(|e| format!("UTF8 error: {}", e))?;
+        
+        let response: HistoryResponse = serde_json::from_str(json_str).map_err(|e| format!("JSON Parse error: {}", e))?;
+
+        if response.success {
+            if let Some(msg) = response.message {
+                if msg.contains("||CSV_DATA||") {
+                    let parts: Vec<&str> = msg.splitn(2, "||CSV_DATA||").collect();
+                    if parts.len() == 2 {
+                        let csv_content = parts[1].replace("|NL|", "\n");
+                        return Ok(csv_content);
+                    }
+                }
+                return Ok(msg);
+            }
+            Ok("Success".to_string())
+        } else {
+            Err(response.error.unwrap_or_else(|| "Unknown error".to_string()))
+        }
+    }
+}

mql-rust/src/data/parser.rs

@@ -0,0 +1,86 @@
+use std::str::FromStr;
+
+#[derive(Debug, Clone)]
+pub struct Ohlcv {
+    pub time: String,
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub tick_volume: u64,
+    pub spread: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct Tick {
+    pub time: String,
+    pub bid: f64,
+    pub ask: f64,
+    pub volume: u64,
+}
+
+pub fn parse_ohlcv_csv(csv_data: &str) -> Vec<Ohlcv> {
+    let mut results = Vec::new();
+    let mut lines = csv_data.lines();
+    
+    // Skip header
+    lines.next();
+    
+    for line in lines {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let parts: Vec<&str> = line.split(',').collect();
+        if parts.len() >= 7 {
+            if let (Ok(o), Ok(h), Ok(l), Ok(c), Ok(tv), Ok(s)) = (
+                f64::from_str(parts[1]),
+                f64::from_str(parts[2]),
+                f64::from_str(parts[3]),
+                f64::from_str(parts[4]),
+                u64::from_str(parts[5]),
+                u32::from_str(parts[6]),
+            ) {
+                results.push(Ohlcv {
+                    time: parts[0].to_string(),
+                    open: o,
+                    high: h,
+                    low: l,
+                    close: c,
+                    tick_volume: tv,
+                    spread: s,
+                });
+            }
+        }
+    }
+    results
+}
+
+pub fn parse_tick_csv(csv_data: &str) -> Vec<Tick> {
+    let mut results = Vec::new();
+    let mut lines = csv_data.lines();
+    
+    // Skip header
+    lines.next();
+    
+    for line in lines {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let parts: Vec<&str> = line.split(',').collect();
+        if parts.len() >= 4 {
+            if let (Ok(b), Ok(a), Ok(v)) = (
+                f64::from_str(parts[1]),
+                f64::from_str(parts[2]),
+                u64::from_str(parts[3]),
+            ) {
+                results.push(Tick {
+                    time: parts[0].to_string(),
+                    bid: b,
+                    ask: a,
+                    volume: v,
+                });
+            }
+        }
+    }
+    results
+}

mql-rust/src/engine/backtester.rs

@@ -0,0 +1,172 @@
+use crate::data::parser::{Ohlcv, Tick};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum OrderType {
+    Buy,
+    Sell,
+    // Add pending later
+}
+
+#[derive(Debug, Clone)]
+pub struct Position {
+    pub ticket: u64,
+    pub symbol: String,
+    pub order_type: OrderType,
+    pub volume: f64,
+    pub open_price: f64,
+    pub sl: Option<f64>,
+    pub tp: Option<f64>,
+    pub open_time: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ClosedTrade {
+    pub ticket: u64,
+    pub symbol: String,
+    pub order_type: OrderType,
+    pub volume: f64,
+    pub open_price: f64,
+    pub close_price: f64,
+    pub profit: f64,
+    pub open_time: String,
+    pub close_time: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct BacktestConfig {
+    pub initial_deposit: f64,
+    pub leverage: f64,
+    pub spread_modifier: u32,
+}
+
+pub struct Backtester {
+    pub config: BacktestConfig,
+    pub balance: f64,
+    pub equity: f64,
+    pub free_margin: f64,
+    pub margin: f64,
+    pub open_positions: Vec<Position>,
+    pub history: Vec<ClosedTrade>,
+    ticket_counter: u64,
+    
+    // Internal state cache for symbols
+    pub current_prices: HashMap<String, (f64, f64)>, // Bid, Ask
+}
+
+impl Backtester {
+    pub fn new(config: BacktestConfig) -> Self {
+        Self {
+            balance: config.initial_deposit,
+            equity: config.initial_deposit,
+            free_margin: config.initial_deposit,
+            margin: 0.0,
+            config,
+            open_positions: Vec::new(),
+            history: Vec::new(),
+            ticket_counter: 1,
+            current_prices: HashMap::new(),
+        }
+    }
+
+    pub fn update_tick(&mut self, symbol: &str, bid: f64, ask: f64) {
+        self.current_prices.insert(symbol.to_string(), (bid, ask));
+        self.recalculate_equity();
+    }
+    
+    pub fn update_ohlcv(&mut self, symbol: &str, bar: &Ohlcv) {
+        // Simple approximation for bar execution (using Close price for equity calculation)
+        let simulated_bid = bar.close;
+        let simulated_ask = bar.close + (bar.spread as f64 * 0.00001); // Assumes generic 5-digit broker formatting
+        self.update_tick(symbol, simulated_bid, simulated_ask);
+    }
+
+    fn recalculate_equity(&mut self) {
+        let mut floating_profit = 0.0;
+        let contract_size = 100000.0; // Assume standard Forex lots for MVP
+        
+        for pos in &self.open_positions {
+            if let Some(&(bid, ask)) = self.current_prices.get(&pos.symbol) {
+                if pos.order_type == OrderType::Buy {
+                    floating_profit += (bid - pos.open_price) * contract_size * pos.volume;
+                } else if pos.order_type == OrderType::Sell {
+                    floating_profit += (pos.open_price - ask) * contract_size * pos.volume;
+                }
+            }
+        }
+        
+        self.equity = self.balance + floating_profit;
+        self.free_margin = self.equity - self.margin;
+    }
+
+    pub fn market_order(&mut self, symbol: &str, order_type: OrderType, volume: f64, sl: Option<f64>, tp: Option<f64>, time: String) -> Result<u64, String> {
+        let &(bid, ask) = self.current_prices.get(symbol).ok_or("No price data for symbol")?;
+        
+        // Ensure Margin
+        let required_margin = (volume * 100000.0) / self.config.leverage;
+        if self.free_margin < required_margin {
+            return Err("Not enough free margin".to_string());
+        }
+
+        let price = match order_type {
+            OrderType::Buy => ask,
+            OrderType::Sell => bid,
+        };
+
+        let ticket = self.ticket_counter;
+        self.ticket_counter += 1;
+
+        let pos = Position {
+            ticket,
+            symbol: symbol.to_string(),
+            order_type,
+            volume,
+            open_price: price,
+            sl,
+            tp,
+            open_time: time,
+        };
+
+        self.margin += required_margin;
+        self.open_positions.push(pos);
+        self.recalculate_equity();
+
+        Ok(ticket)
+    }
+
+    pub fn close_position(&mut self, ticket: u64, time: String) -> Result<(), String> {
+        let pos_index = self.open_positions.iter().position(|p| p.ticket == ticket)
+            .ok_or("Position ticket not found")?;
+
+        let pos = self.open_positions.remove(pos_index);
+        let &(bid, ask) = self.current_prices.get(&pos.symbol).ok_or("No price data for symbol")?;
+        
+        let contract_size = 100000.0;
+        
+        let (close_price, profit) = match pos.order_type {
+            OrderType::Buy => (bid, (bid - pos.open_price) * contract_size * pos.volume),
+            OrderType::Sell => (ask, (pos.open_price - ask) * contract_size * pos.volume),
+        };
+
+        self.balance += profit;
+        
+        // Free margin back
+        let required_margin = (pos.volume * 100000.0) / self.config.leverage;
+        self.margin -= required_margin;
+        
+        self.history.push(ClosedTrade {
+            ticket: pos.ticket,
+            symbol: pos.symbol.clone(),
+            order_type: pos.order_type,
+            volume: pos.volume,
+            open_price: pos.open_price,
+            close_price,
+            profit,
+            open_time: pos.open_time,
+            close_time: time,
+        });
+
+        self.recalculate_equity();
+        Ok(())
+    }
+}

mql-rust/src/engine/data.rs

@@ -0,0 +1,44 @@
+use crate::data::parser::{Ohlcv, Tick};
+
+pub enum DataRow {
+    Ohlc(Ohlcv),
+    TickData(Tick),
+}
+
+pub struct DataFeed {
+    pub symbol: String,
+    pub data: Vec<DataRow>,
+    cursor: usize,
+}
+
+impl DataFeed {
+    pub fn new(symbol: &str, data: Vec<DataRow>) -> Self {
+        Self {
+            symbol: symbol.to_string(),
+            data,
+            cursor: 0,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.cursor = 0;
+    }
+
+    pub fn next(&mut self) -> Option<&DataRow> {
+        if self.cursor < self.data.len() {
+            let row = &self.data[self.cursor];
+            self.cursor += 1;
+            Some(row)
+        } else {
+            None
+        }
+    }
+    
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+    
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}

mql-rust/src/engine/mod.rs

@@ -0,0 +1,3 @@
+pub mod backtester;
+pub mod data;
+pub mod tests;

mql-rust/src/engine/tests.rs

@@ -0,0 +1,55 @@
+#[cfg(test)]
+mod tests {
+    use crate::compiler::lexer::Lexer;
+    use crate::compiler::lexer::Token;
+    use crate::engine::backtester::{Backtester, BacktestConfig, OrderType};
+
+    #[test]
+    fn test_mql5_lexer() {
+        let code = r#"
+            double input lotSize = 0.1;
+            void OnTick() {
+                OrderSend("EURUSD", OP_BUY, lotSize, Ask, 10, 0, 0);
+            }
+        "#;
+        
+        // This is just a structural test that the lexer doesn't panic and returns tokens
+        let result = Lexer::tokenize(code);
+        assert!(result.is_ok());
+        
+        let (_, tokens) = result.unwrap();
+        assert!(!tokens.is_empty());
+        assert!(tokens.contains(&Token::Double));
+        assert!(tokens.contains(&Token::Input));
+        assert!(tokens.contains(&Token::Identifier("lotSize".to_string())));
+    }
+    
+    #[test]
+    fn test_backtest_engine_equity() {
+        let config = BacktestConfig {
+            initial_deposit: 10000.0,
+            leverage: 100.0,
+            spread_modifier: 0,
+        };
+        
+        let mut bt = Backtester::new(config);
+        
+        // Simulate feed: Bid=1.00000, Ask=1.00010
+        bt.update_tick("EURUSD", 1.00000, 1.00010);
+        
+        let ticket = bt.market_order("EURUSD", OrderType::Buy, 1.0, None, None, "10:00".to_string()).unwrap();
+        
+        // Price goes up 10 pips: Bid=1.00100, Ask=1.00110
+        bt.update_tick("EURUSD", 1.00100, 1.00110);
+        
+        // We bought at Ask (1.00010), current Bid is 1.00100. Diff = +0.00090
+        // Profit = 0.00090 * 100000 * 1.0 = $90.00
+        assert!(bt.equity > 10080.0 && bt.equity < 10100.0); 
+        
+        // Close position
+        bt.close_position(ticket, "10:05".to_string()).unwrap();
+        assert!(bt.balance > 10080.0 && bt.balance < 10100.0);
+        assert_eq!(bt.open_positions.len(), 0);
+        assert_eq!(bt.history.len(), 1);
+    }
+}

mql-rust/src/main.rs

@@ -0,0 +1,53 @@
+pub mod compiler;
+pub mod data;
+pub mod engine;
+pub mod ui;
+
+use eframe::egui;
+use ui::backtest_panel::BacktestPanel;
+
+struct MqlRustApp {
+    backtest_panel: BacktestPanel,
+}
+
+impl MqlRustApp {
+    fn new(_cc: &eframe::CreationContext<'_>) -> Self {
+        Self {
+            backtest_panel: BacktestPanel::new(),
+        }
+    }
+}
+
+impl eframe::App for MqlRustApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("MQL-Rust Compiler & Backtester");
+            ui.separator();
+            
+            // Draw configuration panel
+            if let Some(config) = self.backtest_panel.draw(ui) {
+                // Return config triggered a backtest run request
+                self.backtest_panel.compiler_log.push_str(&format!(
+                    "\n> Starting backtest with Deposit: ${}, Leverage: 1:{}, Spread Modifier: {}",
+                    config.initial_deposit, config.leverage, config.spread_modifier
+                ));
+                // TODO: Wire parsing and backtesting execution threads
+            }
+        });
+    }
+}
+
+fn main() -> eframe::Result<()> {
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default()
+            .with_inner_size([600.0, 700.0])
+            .with_title("MQL-Rust"),
+        ..Default::default()
+    };
+    
+    eframe::run_native(
+        "MQL-Rust Console",
+        options,
+        Box::new(|cc| Ok(Box::new(MqlRustApp::new(cc)))),
+    )
+}

mql-rust/src/ui/backtest_panel.rs

@@ -0,0 +1,156 @@
+use eframe::egui;
+use rfd::FileDialog;
+use std::path::PathBuf;
+use crate::engine::backtester::BacktestConfig;
+
+pub struct BacktestPanel {
+    pub initial_deposit_str: String,
+    pub leverage_str: String,
+    pub spread_modifier_str: String,
+    pub selected_symbols: Vec<String>,
+    pub new_symbol_input: String,
+    pub loaded_mql5_path: Option<PathBuf>,
+    pub compiler_log: String,
+    pub is_running: bool,
+}
+
+impl BacktestPanel {
+    pub fn new() -> Self {
+        Self {
+            initial_deposit_str: "10000.0".to_string(),
+            leverage_str: "100.0".to_string(),
+            spread_modifier_str: "0".to_string(),
+            selected_symbols: vec!["EURUSD".to_string()],
+            new_symbol_input: "".to_string(),
+            loaded_mql5_path: None,
+            compiler_log: "Ready.".to_string(),
+            is_running: false,
+        }
+    }
+
+    pub fn draw(&mut self, ui: &mut egui::Ui) -> Option<BacktestConfig> {
+        ui.heading("⚙️ Backtest Configuration");
+        ui.separator();
+
+        // Account Settings
+        ui.group(|ui| {
+            ui.label("Account Settings");
+            egui::Grid::new("config_grid").num_columns(2).spacing([10.0, 5.0]).show(ui, |ui| {
+                ui.label("Initial Deposit ($):");
+                ui.text_edit_singleline(&mut self.initial_deposit_str);
+                ui.end_row();
+
+                ui.label("Leverage (1:X):");
+                ui.text_edit_singleline(&mut self.leverage_str);
+                ui.end_row();
+
+                ui.label("Spread Modifier (points):");
+                ui.text_edit_singleline(&mut self.spread_modifier_str);
+                ui.end_row();
+            });
+        });
+
+        ui.add_space(10.0);
+
+        // Symbol Selection
+        ui.group(|ui| {
+            ui.label("Symbols for Backtest");
+            ui.horizontal(|ui| {
+                ui.text_edit_singleline(&mut self.new_symbol_input);
+                if ui.button("Add").clicked() {
+                    if !self.new_symbol_input.is_empty() && !self.selected_symbols.contains(&self.new_symbol_input) {
+                        self.selected_symbols.push(self.new_symbol_input.clone());
+                        self.new_symbol_input.clear();
+                    }
+                }
+            });
+            
+            ui.horizontal_wrapped(|ui| {
+                let mut to_remove = None;
+                for (i, sym) in self.selected_symbols.iter().enumerate() {
+                    ui.group(|ui| {
+                        ui.horizontal(|ui| {
+                            ui.label(sym);
+                            if ui.small_button("x").clicked() {
+                                to_remove = Some(i);
+                            }
+                        });
+                    });
+                }
+                if let Some(i) = to_remove {
+                    self.selected_symbols.remove(i);
+                }
+            });
+        });
+
+        ui.add_space(10.0);
+
+        // MQL5 File Loading
+        ui.group(|ui| {
+            ui.label("MQL5 Strategy Code");
+            ui.horizontal(|ui| {
+                if ui.button("📂 Load .mq5 File").clicked() {
+                    if let Some(path) = FileDialog::new()
+                        .add_filter("MQL5 Source", &["mq5"])
+                        .pick_file() 
+                    {
+                        self.loaded_mql5_path = Some(path);
+                        self.compiler_log = "File loaded. Ready to compile.".to_string();
+                    }
+                }
+                if let Some(p) = &self.loaded_mql5_path {
+                    ui.label(p.display().to_string());
+                } else {
+                    ui.label("No file selected.");
+                }
+            });
+        });
+
+        ui.add_space(10.0);
+
+        // Start button
+        ui.horizontal(|ui| {
+            if self.is_running {
+                ui.add_enabled(false, egui::Button::new("Running Backtest..."));
+            } else {
+                if ui.button("🚀 Compile & Run Backtest").clicked() {
+                    if self.loaded_mql5_path.is_none() {
+                        self.compiler_log = "Error: Please load an .mq5 file first.".to_string();
+                        return None;
+                    }
+                    if self.selected_symbols.is_empty() {
+                        self.compiler_log = "Error: Please add at least one symbol.".to_string();
+                        return None;
+                    }
+
+                    if let (Ok(dep), Ok(lev), Ok(spr)) = (
+                        self.initial_deposit_str.parse::<f64>(),
+                        self.leverage_str.parse::<f64>(),
+                        self.spread_modifier_str.parse::<u32>(),
+                    ) {
+                        self.compiler_log = "Starting compilation...".to_string();
+                        self.is_running = true;
+                        
+                        return Some(BacktestConfig {
+                            initial_deposit: dep,
+                            leverage: lev,
+                            spread_modifier: spr,
+                        });
+                    } else {
+                        self.compiler_log = "Error: Invalid numeric configuration fields.".to_string();
+                    }
+                }
+            }
+        });
+
+        ui.add_space(5.0);
+        
+        // Logs
+        ui.group(|ui| {
+            ui.set_min_height(60.0);
+            ui.label(&self.compiler_log);
+        });
+
+        None
+    }
+}

mql-rust/src/ui/mod.rs

@@ -0,0 +1 @@
+pub mod backtest_panel;