Upload 21 files

.gitattributes

@@ -33,3 +33,7 @@ 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
+A[[:space:]]GUIDE[[:space:]]to[[:space:]]open[[:space:]]SUM3API[[:space:]]software[[:space:]](trading[[:space:]]terminal).pdf filter=lfs diff=lfs merge=lfs -text
+MQL5/Libraries/libsodium.dll filter=lfs diff=lfs merge=lfs -text
+MQL5/Libraries/libzmq.dll filter=lfs diff=lfs merge=lfs -text
+SUM3API.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,15 @@
+# Rust
+/target
+Cargo.lock
+
+# MQL5
+/*.ex5
+/*.ex4
+
+# OS / IDE
+.DS_Store
+.vscode/
+
+# Local back-ups
+*copy/
+main_original_backup.tex

A GUIDE to open SUM3API software (trading terminal).pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:790111b2b4a46eb3358366c1a4421e50b481caa6b3ad76f6a5354c8a5e75e85c
+size 1274968

Complete_System_Architecture.md

@@ -0,0 +1,1341 @@
+# Complete End-to-End System Architecture: MQL5 ↔ ZeroMQ ↔ Rust for SUM3API
+
+**Version**: 2.0.0  
+**Last Updated**: 2026-01-28  
+**Purpose**: Comprehensive technical documentation covering all micro-level implementation details
+
+---
+
+## Table of Contents
+
+1. [System Overview](#system-overview)
+2. [Complete Architecture Diagram](#complete-architecture-diagram)
+3. [Security Architecture](#security-architecture)
+4. [Component Deep Dive](#component-deep-dive)
+5. [Data Flow & Communication Patterns](#data-flow--communication-patterns)
+6. [Account Information Fetching](#account-information-fetching)
+7. [Complete Data Structures](#complete-data-structures)
+8. [ZeroMQ Layer Details](#zeromq-layer-details)
+9. [Async Task Management](#async-task-management)
+10. [File Structure & Dependencies](#file-structure--dependencies)
+
+---
+
+## System Overview
+
+This system implements a **secure, real-time bidirectional trading bridge** between MetaTrader 5 and a Rust-based GUI application using ZeroMQ as the transport layer.
+
+### Core Design Principles
+
+1. **Security First**: No credentials in code or transmitted over network
+2. **Real-time Performance**: Tick-level granularity with minimal latency
+3. **Separation of Concerns**: Authentication vs. Trading logic
+4. **Async Architecture**: Non-blocking I/O for maximum throughput
+5. **Type Safety**: Strong typing in both MQL5 and Rust
+
+---
+
+## Complete Architecture Diagram
+
+### High-Level System Architecture
+
+```mermaid
+flowchart TB
+    subgraph USER_SPACE["User Space"]
+        USER[("User")]
+    end
+    
+    subgraph MT5_PLATFORM["MetaTrader 5 Platform (Authenticated Process)"]
+        direction TB
+        
+        subgraph AUTH["Authentication Layer"]
+            MT5_GUI[MT5 Terminal GUI]
+            SESSION["Authenticated Session<br/>[+] Account ID<br/>[+] Server Connection<br/>[+] Trading Permissions"]
+        end
+        
+        subgraph DATA_SOURCES["MT5 Data Sources"]
+            direction TB
+            MARKET[("Market Data Feed<br/>Tick Stream")]
+            ACCOUNT_DB[("Account Database<br/>ACCOUNT_BALANCE<br/>ACCOUNT_EQUITY<br/>ACCOUNT_MARGIN<br/>ACCOUNT_MARGIN_FREE")]
+            POSITIONS_DB[("Positions Database<br/>Active Trades")]
+            ORDERS_DB[("Orders Database<br/>Pending Orders")]
+            HISTORY_DB[("Historical Database<br/>OHLC & Tick Data")]
+        end
+        
+        subgraph EA_LAYER["Expert Advisor Layer"]
+            EA[ZmqPublisher.mq5<br/>Expert Advisor]
+            TRADE_ENGINE[CTrade Engine<br/>Order Execution]
+        end
+        
+        USER -->|1. Manual Login<br/>account + password + server| MT5_GUI
+        MT5_GUI --> SESSION
+        SESSION -.->|Inherits Session| EA
+        
+        MARKET --> EA
+        ACCOUNT_DB --> EA
+        POSITIONS_DB --> EA
+        ORDERS_DB --> EA
+        HISTORY_DB --> EA
+        EA --> TRADE_ENGINE
+    end
+    
+    subgraph ZMQ_LAYER["ZeroMQ Transport Layer (localhost)"]
+        direction TB
+        PUB_SOCKET[["[PUB] PUB Socket<br/>tcp://0.0.0.0:5555<br/>Broadcast Mode"]]
+        REP_SOCKET[["[REP] REP Socket<br/>tcp://0.0.0.0:5556<br/>Request-Reply Mode"]]
+    end
+    
+    subgraph RUST_APP["Rust Application (mt5-chart)"]
+        direction TB
+        
+        subgraph ASYNC_RUNTIME["Tokio Async Runtime"]
+            TICK_TASK[["[Task] Tick Subscriber Task<br/>SubSocket<br/>Port 5555"]]
+            ORDER_TASK[["[Task] Order Handler Task<br/>ReqSocket<br/>Port 5556"]]
+        end
+        
+        subgraph CHANNELS["MPSC Channels"]
+            direction TB
+            TICK_CHAN[Tick Channel<br/>capacity: 100]
+            ORDER_CHAN[Order Request Channel<br/>capacity: 10]
+            RESPONSE_CHAN[Order Response Channel<br/>capacity: 10]
+        end
+        
+        subgraph APP_STATE["Application State"]
+            STATE[Mt5ChartApp<br/>• data: Vec&lt;TickData&gt;<br/>• balance, equity, margin<br/>• positions, orders<br/>• UI state]
+        end
+        
+        subgraph GUI["egui GUI Components"]
+            direction TB
+            CHART[["[Chart] Price Chart<br/>Bid/Ask Lines<br/>Position Lines<br/>Order Breaklines"]]
+            ACCOUNT_PANEL[["[Account] Account Info Panel<br/>Balance, Equity<br/>Margin, Free Margin"]]
+            TRADE_PANEL[["[Trade] Trade Controls<br/>Market Orders<br/>Pending Orders"]]
+            HISTORY_PANEL[["[History] History Download<br/>OHLC/Tick CSV Export"]]
+            RECORD_PANEL[["[REC] Live Recording<br/>Real-time CSV Capture"]]
+            POSITIONS_PANEL[["[Pos] Active Positions<br/>Close Management"]]
+            ORDERS_PANEL[["[Orders] Pending Orders<br/>Cancel Management"]]
+        end
+        
+        TICK_TASK --> TICK_CHAN
+        ORDER_TASK <--> ORDER_CHAN
+        ORDER_TASK <--> RESPONSE_CHAN
+        
+        TICK_CHAN --> STATE
+        STATE <--> ORDER_CHAN
+        RESPONSE_CHAN --> STATE
+        
+        STATE --> CHART
+        STATE --> ACCOUNT_PANEL
+        STATE --> TRADE_PANEL
+        STATE --> HISTORY_PANEL
+        STATE --> RECORD_PANEL
+        STATE --> POSITIONS_PANEL
+        STATE --> ORDERS_PANEL
+    end
+    
+    EA --> PUB_SOCKET
+    EA <--> REP_SOCKET
+    
+    PUB_SOCKET -.->|JSON Tick Stream<br/>Non-blocking| TICK_TASK
+    ORDER_TASK -.->|JSON Request<br/>Blocking| REP_SOCKET
+    REP_SOCKET -.->|JSON Response<br/>Blocking| ORDER_TASK
+    
+    style USER_SPACE fill:#f0f0f0,stroke:#666,stroke-width:2px
+    style MT5_PLATFORM fill:#e6f3ff,stroke:#0066cc,stroke-width:3px
+    style AUTH fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+    style ZMQ_LAYER fill:#f0fff0,stroke:#00cc00,stroke-width:3px
+    style RUST_APP fill:#ffe6f0,stroke:#cc0066,stroke-width:3px
+    style SESSION fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+```
+
+---
+
+## Security Architecture
+
+### Authentication Flow & Credential Isolation
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant MT5_GUI as MT5 Terminal GUI
+    participant Broker as Broker Server
+    participant Session as Authenticated Session
+    participant EA as MQL5 Expert Advisor
+    participant ZMQ as ZeroMQ Sockets
+    participant Rust as Rust Application
+    
+    rect rgb(255, 240, 200)
+        Note over User,Session: Phase 1: One-Time Authentication (Manual)
+        User->>MT5_GUI: Enter credentials<br/>• Account ID: 12345678<br/>• Password: ********<br/>• Server: MetaQuotes-Demo
+        MT5_GUI->>Broker: Authenticate
+        Broker-->>MT5_GUI: [+] Authentication Success
+        MT5_GUI->>Session: Create Authenticated Session
+        Note over Session: Session stores:<br/>[+] Account credentials<br/>[+] Server connection<br/>[+] Trading permissions<br/>[+] Account state
+    end
+    
+    rect rgb(230, 255, 230)
+        Note over Session,EA: Phase 2: EA Initialization (Session Inheritance)
+        User->>MT5_GUI: Attach EA to chart
+        MT5_GUI->>EA: OnInit()
+        EA->>Session: Request session access
+        Session-->>EA: [+] Grant access (no credentials needed)
+        Note over EA: EA now has:<br/>[+] Authenticated session<br/>[+] Account info access<br/>[+] Trading permissions<br/>[-] NO credentials stored
+    end
+    
+    rect rgb(230, 240, 255)
+        Note over EA,Rust: Phase 3: External Communication (Credential-Free)
+        EA->>ZMQ: Bind PUB socket (port 5555)
+        EA->>ZMQ: Bind REP socket (port 5556)
+        Rust->>ZMQ: Connect SUB socket (127.0.0.1:5555)
+        Rust->>ZMQ: Connect REQ socket (127.0.0.1:5556)
+        Note over ZMQ,Rust: [+] Only localhost TCP addresses<br/>[-] NO credentials transmitted<br/>[-] NO authentication required
+    end
+    
+    rect rgb(255, 230, 230)
+        Note over EA,Rust: Phase 4: Runtime Operations (Secure)
+        loop Every Tick
+            EA->>Session: AccountInfoDouble(ACCOUNT_BALANCE)
+            Session-->>EA: balance value
+            EA->>Session: AccountInfoDouble(ACCOUNT_EQUITY)
+            Session-->>EA: equity value
+            EA->>ZMQ: Publish JSON {balance, equity, ...}
+            ZMQ-->>Rust: Receive data (no auth needed)
+        end
+        
+        Rust->>ZMQ: Send order request {type: "market_buy", ...}
+        ZMQ-->>EA: Receive request
+        EA->>Session: Execute trade via CTrade
+        Session-->>EA: Trade result
+        EA->>ZMQ: Send response {success: true, ticket: ...}
+        ZMQ-->>Rust: Receive response
+    end
+```
+
+### Security Comparison: MT5 Python API vs. MQL5+ZMQ+Rust
+
+| Security Aspect | MT5 Python API | MQL5 + ZeroMQ + Rust |
+|----------------|----------------|----------------------|
+| **Credentials in Code** | Required (`account`, `password`, `server`) | Not Required |
+| **Credential Storage** | Must store in config/env vars | No storage needed |
+| **Credential Transmission** | Transmitted via Python API | Never transmitted |
+| **Authentication Method** | Programmatic (code-based) | Manual (GUI-based) |
+| **Session Model** | Python creates new session | EA inherits existing session |
+| **Attack Surface** | High (credentials exposed) | Low (no credentials) |
+| **Version Control Risk** | High (accidental commits) | None |
+| **Network Exposure** | Depends on configuration | Localhost only (default) |
+| **Credential Interception** | Possible during transmission | Not applicable |
+| **Separation of Concerns** | Mixed (auth + trading) | Clear (auth separate) |
+
+### Account Information Access Pattern
+
+```mermaid
+flowchart LR
+    subgraph MT5["MT5 Authenticated Session"]
+        ACC_API["Account Info API<br/>AccountInfoDouble()"]
+        ACC_DATA[(Account Data<br/>ACCOUNT_BALANCE<br/>ACCOUNT_EQUITY<br/>ACCOUNT_MARGIN<br/>ACCOUNT_MARGIN_FREE)]
+    end
+    
+    subgraph EA["Expert Advisor"]
+        FETCH[Fetch Account Info<br/>Lines 366-369]
+        JSON_BUILD[Build JSON Payload<br/>Lines 428-443]
+    end
+    
+    subgraph ZMQ["ZeroMQ"]
+        PUB[PUB Socket<br/>Port 5555]
+    end
+    
+    subgraph RUST["Rust App"]
+        PARSE[Parse JSON<br/>Lines 745-753]
+        UPDATE[Update State<br/>Lines 338-348]
+        DISPLAY[Display in GUI<br/>Lines 449-466]
+    end
+    
+    ACC_API --> ACC_DATA
+    ACC_DATA -->|No credentials needed| FETCH
+    FETCH --> JSON_BUILD
+    JSON_BUILD --> PUB
+    PUB -.->|JSON over TCP| PARSE
+    PARSE --> UPDATE
+    UPDATE --> DISPLAY
+    
+    style ACC_DATA fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+    style FETCH fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style PUB fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+    style DISPLAY fill:#ffe6f0,stroke:#cc0066,stroke-width:2px
+```
+
+---
+
+## Component Deep Dive
+
+### 1. MQL5 Expert Advisor: ZmqPublisher.mq5
+
+#### File Structure
+- **Location**: `MQL5/Experts/ZmqPublisher.mq5`
+- **Lines**: 451
+- **Size**: 19,014 bytes
+- **Dependencies**: `Zmq.mqh`, `Trade.mqh`
+
+#### Input Parameters
+
+```mql5
+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)
+```
+
+#### Global Variables
+
+```mql5
+CZmq *g_publisher;  // PUB socket for tick data broadcasting
+CZmq *g_responder;  // REP socket for order request handling
+CTrade g_trade;     // MT5 trading helper class
+```
+
+#### Initialization Sequence (OnInit)
+
+```mermaid
+flowchart TD
+    START([OnInit Called]) --> INIT_PUB[Create CZmq Publisher]
+    INIT_PUB --> PUB_INIT{Init ZMQ_PUB?}
+    PUB_INIT -->|Failed| FAIL1[Return INIT_FAILED]
+    PUB_INIT -->|Success| PUB_BIND{Bind to Port 5555?}
+    PUB_BIND -->|Failed| FAIL2[Return INIT_FAILED]
+    PUB_BIND -->|Success| INIT_REP[Create CZmq Responder]
+    
+    INIT_REP --> REP_INIT{Init ZMQ_REP?}
+    REP_INIT -->|Failed| FAIL3[Return INIT_FAILED]
+    REP_INIT -->|Success| REP_BIND{Bind to Port 5556?}
+    REP_BIND -->|Failed| FAIL4[Return INIT_FAILED]
+    REP_BIND -->|Success| CONFIG_TRADE[Configure CTrade]
+    
+    CONFIG_TRADE --> SET_SLIP[SetDeviationInPoints]
+    SET_SLIP --> SET_FILL[SetTypeFilling IOC]
+    SET_FILL --> SUCCESS[Return INIT_SUCCEEDED]
+    
+    style START fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style SUCCESS fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+    style FAIL1 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+    style FAIL2 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+    style FAIL3 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+    style FAIL4 fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+```
+
+#### OnTick() Processing Flow
+
+```mermaid
+flowchart TB
+    TICK([OnTick Event]) --> CHECK_REQ{Check REP Socket<br/>Non-blocking}
+    
+    CHECK_REQ -->|Request Available| RECV_REQ[Receive Request JSON]
+    RECV_REQ --> PROCESS[ProcessOrderRequest]
+    PROCESS --> SEND_RESP[Send Response JSON<br/>Blocking]
+    SEND_RESP --> CHECK_PUB
+    
+    CHECK_REQ -->|No Request| CHECK_PUB{Check Publisher}
+    
+    CHECK_PUB -->|NULL| END([Return])
+    CHECK_PUB -->|Valid| GET_TICK[SymbolInfoTick]
+    
+    GET_TICK --> GET_ACCOUNT[Get Account Info<br/>Lines 366-369]
+    GET_ACCOUNT --> GET_CONSTRAINTS[Get Symbol Constraints<br/>Lines 372-374]
+    GET_CONSTRAINTS --> GET_POSITIONS[Get Active Positions<br/>Lines 377-397]
+    GET_POSITIONS --> GET_ORDERS[Get Pending Orders<br/>Lines 400-425]
+    GET_ORDERS --> BUILD_JSON[Build Complete JSON<br/>Lines 428-443]
+    BUILD_JSON --> PUBLISH[Publish to PUB Socket<br/>Line 445]
+    PUBLISH --> END
+    
+    style TICK fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style GET_ACCOUNT fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+    style PUBLISH fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+```
+
+#### Account Information Fetching (Detailed)
+
+**Lines 366-369: Account Info Retrieval**
+
+```mql5
+// Get account info
+double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+double equity = AccountInfoDouble(ACCOUNT_EQUITY);
+double margin = AccountInfoDouble(ACCOUNT_MARGIN);
+double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+```
+
+**MQL5 Account Info Functions**:
+- `AccountInfoDouble(ACCOUNT_BALANCE)` - Current account balance
+- `AccountInfoDouble(ACCOUNT_EQUITY)` - Current equity (balance + floating P/L)
+- `AccountInfoDouble(ACCOUNT_MARGIN)` - Margin currently used
+- `AccountInfoDouble(ACCOUNT_MARGIN_FREE)` - Free margin available
+
+**Security Note**: These functions access the authenticated session's account data **without requiring credentials**. The EA inherits the session from the MT5 terminal.
+
+#### Symbol Trading Constraints (Lines 372-374)
+
+```mql5
+// 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);
+```
+
+#### Position Fetching Loop (Lines 377-397)
+
+```mql5
+// 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, "]");
+```
+
+#### Order Request Processing (Lines 87-188)
+
+```mermaid
+flowchart TD
+    START([ProcessOrderRequest]) --> PARSE[Parse JSON Request<br/>Extract: type, symbol, volume, price, ticket]
+    
+    PARSE --> ROUTE{Route by Type}
+    
+    ROUTE -->|market_buy| MB[Get ASK price<br/>g_trade.Buy]
+    ROUTE -->|market_sell| MS[Get BID price<br/>g_trade.Sell]
+    ROUTE -->|limit_buy| LB[g_trade.BuyLimit]
+    ROUTE -->|limit_sell| LS[g_trade.SellLimit]
+    ROUTE -->|stop_buy| SB[g_trade.BuyStop]
+    ROUTE -->|stop_sell| SS[g_trade.SellStop]
+    ROUTE -->|close_position| CP[g_trade.PositionClose]
+    ROUTE -->|cancel_order| CO[g_trade.OrderDelete]
+    ROUTE -->|download_history| DH[DownloadHistory]
+    ROUTE -->|unknown| ERR[Unknown order type]
+    
+    MB --> CHECK{Success?}
+    MS --> CHECK
+    LB --> CHECK
+    LS --> CHECK
+    SB --> CHECK
+    SS --> CHECK
+    CP --> CHECK
+    CO --> CHECK
+    DH --> CHECK
+    ERR --> BUILD_FAIL
+    
+    CHECK -->|Yes| BUILD_SUCCESS["Build Success JSON<br/>{success: true, ticket: ...}"]
+    CHECK -->|No| BUILD_FAIL["Build Failure JSON<br/>{success: false, error: ...}"]
+    
+    BUILD_SUCCESS --> RETURN[Return JSON Response]
+    BUILD_FAIL --> RETURN
+    
+    style START fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style BUILD_SUCCESS fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+    style BUILD_FAIL fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+```
+
+### 2. ZMQ Wrapper: Zmq.mqh
+
+#### File Structure
+- **Location**: `MQL5/Include/Zmq/Zmq.mqh`
+- **Lines**: 145
+- **Size**: 4,100 bytes
+- **Purpose**: MQL5 wrapper around libzmq.dll
+
+#### Class Structure
+
+```mermaid
+classDiagram
+    class CZmq {
+        -long m_context
+        -long m_socket
+        -bool m_initialized
+        +CZmq()
+        +~CZmq()
+        +bool Init(int type)
+        +bool Bind(string endpoint)
+        +bool Connect(string endpoint)
+        +int Send(string message, bool nonBlocking)
+        +string Receive(bool nonBlocking)
+        +void Shutdown()
+    }
+    
+    class libzmq_dll {
+        <<external>>
+        +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()
+    }
+    
+    CZmq --> libzmq_dll : imports
+```
+
+#### Socket Type Constants
+
+```mql5
+#define ZMQ_PUB 1    // Publisher socket (one-to-many)
+#define ZMQ_SUB 2    // Subscriber socket (many-to-one)
+#define ZMQ_REQ 3    // Request socket (synchronous client)
+#define ZMQ_REP 4    // Reply socket (synchronous server)
+#define ZMQ_NOBLOCK 1 // Non-blocking flag
+```
+
+#### Method Details
+
+**Init(int type)** - Lines 51-68
+```mql5
+bool Init(int type) {
+   if(m_initialized) return true;
+   
+   m_context = zmq_ctx_new();  // Create ZMQ context
+   if(m_context == 0) {
+      Print("ZMQ Init failed: Context creation error");
+      return false;
+   }
+   
+   m_socket = zmq_socket(m_context, type);  // Create socket of specified type
+   if(m_socket == 0) {
+      Print("ZMQ Init failed: Socket creation error");
+      return false;
+   }
+   
+   m_initialized = true;
+   return true;
+}
+```
+
+**Send(string message, bool nonBlocking)** - Lines 98-114
+```mql5
+int Send(string message, bool nonBlocking = true) {
+   if(!m_initialized) return -1;
+   
+   uchar data[];
+   StringToCharArray(message, data, 0, WHOLE_ARRAY, CP_UTF8);
+   int len = ArraySize(data) - 1; // Exclude null terminator
+   if (len < 0) len = 0;
+
+   int flags = 0;
+   if(nonBlocking) flags = ZMQ_NOBLOCK;
+   
+   int bytesSent = zmq_send(m_socket, data, len, flags);
+   return bytesSent;
+}
+```
+
+**Receive(bool nonBlocking)** - Lines 117-131
+```mql5
+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);
+}
+```
+
+### 3. Rust Application: main.rs
+
+#### File Structure
+- **Location**: `Rustmt5-chart/src/main.rs`
+- **Lines**: 853
+- **Size**: 35,504 bytes
+- **Language**: Rust 2021 Edition
+
+#### Dependencies (Cargo.toml)
+
+```toml
+[dependencies]
+eframe = "0.27"           # egui framework
+egui = "0.27"             # Immediate mode GUI
+egui_plot = "0.27"        # Plotting library
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"        # JSON serialization
+tokio = { version = "1", features = ["full"] }
+zeromq = "0.3"            # ZeroMQ bindings
+chrono = "0.4"            # Date/time handling
+```
+
+#### Data Structure Hierarchy
+
+```mermaid
+classDiagram
+    class TickData {
+        +String symbol
+        +f64 bid
+        +f64 ask
+        +i64 time
+        +u64 volume
+        +f64 balance
+        +f64 equity
+        +f64 margin
+        +f64 free_margin
+        +f64 min_lot
+        +f64 max_lot
+        +f64 lot_step
+        +Vec~PositionData~ positions
+        +Vec~PendingOrderData~ orders
+    }
+    
+    class PositionData {
+        +u64 ticket
+        +String pos_type
+        +f64 volume
+        +f64 price
+        +f64 profit
+    }
+    
+    class PendingOrderData {
+        +u64 ticket
+        +String order_type
+        +f64 volume
+        +f64 price
+    }
+    
+    class OrderRequest {
+        +String order_type
+        +String symbol
+        +f64 volume
+        +f64 price
+        +u64 ticket
+        +Option~String~ timeframe
+        +Option~String~ start
+        +Option~String~ end
+        +Option~String~ mode
+        +Option~u64~ request_id
+    }
+    
+    class OrderResponse {
+        +bool success
+        +Option~i64~ ticket
+        +Option~String~ error
+        +Option~String~ message
+    }
+    
+    class OrderBreakline {
+        +usize index
+        +String order_type
+        +i64 ticket
+    }
+    
+    class Mt5ChartApp {
+        +Receiver~TickData~ tick_receiver
+        +Vec~TickData~ data
+        +String symbol
+        +f64 balance
+        +f64 equity
+        +f64 margin
+        +f64 free_margin
+        +Sender~OrderRequest~ order_sender
+        +Receiver~OrderResponse~ response_receiver
+        +Vec~PositionData~ positions
+        +Vec~PendingOrderData~ pending_orders
+        +Vec~OrderBreakline~ order_breaklines
+        +update()
+        +send_order()
+        +send_download_request()
+    }
+    
+    TickData "1" *-- "*" PositionData
+    TickData "1" *-- "*" PendingOrderData
+    Mt5ChartApp "1" *-- "*" TickData
+    Mt5ChartApp "1" *-- "*" OrderBreakline
+```
+
+---
+
+## Data Flow & Communication Patterns
+
+### Complete Tick Data Flow
+
+```mermaid
+sequenceDiagram
+    participant MT5 as MT5 Market
+    participant EA as ZmqPublisher.mq5
+    participant PUB as PUB Socket :5555
+    participant SUB as SUB Socket (Rust)
+    participant CHAN as Tick Channel
+    participant APP as Mt5ChartApp
+    participant GUI as egui GUI
+    
+    rect rgb(230, 255, 230)
+        Note over MT5,EA: Every Tick Event
+        MT5->>EA: OnTick()
+        
+        EA->>EA: SymbolInfoTick(_Symbol, tick)
+        EA->>EA: AccountInfoDouble(ACCOUNT_BALANCE)
+        EA->>EA: AccountInfoDouble(ACCOUNT_EQUITY)
+        EA->>EA: AccountInfoDouble(ACCOUNT_MARGIN)
+        EA->>EA: AccountInfoDouble(ACCOUNT_MARGIN_FREE)
+        EA->>EA: SymbolInfoDouble(SYMBOL_VOLUME_MIN/MAX/STEP)
+        
+        loop For each position
+            EA->>EA: PositionGetTicket(i)
+            EA->>EA: Build position JSON
+        end
+        
+        loop For each order
+            EA->>EA: OrderGetTicket(i)
+            EA->>EA: Build order JSON
+        end
+        
+        EA->>EA: StringConcatenate(json, ...)
+        EA->>PUB: Send(json, non-blocking)
+    end
+    
+    rect rgb(230, 240, 255)
+        Note over PUB,APP: Async Rust Processing
+        PUB-->>SUB: TCP transmission
+        SUB->>SUB: recv().await
+        SUB->>SUB: serde_json::from_str::<TickData>()
+        SUB->>CHAN: tick_tx.send(tick).await
+        
+        CHAN-->>APP: tick_receiver.try_recv()
+        APP->>APP: Update balance, equity, margin
+        APP->>APP: Update positions, orders
+        APP->>APP: data.push(tick)
+        APP->>APP: Record to CSV if recording
+    end
+    
+    rect rgb(255, 240, 230)
+        Note over APP,GUI: GUI Update (60 FPS)
+        APP->>GUI: update(&mut self, ctx, frame)
+        GUI->>GUI: Draw price chart
+        GUI->>GUI: Draw account panel
+        GUI->>GUI: Draw positions/orders
+        GUI->>GUI: ctx.request_repaint()
+    end
+```
+
+### Complete Order Execution Flow
+
+```mermaid
+sequenceDiagram
+    participant GUI as egui GUI
+    participant APP as Mt5ChartApp
+    participant CHAN as Order Channel
+    participant REQ as REQ Socket (Rust)
+    participant REP as REP Socket :5556
+    participant EA as ZmqPublisher.mq5
+    participant TRADE as CTrade Engine
+    participant MT5 as MT5 Terminal
+    
+    rect rgb(255, 240, 230)
+        Note over GUI,APP: User Interaction
+        GUI->>APP: Button clicked: "BUY"
+        APP->>APP: send_order("market_buy", None, None)
+        APP->>APP: Build OrderRequest struct
+        APP->>APP: serde_json::to_string(&request)
+        APP->>CHAN: order_sender.try_send(request)
+    end
+    
+    rect rgb(230, 240, 255)
+        Note over CHAN,EA: Async Order Task
+        CHAN-->>REQ: order_rx.recv().await
+        REQ->>REQ: Serialize to JSON
+        REQ->>REP: socket.send(json).await (blocking)
+        
+        REP-->>EA: Receive(non-blocking) in OnTick
+        EA->>EA: ProcessOrderRequest(request)
+        EA->>EA: ExtractJsonString(request, "type")
+        EA->>EA: ExtractJsonDouble(request, "volume")
+    end
+    
+    rect rgb(230, 255, 230)
+        Note over EA,MT5: Trade Execution
+        EA->>EA: if(orderType == "market_buy")
+        EA->>EA: askPrice = SymbolInfoDouble(SYMBOL_ASK)
+        EA->>TRADE: g_trade.Buy(volume, symbol, askPrice, 0, 0, "Rust GUI Order")
+        TRADE->>MT5: Execute market order
+        MT5-->>TRADE: Trade result
+        TRADE-->>EA: success = true, resultTicket = 12345678
+        
+        EA->>EA: Build response JSON
+        EA->>EA: {"success":true,"ticket":12345678}
+        EA->>REP: Send(response, blocking)
+    end
+    
+    rect rgb(240, 230, 255)
+        Note over REP,APP: Response Processing
+        REP-->>REQ: socket.recv().await (blocking)
+        REQ->>REQ: serde_json::from_str::<OrderResponse>()
+        REQ->>CHAN: response_tx.send(response).await
+        
+        CHAN-->>APP: response_receiver.try_recv()
+        APP->>APP: if response.success
+        APP->>APP: Create OrderBreakline
+        APP->>APP: order_breaklines.push(breakline)
+        APP->>APP: last_order_result = "✓ Order executed!"
+    end
+    
+    rect rgb(255, 240, 230)
+        Note over APP,GUI: GUI Feedback
+        APP->>GUI: Update chart with breakline
+        GUI->>GUI: Draw vertical line at execution point
+        GUI->>GUI: Display success message
+    end
+```
+
+---
+
+## Account Information Fetching
+
+### MQL5 Account Info API
+
+```mermaid
+flowchart LR
+    subgraph MT5_SESSION["MT5 Authenticated Session"]
+        AUTH[Authenticated User Session]
+        ACC_STATE[(Account State<br/>• Balance<br/>• Equity<br/>• Margin<br/>• Free Margin<br/>• Leverage<br/>• Currency)]
+    end
+    
+    subgraph MQL5_API["MQL5 Account API"]
+        API1[AccountInfoDouble<br/>ACCOUNT_BALANCE]
+        API2[AccountInfoDouble<br/>ACCOUNT_EQUITY]
+        API3[AccountInfoDouble<br/>ACCOUNT_MARGIN]
+        API4[AccountInfoDouble<br/>ACCOUNT_MARGIN_FREE]
+    end
+    
+    subgraph EA_CODE["Expert Advisor Code"]
+        FETCH["Lines 366-369:<br/>double balance = AccountInfoDouble(ACCOUNT_BALANCE);<br/>double equity = AccountInfoDouble(ACCOUNT_EQUITY);<br/>double margin = AccountInfoDouble(ACCOUNT_MARGIN);<br/>double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);"]
+    end
+    
+    AUTH --> ACC_STATE
+    ACC_STATE --> API1
+    ACC_STATE --> API2
+    ACC_STATE --> API3
+    ACC_STATE --> API4
+    
+    API1 --> FETCH
+    API2 --> FETCH
+    API3 --> FETCH
+    API4 --> FETCH
+    
+    style AUTH fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+    style ACC_STATE fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style FETCH fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+```
+
+### Account Info Constants (MQL5)
+
+| Constant | Type | Description |
+|----------|------|-------------|
+| `ACCOUNT_BALANCE` | double | Account balance in deposit currency |
+| `ACCOUNT_EQUITY` | double | Account equity (balance + floating P/L) |
+| `ACCOUNT_MARGIN` | double | Margin currently used |
+| `ACCOUNT_MARGIN_FREE` | double | Free margin available for trading |
+| `ACCOUNT_MARGIN_LEVEL` | double | Margin level percentage |
+| `ACCOUNT_PROFIT` | double | Current profit on all positions |
+| `ACCOUNT_CREDIT` | double | Credit amount |
+| `ACCOUNT_LEVERAGE` | long | Account leverage (e.g., 100 for 1:100) |
+| `ACCOUNT_CURRENCY` | string | Account currency (e.g., "USD") |
+
+### Rust Account Info Reception
+
+**Lines 338-348: Account Info Update**
+
+```rust
+// 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;
+    }
+}
+```
+
+**Lines 449-466: Account Info Display**
+
+```rust
+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();
+        });
+});
+```
+
+---
+
+## Complete Data Structures
+
+### JSON Tick Data Format (PUB/SUB Port 5555)
+
+```json
+{
+    "symbol": "XAUUSDc",
+    "bid": 2650.55,
+    "ask": 2650.75,
+    "time": 1706284800,
+    "volume": 100,
+    "balance": 10000.00,
+    "equity": 10150.25,
+    "margin": 500.00,
+    "free_margin": 9650.25,
+    "min_lot": 0.01,
+    "max_lot": 100.00,
+    "lot_step": 0.01,
+    "positions": [
+        {
+            "ticket": 12345678,
+            "type": "BUY",
+            "volume": 0.10,
+            "price": 2645.50,
+            "profit": 50.50
+        },
+        {
+            "ticket": 12345679,
+            "type": "SELL",
+            "volume": 0.05,
+            "price": 2655.00,
+            "profit": -25.00
+        }
+    ],
+    "orders": [
+        {
+            "ticket": 87654321,
+            "type": "BUY LIMIT",
+            "volume": 0.05,
+            "price": 2600.00
+        },
+        {
+            "ticket": 87654322,
+            "type": "SELL STOP",
+            "volume": 0.10,
+            "price": 2700.00
+        }
+    ]
+}
+```
+
+### JSON Order Request Format (REQ/REP Port 5556)
+
+**Market Order Request**:
+```json
+{
+    "type": "market_buy",
+    "symbol": "XAUUSDc",
+    "volume": 0.01,
+    "price": 0.0,
+    "ticket": 0
+}
+```
+
+**Pending Order Request**:
+```json
+{
+    "type": "limit_buy",
+    "symbol": "XAUUSDc",
+    "volume": 0.05,
+    "price": 2600.00,
+    "ticket": 0
+}
+```
+
+**Close Position Request**:
+```json
+{
+    "type": "close_position",
+    "symbol": "XAUUSDc",
+    "volume": 0.0,
+    "price": 0.0,
+    "ticket": 12345678
+}
+```
+
+**History Download Request**:
+```json
+{
+    "type": "download_history",
+    "symbol": "XAUUSDc",
+    "volume": 0.0,
+    "price": 0.0,
+    "ticket": 0,
+    "timeframe": "M1",
+    "start": "2024.01.01",
+    "end": "2024.01.31",
+    "mode": "OHLC",
+    "request_id": 1
+}
+```
+
+### JSON Order Response Format
+
+**Success Response**:
+```json
+{
+    "success": true,
+    "ticket": 12345678
+}
+```
+
+**Failure Response**:
+```json
+{
+    "success": false,
+    "error": "Error 10019: Not enough money"
+}
+```
+
+**History Download Success Response**:
+```json
+{
+    "success": true,
+    "message": "1000 records||CSV_DATA||Time,Open,High,Low,Close,TickVol,Spread|NL|2024.01.01 00:00,2650.50,2651.00,2650.00,2650.75,100,3|NL|..."
+}
+```
+
+---
+
+## ZeroMQ Layer Details
+
+### Socket Patterns
+
+```mermaid
+flowchart TB
+    subgraph PUB_SUB["PUB/SUB Pattern (Port 5555)"]
+        direction LR
+        PUB[Publisher<br/>ZmqPublisher.mq5]
+        SUB1[Subscriber 1<br/>Rust App]
+        SUB2[Subscriber 2<br/>Other Apps]
+        
+        PUB -->|Broadcast| SUB1
+        PUB -->|Broadcast| SUB2
+    end
+    
+    subgraph REQ_REP["REQ/REP Pattern (Port 5556)"]
+        direction LR
+        REQ[Request<br/>Rust App]
+        REP[Reply<br/>ZmqPublisher.mq5]
+        
+        REQ <-->|Synchronous| REP
+    end
+    
+    style PUB fill:#ccffcc,stroke:#00cc00,stroke-width:2px
+    style REP fill:#ffe6cc,stroke:#ff9900,stroke-width:2px
+```
+
+### Socket Configuration
+
+**PUB Socket (EA Side)**:
+```mql5
+g_publisher = new CZmq();
+g_publisher.Init(ZMQ_PUB);
+g_publisher.Bind("tcp://0.0.0.0:5555");  // Bind to all interfaces
+g_publisher.Send(json, true);            // Non-blocking send
+```
+
+**SUB Socket (Rust Side)**:
+```rust
+let mut socket = zeromq::SubSocket::new();
+socket.connect("tcp://127.0.0.1:5555").await;  // Connect to localhost
+socket.subscribe("").await;                     // Subscribe to all messages
+let msg = socket.recv().await;                  // Blocking receive
+```
+
+**REP Socket (EA Side)**:
+```mql5
+g_responder = new CZmq();
+g_responder.Init(ZMQ_REP);
+g_responder.Bind("tcp://0.0.0.0:5556");     // Bind to all interfaces
+string request = g_responder.Receive(true);  // Non-blocking receive
+g_responder.Send(response, false);           // Blocking send (REP pattern)
+```
+
+**REQ Socket (Rust Side)**:
+```rust
+let mut socket = zeromq::ReqSocket::new();
+socket.connect("tcp://127.0.0.1:5556").await;  // Connect to localhost
+socket.send(json_request.into()).await;        // Blocking send
+let msg = socket.recv().await;                  // Blocking receive
+```
+
+---
+
+## Async Task Management
+
+### Tokio Runtime Architecture
+
+```mermaid
+flowchart TB
+    subgraph TOKIO["Tokio Async Runtime"]
+        MAIN[tokio::main]
+        
+        subgraph TASKS["Spawned Tasks"]
+            TICK_TASK[Tick Subscriber Task<br/>Lines 731-763]
+            ORDER_TASK[Order Handler Task<br/>Lines 768-835]
+        end
+        
+        subgraph CHANNELS["MPSC Channels"]
+            TICK_CH[Tick Channel<br/>capacity: 100]
+            ORDER_CH[Order Channel<br/>capacity: 10]
+            RESP_CH[Response Channel<br/>capacity: 10]
+        end
+    end
+    
+    subgraph EGUI["eframe GUI (Blocking)"]
+        APP[Mt5ChartApp::update]
+    end
+    
+    MAIN --> TICK_TASK
+    MAIN --> ORDER_TASK
+    MAIN --> EGUI
+    
+    TICK_TASK --> TICK_CH
+    ORDER_TASK <--> ORDER_CH
+    ORDER_TASK <--> RESP_CH
+    
+    TICK_CH --> APP
+    APP --> ORDER_CH
+    RESP_CH --> APP
+    
+    style TOKIO fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style EGUI fill:#ffe6f0,stroke:#cc0066,stroke-width:2px
+```
+
+### Tick Subscriber Task (Lines 731-763)
+
+```rust
+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;
+            }
+        }
+    }
+});
+```
+
+### Order Handler Task (Lines 768-835)
+
+```rust
+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 (blocking in REQ/REP pattern)
+        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 (blocking in REQ/REP pattern)
+        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;
+            }
+        }
+    }
+});
+```
+
+---
+
+## File Structure & Dependencies
+
+### Complete Directory Structure
+
+```
+SUM3API/
+├── MQL5/
+│   ├── Experts/
+│   │   └── ZmqPublisher.mq5           # Main EA (451 lines, 19 KB)
+│   ├── Include/
+│   │   └── Zmq/
+│   │       └── Zmq.mqh                # ZMQ wrapper (145 lines, 4 KB)
+│   └── Libraries/
+│       ├── libzmq.dll                 # ZeroMQ native library
+│       └── libsodium.dll              # Crypto library (ZMQ dependency)
+│
+└── Rustmt5-chart/
+    ├── Cargo.toml                     # Rust dependencies
+    ├── Cargo.lock                     # Dependency lock file (117 KB)
+    ├── src/
+    │   └── main.rs                    # Main application (853 lines, 35 KB)
+    ├── output/                        # CSV output directory
+    │   ├── History_*.csv              # Downloaded historical data
+    │   └── Live_*.csv                 # Live recorded tick data
+    └── target/                        # Build artifacts
+        ├── debug/                     # Debug build
+        └── release/                   # Release build
+
+```
+
+### Dependency Graph
+
+```mermaid
+flowchart TB
+    subgraph MQL5_DEPS["MQL5 Dependencies"]
+        EA[ZmqPublisher.mq5]
+        ZMQ_MQH[Zmq.mqh]
+        TRADE_MQH[Trade.mqh<br/>MT5 Built-in]
+        LIBZMQ[libzmq.dll]
+        LIBSODIUM[libsodium.dll]
+    end
+    
+    subgraph RUST_DEPS["Rust Dependencies"]
+        MAIN[main.rs]
+        EFRAME[eframe 0.27]
+        EGUI[egui 0.27]
+        EGUI_PLOT[egui_plot 0.27]
+        SERDE[serde 1.0]
+        SERDE_JSON[serde_json 1.0]
+        TOKIO[tokio 1.x]
+        ZEROMQ[zeromq 0.3]
+        CHRONO[chrono 0.4]
+    end
+    
+    EA --> ZMQ_MQH
+    EA --> TRADE_MQH
+    ZMQ_MQH --> LIBZMQ
+    LIBZMQ --> LIBSODIUM
+    
+    MAIN --> EFRAME
+    MAIN --> EGUI_PLOT
+    MAIN --> SERDE
+    MAIN --> SERDE_JSON
+    MAIN --> TOKIO
+    MAIN --> ZEROMQ
+    MAIN --> CHRONO
+    EFRAME --> EGUI
+    
+    style EA fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style MAIN fill:#ffe6f0,stroke:#cc0066,stroke-width:2px
+```
+
+---
+
+## Summary
+
+This document provides a complete end-to-end technical specification of the MQL5 ↔ ZeroMQ ↔ Rust trading system, including:
+
+**Security Architecture**: Credential-free design with session inheritance  
+**Account Information Flow**: From MT5 API to Rust GUI  
+**Complete Data Structures**: JSON formats and Rust/MQL5 types  
+**Communication Patterns**: PUB/SUB and REQ/REP with sequence diagrams  
+**Async Task Management**: Tokio runtime and channel architecture  
+**Micro-level Implementation**: Line-by-line code references  
+**File Structure**: Complete dependency graph  
+
+**Key Security Advantage**: Unlike MT5's Python API which requires explicit credentials in code, this system leverages MT5's authenticated session, eliminating credential exposure entirely.
+
+---
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Algorembrant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MQL5-ZMQ Library for SUM3API.md

@@ -0,0 +1,1283 @@
+# MQL5 ZeroMQ Wrapper Library
+
+A comprehensive reusable MQL5 wrapper library for ZeroMQ socket operations, designed for real-time communication between MetaTrader 5 and external applications.
+
+---
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Architecture](#architecture)
+3. [Prerequisites and Installation](#prerequisites-and-installation)
+4. [API Reference](#api-reference)
+5. [Usage Guide](#usage-guide)
+6. [Socket Patterns](#socket-patterns)
+7. [Message Protocol](#message-protocol)
+8. [Complete Examples](#complete-examples)
+9. [Error Handling](#error-handling)
+10. [Best Practices](#best-practices)
+11. [Troubleshooting](#troubleshooting)
+
+---
+
+## Overview
+
+This library provides a high-level MQL5 wrapper around the native ZeroMQ (libzmq) library, enabling MetaTrader 5 Expert Advisors and indicators to communicate with external applications via TCP sockets.
+
+> [!NOTE]
+> For the companion Rust client library, see [Rust-ZMQ Library for SUM3API](Rust-ZMQ%20Library%20for%20SUM3API.md).
+
+### Key Features
+
+- **Simple API**: Object-oriented wrapper class with intuitive methods
+- **Multiple Socket Types**: Support for PUB, SUB, REQ, and REP patterns
+- **Non-blocking Operations**: Configurable blocking/non-blocking send and receive
+- **UTF-8 Support**: Automatic string encoding/decoding
+- **Resource Management**: Automatic cleanup on destruction
+
+### Supported Socket Types
+
+| Constant | Value | Description |
+|----------|-------|-------------|
+| `ZMQ_PUB` | 1 | Publisher socket for broadcasting messages |
+| `ZMQ_SUB` | 2 | Subscriber socket for receiving broadcasts |
+| `ZMQ_REQ` | 3 | Request socket for request/reply pattern (client) |
+| `ZMQ_REP` | 4 | Reply socket for request/reply pattern (server) |
+
+---
+
+## Architecture
+
+### System Overview
+
+```mermaid
+flowchart LR
+    subgraph MT5["MetaTrader 5"]
+        EA["ZmqPublisher EA"]
+        CZmq["CZmq Wrapper"]
+        DLL["libzmq.dll"]
+        EA --> CZmq
+        CZmq --> DLL
+    end
+
+    subgraph Network["ZeroMQ TCP/IP"]
+        PUB["PUB Socket<br/>tcp://0.0.0.0:5555"]
+        REP["REP Socket<br/>tcp://0.0.0.0:5556"]
+    end
+
+    subgraph Client["External Client"]
+        SUB["SUB Socket"]
+        REQ["REQ Socket"]
+        APP["Application<br/>(Rust/Go/Java/C++)"]
+        SUB --> APP
+        REQ --> APP
+    end
+
+    DLL --> PUB
+    DLL --> REP
+    PUB -->|"Tick Data (JSON)"| SUB
+    REQ <-->|"Order Request/Response"| REP
+```
+
+### Communication Flow
+
+```mermaid
+sequenceDiagram
+    participant MT5 as MetaTrader 5
+    participant PUB as PUB Socket :5555
+    participant SUB as SUB Socket
+    participant Client as External Client
+    participant REQ as REQ Socket
+    participant REP as REP Socket :5556
+
+    Note over MT5,Client: Tick Data Publishing (PUB/SUB)
+    MT5->>PUB: OnTick() - Create JSON
+    PUB->>SUB: Broadcast tick data
+    SUB->>Client: Parse and display
+
+    Note over MT5,Client: Order Handling (REQ/REP)
+    Client->>REQ: Create order request
+    REQ->>REP: Send JSON request
+    REP->>MT5: Receive and parse
+    MT5->>MT5: Execute order
+    MT5->>REP: Create response
+    REP->>REQ: Send JSON response
+    REQ->>Client: Parse result
+```
+
+### Pattern Details
+
+1. **Tick Data Publishing** (PUB/SUB Pattern)
+   - EA binds PUB socket to `tcp://0.0.0.0:5555`
+   - External client subscribes via SUB socket
+   - EA publishes tick data as JSON on every tick
+
+2. **Order Handling** (REQ/REP Pattern)
+   - EA binds REP socket to `tcp://0.0.0.0:5556`
+   - External client sends order requests via REQ socket
+   - EA processes orders and sends responses
+
+---
+
+## Prerequisites and Installation
+
+### Required Files
+
+Place the following files in your MetaTrader 5 installation directory:
+
+```
+MQL5/
+  |-- Libraries/
+  |     |-- libzmq.dll          # ZeroMQ core library
+  |     |-- libsodium.dll       # Cryptographic dependency for libzmq
+  |
+  |-- Include/
+  |     |-- Zmq/
+  |           |-- Zmq.mqh       # MQL5 wrapper class
+  |
+  |-- Experts/
+        |-- ZmqPublisher.mq5    # Example Expert Advisor
+```
+
+### Installation Steps
+
+1. **Download ZeroMQ Libraries**
+   - Download `libzmq.dll` (v4.3.x or later) from [ZeroMQ releases](https://github.com/zeromq/libzmq/releases)
+   - Download `libsodium.dll` from [libsodium releases](https://github.com/jedisct1/libsodium/releases)
+   - Both DLLs must be the same architecture (x64 for 64-bit MT5)
+
+2. **Copy Files**
+   ```
+   Copy libzmq.dll    --> MQL5/Libraries/
+   Copy libsodium.dll --> MQL5/Libraries/
+   Copy Zmq.mqh       --> MQL5/Include/Zmq/
+   ```
+
+3. **Enable DLL Imports in MetaTrader 5**
+   - Go to `Tools > Options > Expert Advisors`
+   - Enable "Allow DLL imports"
+   - Disable "Allow DLL imports only for signed DLLs" (or sign the DLLs)
+
+4. **Compile Your EA**
+   - Open MetaEditor
+   - Include the wrapper: `#include <Zmq/Zmq.mqh>`
+   - Compile your Expert Advisor
+
+---
+
+## API Reference
+
+### Class: CZmq
+
+The main wrapper class for ZeroMQ operations.
+
+#### Constructor and Destructor
+
+```cpp
+CZmq()
+```
+Creates a new CZmq instance. Does not initialize any ZMQ resources.
+
+```cpp
+~CZmq()
+```
+Destructor. Automatically calls `Shutdown()` to clean up resources.
+
+---
+
+#### Init
+
+```cpp
+bool Init(int type)
+```
+
+Initializes the ZeroMQ context and creates a socket of the specified type.
+
+**Parameters:**
+| Name | Type | Description |
+|------|------|-------------|
+| `type` | `int` | Socket type: `ZMQ_PUB`, `ZMQ_SUB`, `ZMQ_REQ`, or `ZMQ_REP` |
+
+**Returns:**
+- `true` if initialization succeeded
+- `false` if context or socket creation failed
+
+**Example:**
+```cpp
+CZmq *publisher = new CZmq();
+if(!publisher.Init(ZMQ_PUB)) {
+    Print("Failed to initialize ZMQ publisher");
+    return INIT_FAILED;
+}
+```
+
+---
+
+#### Bind
+
+```cpp
+bool Bind(string endpoint)
+```
+
+Binds the socket to a local endpoint. Typically used by server-side sockets (PUB, REP).
+
+**Parameters:**
+| Name | Type | Description |
+|------|------|-------------|
+| `endpoint` | `string` | ZMQ endpoint URL (e.g., `"tcp://0.0.0.0:5555"`) |
+
+**Returns:**
+- `true` if binding succeeded
+- `false` if binding failed (check logs for error code)
+
+**Endpoint Formats:**
+| Format | Description |
+|--------|-------------|
+| `tcp://*:5555` | Bind to all interfaces on port 5555 |
+| `tcp://0.0.0.0:5555` | Same as above |
+| `tcp://127.0.0.1:5555` | Bind to localhost only |
+| `ipc:///tmp/socket` | Inter-process communication (Unix only) |
+
+**Example:**
+```cpp
+if(!publisher.Bind("tcp://0.0.0.0:5555")) {
+    Print("Failed to bind to port 5555");
+    return INIT_FAILED;
+}
+```
+
+---
+
+#### Connect
+
+```cpp
+bool Connect(string endpoint)
+```
+
+Connects the socket to a remote endpoint. Typically used by client-side sockets (SUB, REQ).
+
+**Parameters:**
+| Name | Type | Description |
+|------|------|-------------|
+| `endpoint` | `string` | ZMQ endpoint URL (e.g., `"tcp://127.0.0.1:5555"`) |
+
+**Returns:**
+- `true` if connection initiated successfully
+- `false` if connection failed
+
+**Example:**
+```cpp
+CZmq *subscriber = new CZmq();
+subscriber.Init(ZMQ_SUB);
+if(!subscriber.Connect("tcp://127.0.0.1:5555")) {
+    Print("Failed to connect to publisher");
+}
+```
+
+---
+
+#### Send
+
+```cpp
+int Send(string message, bool nonBlocking = true)
+```
+
+Sends a string message through the socket.
+
+**Parameters:**
+| Name | Type | Description |
+|------|------|-------------|
+| `message` | `string` | The message to send (UTF-8 encoded) |
+| `nonBlocking` | `bool` | If `true`, returns immediately. If `false`, blocks until sent. Default: `true` |
+
+**Returns:**
+- Number of bytes sent on success
+- `-1` on failure
+
+**Example:**
+```cpp
+string json = "{\"symbol\":\"EURUSD\",\"bid\":1.1234}";
+int bytes = publisher.Send(json, false);  // Blocking send
+if(bytes < 0) {
+    Print("Send failed");
+}
+```
+
+---
+
+#### Receive
+
+```cpp
+string Receive(bool nonBlocking = true)
+```
+
+Receives a message from the socket.
+
+**Parameters:**
+| Name | Type | Description |
+|------|------|-------------|
+| `nonBlocking` | `bool` | If `true`, returns immediately with empty string if no message. If `false`, blocks until message received. Default: `true` |
+
+**Returns:**
+- Received message as string on success
+- Empty string `""` if no message available (non-blocking) or on error
+
+**Buffer Size:**
+- Maximum receive buffer is 4096 bytes
+- For larger messages, modify the `buffer[4096]` in `Zmq.mqh`
+
+**Example:**
+```cpp
+// Non-blocking receive (polling)
+string msg = responder.Receive(true);
+if(msg != "") {
+    Print("Received: ", msg);
+}
+
+// Blocking receive (waits for message)
+string msg = requester.Receive(false);
+```
+
+---
+
+#### Shutdown
+
+```cpp
+void Shutdown()
+```
+
+Closes the socket and terminates the ZMQ context. Should be called during cleanup.
+
+**Example:**
+```cpp
+void OnDeinit(const int reason) {
+    if(g_publisher != NULL) {
+        g_publisher.Shutdown();
+        delete g_publisher;
+        g_publisher = NULL;
+    }
+}
+```
+
+---
+
+## Usage Guide
+
+### Step 1: Include the Library
+
+```cpp
+#include <Zmq/Zmq.mqh>
+```
+
+### Step 2: Declare Global Instance
+
+```cpp
+CZmq *g_publisher;  // Declare as pointer for proper lifecycle management
+```
+
+### Step 3: Initialize in OnInit()
+
+```cpp
+int OnInit() {
+    g_publisher = new CZmq();
+    
+    if(!g_publisher.Init(ZMQ_PUB)) {
+        Print("ZMQ initialization failed");
+        return INIT_FAILED;
+    }
+    
+    if(!g_publisher.Bind("tcp://0.0.0.0:5555")) {
+        Print("ZMQ bind failed");
+        return INIT_FAILED;
+    }
+    
+    Print("ZMQ Publisher ready on port 5555");
+    return INIT_SUCCEEDED;
+}
+```
+
+### Step 4: Use in OnTick()
+
+```cpp
+void OnTick() {
+    MqlTick tick;
+    if(SymbolInfoTick(_Symbol, tick)) {
+        string json;
+        StringConcatenate(json, 
+            "{\"symbol\":\"", _Symbol, 
+            "\",\"bid\":", DoubleToString(tick.bid, _Digits),
+            ",\"ask\":", DoubleToString(tick.ask, _Digits), 
+            "}");
+        
+        g_publisher.Send(json);
+    }
+}
+```
+
+### Step 5: Cleanup in OnDeinit()
+
+```cpp
+void OnDeinit(const int reason) {
+    if(g_publisher != NULL) {
+        g_publisher.Shutdown();
+        delete g_publisher;
+        g_publisher = NULL;
+    }
+}
+```
+
+---
+
+## Socket Patterns
+
+### PUB/SUB Pattern (One-to-Many Broadcasting)
+
+```mermaid
+flowchart LR
+    PUB["Publisher\n(MT5 EA)"]
+    SUB1["Subscriber 1\n(Rust App)"]
+    SUB2["Subscriber 2\n(Go Service)"]
+    SUB3["Subscriber 3\n(Java Dashboard)"]
+    
+    PUB -->|"Tick JSON"| SUB1
+    PUB -->|"Tick JSON"| SUB2
+    PUB -->|"Tick JSON"| SUB3
+```
+
+Used for real-time data streaming where the publisher broadcasts to all connected subscribers.
+
+**MQL5 Side (Publisher):**
+```cpp
+CZmq *publisher = new CZmq();
+publisher.Init(ZMQ_PUB);
+publisher.Bind("tcp://0.0.0.0:5555");
+
+// In OnTick
+publisher.Send("{\"bid\": 1.1234}");
+```
+
+**Rust Client Side (Subscriber):**
+```rust
+use zeromq::{Socket, SubSocket};
+
+let mut socket = SubSocket::new();
+socket.connect("tcp://127.0.0.1:5555").await?;
+socket.subscribe("").await?;  // Subscribe to all messages
+
+loop {
+    let msg = socket.recv().await?;
+    println!("Received: {:?}", msg);
+}
+```
+
+**Go Client Side (Subscriber):**
+```go
+package main
+
+import (
+    "fmt"
+    zmq "github.com/pebbe/zmq4"
+)
+
+func main() {
+    subscriber, _ := zmq.NewSocket(zmq.SUB)
+    defer subscriber.Close()
+    
+    subscriber.Connect("tcp://127.0.0.1:5555")
+    subscriber.SetSubscribe("")  // Subscribe to all messages
+    
+    for {
+        msg, _ := subscriber.Recv(0)
+        fmt.Printf("Received: %s\n", msg)
+    }
+}
+```
+
+---
+
+### REQ/REP Pattern (Request-Reply)
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant REQ as REQ Socket
+    participant REP as REP Socket
+    participant MT5 as MT5 EA
+
+    Client->>REQ: market_buy request
+    REQ->>REP: Send JSON
+    REP->>MT5: Receive()
+    MT5->>MT5: g_trade.Buy()
+    MT5->>REP: Send response
+    REP->>REQ: JSON response
+    REQ->>Client: {success: true, ticket: 12345}
+```
+
+Used for command-response communication, such as order execution.
+
+**MQL5 Side (Responder):**
+```cpp
+CZmq *responder = new CZmq();
+responder.Init(ZMQ_REP);
+responder.Bind("tcp://0.0.0.0:5556");
+
+// In OnTick (non-blocking poll)
+string request = responder.Receive(true);
+if(request != "") {
+    // Process request
+    string response = ProcessOrderRequest(request);
+    responder.Send(response, false);  // Blocking send required for REP
+}
+```
+
+**Rust Client Side (Requester):**
+```rust
+use zeromq::{Socket, ReqSocket};
+
+let mut socket = ReqSocket::new();
+socket.connect("tcp://127.0.0.1:5556").await?;
+
+// Send order request
+let request = r#"{"type":"market_buy","symbol":"EURUSD","volume":0.01}"#;
+socket.send(request.into()).await?;
+
+// Wait for response
+let response = socket.recv().await?;
+println!("Response: {:?}", response);
+```
+
+**Go Client Side (Requester):**
+```go
+package main
+
+import (
+    "fmt"
+    zmq "github.com/pebbe/zmq4"
+)
+
+func main() {
+    requester, _ := zmq.NewSocket(zmq.REQ)
+    defer requester.Close()
+    
+    requester.Connect("tcp://127.0.0.1:5556")
+    
+    // Send order request
+    request := `{"type":"market_buy","symbol":"EURUSD","volume":0.01}`
+    requester.Send(request, 0)
+    
+    // Wait for response
+    response, _ := requester.Recv(0)
+    fmt.Printf("Response: %s\n", response)
+}
+```
+
+---
+
+## Message Protocol
+
+### Tick Data Message (PUB Socket)
+
+Published on every tick from MQL5 to connected subscribers.
+
+```json
+{
+    "symbol": "XAUUSDc",
+    "bid": 2345.67,
+    "ask": 2345.89,
+    "time": 1706400000,
+    "volume": 100,
+    "balance": 10000.00,
+    "equity": 10150.50,
+    "margin": 500.00,
+    "free_margin": 9650.50,
+    "min_lot": 0.01,
+    "max_lot": 100.00,
+    "lot_step": 0.01,
+    "positions": [
+        {
+            "ticket": 12345,
+            "type": "BUY",
+            "volume": 0.10,
+            "price": 2340.50,
+            "profit": 15.25
+        }
+    ],
+    "orders": [
+        {
+            "ticket": 12346,
+            "type": "BUY LIMIT",
+            "volume": 0.05,
+            "price": 2330.00
+        }
+    ]
+}
+```
+
+### Order Request Message (REQ Socket)
+
+Sent from external client to MQL5 for order execution.
+
+**Market Order:**
+```json
+{
+    "type": "market_buy",
+    "symbol": "XAUUSDc",
+    "volume": 0.01,
+    "price": 0
+}
+```
+
+**Limit Order:**
+```json
+{
+    "type": "limit_buy",
+    "symbol": "XAUUSDc",
+    "volume": 0.01,
+    "price": 2340.00
+}
+```
+
+**Close Position:**
+```json
+{
+    "type": "close_position",
+    "ticket": 12345
+}
+```
+
+**Cancel Order:**
+```json
+{
+    "type": "cancel_order",
+    "ticket": 12346
+}
+```
+
+**Download History:**
+```json
+{
+    "type": "download_history",
+    "symbol": "XAUUSDc",
+    "timeframe": "M1",
+    "start": "2024.01.01",
+    "end": "2024.01.31",
+    "mode": "OHLC"
+}
+```
+
+### Order Response Message (REP Socket)
+
+Sent from MQL5 back to the client.
+
+**Success:**
+```json
+{
+    "success": true,
+    "ticket": 12347
+}
+```
+
+**Failure:**
+```json
+{
+    "success": false,
+    "error": "Error 10019: Not enough money"
+}
+```
+
+### Supported Order Types
+
+| Type String | Description |
+|-------------|-------------|
+| `market_buy` | Execute market buy order |
+| `market_sell` | Execute market sell order |
+| `limit_buy` | Place buy limit pending order |
+| `limit_sell` | Place sell limit pending order |
+| `stop_buy` | Place buy stop pending order |
+| `stop_sell` | Place sell stop pending order |
+| `close_position` | Close existing position by ticket |
+| `cancel_order` | Delete pending order by ticket |
+| `download_history` | Request historical data download |
+
+---
+
+## Complete Examples
+
+### Example 1: Simple Tick Publisher
+
+```cpp
+//+------------------------------------------------------------------+
+//|                                           SimpleTickPublisher.mq5 |
+//+------------------------------------------------------------------+
+#include <Zmq/Zmq.mqh>
+
+input string InpAddress = "tcp://0.0.0.0:5555";
+
+CZmq *g_publisher;
+
+int OnInit() {
+    g_publisher = new CZmq();
+    
+    if(!g_publisher.Init(ZMQ_PUB)) {
+        Print("Failed to init ZMQ");
+        return INIT_FAILED;
+    }
+    
+    if(!g_publisher.Bind(InpAddress)) {
+        Print("Failed to bind");
+        return INIT_FAILED;
+    }
+    
+    Print("Publisher ready on ", InpAddress);
+    return INIT_SUCCEEDED;
+}
+
+void OnDeinit(const int reason) {
+    if(g_publisher != NULL) {
+        g_publisher.Shutdown();
+        delete g_publisher;
+    }
+}
+
+void OnTick() {
+    MqlTick tick;
+    if(SymbolInfoTick(_Symbol, tick)) {
+        string json;
+        StringConcatenate(json,
+            "{\"symbol\":\"", _Symbol,
+            "\",\"bid\":", DoubleToString(tick.bid, _Digits),
+            ",\"ask\":", DoubleToString(tick.ask, _Digits),
+            ",\"time\":", IntegerToString(tick.time),
+            "}");
+        
+        g_publisher.Send(json);
+    }
+}
+```
+
+### Example 2: Order Executor Service
+
+```cpp
+//+------------------------------------------------------------------+
+//|                                              OrderExecutor.mq5    |
+//+------------------------------------------------------------------+
+#include <Zmq/Zmq.mqh>
+#include <Trade/Trade.mqh>
+
+input string InpAddress = "tcp://0.0.0.0:5556";
+
+CZmq *g_responder;
+CTrade g_trade;
+
+int OnInit() {
+    g_responder = new CZmq();
+    
+    if(!g_responder.Init(ZMQ_REP))
+        return INIT_FAILED;
+    
+    if(!g_responder.Bind(InpAddress))
+        return INIT_FAILED;
+    
+    g_trade.SetDeviationInPoints(10);
+    
+    Print("Order executor ready on ", InpAddress);
+    return INIT_SUCCEEDED;
+}
+
+void OnDeinit(const int reason) {
+    if(g_responder != NULL) {
+        g_responder.Shutdown();
+        delete g_responder;
+    }
+}
+
+void OnTick() {
+    // Non-blocking receive
+    string request = g_responder.Receive(true);
+    
+    if(request == "") return;
+    
+    Print("Request: ", request);
+    
+    // Parse and execute (simplified)
+    string response;
+    if(StringFind(request, "market_buy") >= 0) {
+        double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
+        if(g_trade.Buy(0.01, _Symbol, ask)) {
+            StringConcatenate(response, 
+                "{\"success\":true,\"ticket\":", 
+                IntegerToString(g_trade.ResultOrder()), "}");
+        } else {
+            response = "{\"success\":false,\"error\":\"Buy failed\"}";
+        }
+    } else {
+        response = "{\"success\":false,\"error\":\"Unknown command\"}";
+    }
+    
+    g_responder.Send(response, false);  // Blocking send for REP
+    Print("Response: ", response);
+}
+```
+
+### Example 3: Rust Client (Complete)
+
+```rust
+// Cargo.toml dependencies:
+// zeromq = "0.3"
+// tokio = { version = "1", features = ["full"] }
+// serde = { version = "1", features = ["derive"] }
+// serde_json = "1"
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+
+#[derive(Debug, Deserialize)]
+struct TickData {
+    symbol: String,
+    bid: f64,
+    ask: f64,
+    time: i64,
+}
+
+#[derive(Debug, Serialize)]
+struct OrderRequest {
+    #[serde(rename = "type")]
+    order_type: String,
+    symbol: String,
+    volume: f64,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Subscribe to tick data
+    let (tx, mut rx) = mpsc::channel::<TickData>(100);
+    
+    tokio::spawn(async move {
+        let mut socket = zeromq::SubSocket::new();
+        socket.connect("tcp://127.0.0.1:5555").await.unwrap();
+        socket.subscribe("").await.unwrap();
+        
+        loop {
+            if let Ok(msg) = socket.recv().await {
+                if let Some(bytes) = msg.get(0) {
+                    if let Ok(json) = std::str::from_utf8(bytes) {
+                        if let Ok(tick) = serde_json::from_str::<TickData>(json) {
+                            let _ = tx.send(tick).await;
+                        }
+                    }
+                }
+            }
+        }
+    });
+    
+    // Process ticks
+    while let Some(tick) = rx.recv().await {
+        println!("{}: Bid={}, Ask={}", tick.symbol, tick.bid, tick.ask);
+    }
+    
+    Ok(())
+}
+```
+
+### Example 4: Java Client (Complete)
+
+```java
+// Maven dependency: org.zeromq:jeromq:0.5.3
+import org.zeromq.SocketType;
+import org.zeromq.ZContext;
+import org.zeromq.ZMQ;
+import com.google.gson.Gson;
+
+public class MT5Client {
+    private ZContext context;
+    private ZMQ.Socket subscriber;
+    private ZMQ.Socket requester;
+    private Gson gson = new Gson();
+    
+    public MT5Client(int tickPort, int orderPort) {
+        context = new ZContext();
+        
+        // Subscriber for tick data
+        subscriber = context.createSocket(SocketType.SUB);
+        subscriber.connect("tcp://127.0.0.1:" + tickPort);
+        subscriber.subscribe("".getBytes());
+        
+        // Requester for orders
+        requester = context.createSocket(SocketType.REQ);
+        requester.connect("tcp://127.0.0.1:" + orderPort);
+    }
+    
+    public void startTickStream() {
+        new Thread(() -> {
+            while (!Thread.currentThread().isInterrupted()) {
+                String msg = subscriber.recvStr(ZMQ.DONTWAIT);
+                if (msg != null) {
+                    TickData tick = gson.fromJson(msg, TickData.class);
+                    System.out.printf("%s: Bid=%.5f, Ask=%.5f%n", 
+                        tick.symbol, tick.bid, tick.ask);
+                }
+                try { Thread.sleep(1); } catch (InterruptedException e) { break; }
+            }
+        }).start();
+    }
+    
+    public OrderResponse sendOrder(String type, String symbol, double volume) {
+        OrderRequest request = new OrderRequest(type, symbol, volume);
+        requester.send(gson.toJson(request));
+        String response = requester.recvStr();
+        return gson.fromJson(response, OrderResponse.class);
+    }
+    
+    public void close() {
+        context.close();
+    }
+    
+    // Data classes
+    static class TickData {
+        String symbol;
+        double bid, ask;
+        long time;
+    }
+    
+    static class OrderRequest {
+        String type, symbol;
+        double volume;
+        OrderRequest(String t, String s, double v) { type=t; symbol=s; volume=v; }
+    }
+    
+    static class OrderResponse {
+        boolean success;
+        Long ticket;
+        String error;
+    }
+    
+    public static void main(String[] args) {
+        MT5Client client = new MT5Client(5555, 5556);
+        client.startTickStream();
+        
+        // Execute a buy order
+        OrderResponse response = client.sendOrder("market_buy", "EURUSD", 0.01);
+        System.out.println("Order result: " + response.success);
+    }
+}
+```
+
+### Example 5: C++ Client (Complete)
+
+```cpp
+// Requires: libzmq, cppzmq, nlohmann/json
+// Compile: g++ -std=c++17 -o mt5_client mt5_client.cpp -lzmq -lpthread
+
+#include <zmq.hpp>
+#include <nlohmann/json.hpp>
+#include <iostream>
+#include <thread>
+#include <atomic>
+
+using json = nlohmann::json;
+
+class MT5Client {
+private:
+    zmq::context_t context;
+    zmq::socket_t subscriber;
+    zmq::socket_t requester;
+    std::atomic<bool> running{false};
+    std::thread tick_thread;
+
+public:
+    MT5Client(int tick_port = 5555, int order_port = 5556)
+        : context(1), subscriber(context, zmq::socket_type::sub),
+          requester(context, zmq::socket_type::req) {
+        
+        subscriber.connect("tcp://127.0.0.1:" + std::to_string(tick_port));
+        subscriber.set(zmq::sockopt::subscribe, "");
+        
+        requester.connect("tcp://127.0.0.1:" + std::to_string(order_port));
+    }
+    
+    void start_tick_stream() {
+        running = true;
+        tick_thread = std::thread([this]() {
+            while (running) {
+                zmq::message_t message;
+                auto result = subscriber.recv(message, zmq::recv_flags::dontwait);
+                if (result) {
+                    std::string msg(static_cast<char*>(message.data()), message.size());
+                    json tick = json::parse(msg);
+                    std::cout << tick["symbol"].get<std::string>() 
+                              << ": Bid=" << tick["bid"].get<double>()
+                              << ", Ask=" << tick["ask"].get<double>() << std::endl;
+                }
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+        });
+    }
+    
+    json send_order(const std::string& type, const std::string& symbol, double volume) {
+        json request = {{"type", type}, {"symbol", symbol}, {"volume", volume}};
+        std::string req_str = request.dump();
+        
+        zmq::message_t req_msg(req_str.begin(), req_str.end());
+        requester.send(req_msg, zmq::send_flags::none);
+        
+        zmq::message_t reply;
+        requester.recv(reply);
+        
+        std::string reply_str(static_cast<char*>(reply.data()), reply.size());
+        return json::parse(reply_str);
+    }
+    
+    json market_buy(const std::string& symbol, double volume) {
+        return send_order("market_buy", symbol, volume);
+    }
+    
+    json market_sell(const std::string& symbol, double volume) {
+        return send_order("market_sell", symbol, volume);
+    }
+    
+    void stop() {
+        running = false;
+        if (tick_thread.joinable()) tick_thread.join();
+    }
+    
+    ~MT5Client() { stop(); }
+};
+
+int main() {
+    MT5Client client;
+    client.start_tick_stream();
+    
+    // Execute a buy order
+    json response = client.market_buy("EURUSD", 0.01);
+    std::cout << "Order result: " << response.dump() << std::endl;
+    
+    // Keep running
+    std::this_thread::sleep_for(std::chrono::seconds(60));
+    return 0;
+}
+```
+
+---
+
+## Error Handling
+
+### ZMQ Error Codes
+
+The library uses `zmq_errno()` to retrieve error codes. Common errors:
+
+| Error Code | Description | Solution |
+|------------|-------------|----------|
+| 11 | EAGAIN (resource unavailable) | Normal for non-blocking ops when no data |
+| 48 | EADDRINUSE (address in use) | Port already bound, use different port |
+| 111 | ECONNREFUSED | Remote endpoint not available |
+| 156384713 | ETERM (context terminated) | ZMQ context was terminated |
+
+### Defensive Programming
+
+```cpp
+// Always check initialization
+if(!g_publisher.Init(ZMQ_PUB)) {
+    Print("ZMQ Init failed");
+    return INIT_FAILED;
+}
+
+// Always check bind/connect
+if(!g_publisher.Bind("tcp://0.0.0.0:5555")) {
+    Print("ZMQ Bind failed, errno: ", zmq_errno());
+    g_publisher.Shutdown();
+    return INIT_FAILED;
+}
+
+// Handle empty receive gracefully
+string msg = g_responder.Receive(true);
+if(msg == "") {
+    // No message available, continue
+    return;
+}
+```
+
+---
+
+## Best Practices
+
+### 1. Resource Management
+
+Always use pointers and proper cleanup:
+
+```cpp
+CZmq *g_socket = NULL;  // Initialize to NULL
+
+int OnInit() {
+    g_socket = new CZmq();
+    // ... init and bind
+}
+
+void OnDeinit(const int reason) {
+    if(g_socket != NULL) {
+        g_socket.Shutdown();
+        delete g_socket;
+        g_socket = NULL;
+    }
+}
+```
+
+### 2. Non-Blocking in OnTick()
+
+Never use blocking operations in `OnTick()` - they will freeze the terminal:
+
+```cpp
+void OnTick() {
+    // GOOD: Non-blocking receive
+    string msg = g_responder.Receive(true);
+    
+    // BAD: This would freeze the terminal
+    // string msg = g_responder.Receive(false);
+}
+```
+
+### 3. REQ/REP Pattern Compliance
+
+The REP socket must always send a reply after receiving a request:
+
+```cpp
+void OnTick() {
+    string request = g_responder.Receive(true);
+    if(request != "") {
+        // MUST send response for every request
+        string response = ProcessRequest(request);
+        g_responder.Send(response, false);  // Use blocking send
+    }
+}
+```
+
+### 4. Buffer Size Considerations
+
+The default receive buffer is 4096 bytes. For larger messages:
+
+```cpp
+// In Zmq.mqh, modify:
+uchar buffer[16384];  // Increase to 16KB
+```
+
+### 5. JSON Message Construction
+
+Use `StringConcatenate` for efficient string building:
+
+```cpp
+string json;
+StringConcatenate(json,
+    "{\"symbol\":\"", _Symbol,
+    "\",\"value\":", DoubleToString(value, 5),
+    "}");
+```
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue: "dll imports are not allowed"**
+- Solution: Enable `Allow DLL imports` in Tools > Options > Expert Advisors
+
+**Issue: "Cannot load library 'libzmq.dll'"**
+- Solution: Ensure libzmq.dll is in MQL5/Libraries/ folder
+- Solution: Ensure libsodium.dll is also present (dependency)
+- Solution: Verify DLLs are 64-bit if using 64-bit MT5
+
+**Issue: "ZMQ Bind failed"**
+- Solution: Check if port is already in use
+- Solution: Try a different port number
+- Solution: Ensure firewall allows the port
+
+**Issue: No data received on subscriber**
+- Solution: Ensure subscriber connects AFTER publisher binds
+- Solution: Add a small delay after connect before expecting data
+- Solution: Verify network connectivity
+
+**Issue: "Request not answered" on REQ socket**
+- Solution: Ensure REP socket always sends a response for every receive
+- Solution: Check for crashes in request processing logic
+
+### Debug Logging
+
+Add print statements to trace execution:
+
+```cpp
+void OnTick() {
+    string request = g_responder.Receive(true);
+    if(request != "") {
+        Print("Received request: ", request);
+        
+        string response = ProcessRequest(request);
+        Print("Sending response: ", response);
+        
+        int sent = g_responder.Send(response, false);
+        Print("Bytes sent: ", sent);
+    }
+}
+```
+
+---
+
+## Version History
+
+| Version | Date | Changes |
+|---------|------|---------|
+| 2.00 | 2026-01-27 | Added REP socket support, order handling, account info streaming |
+| 1.00 | 2026-01-20 | Initial release with PUB socket support |
+
+---
+
+## License
+
+MIT License
+
+Copyright (c) 2026 Albeos Rembrant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## References
+
+- [ZeroMQ Official Documentation](https://zeromq.org/get-started/)
+- [ZeroMQ Socket Types Guide](https://zeromq.org/socket-api/)
+- [MQL5 DLL Import Guide](https://www.mql5.com/en/docs/runtime/imports)
+- [GitHub Repository](https://github.com/algorembrant/Rust-ZMQ-MT5)
+
+---
+
+## Citation
+
+If you use this library in your research or project, please cite:
+
+```bibtex
+@software{rembrant2026sum3api,
+  author       = {Rembrant, Albeos},
+  title        = {{SUM3API}: Using Rust, ZeroMQ, and MetaQuotes Language (MQL5) API Combination to Extract, Communicate, and Externally Project Financial Data from MetaTrader 5 (MT5)},
+  year         = {2026},
+  publisher    = {GitHub},
+  url          = {https://github.com/algorembrant/Rust-ZMQ-MT5},
+  version      = {2.00}
+}
+```
+
+//end of documentattion

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)
+   }
+  }
+  
+//+------------------------------------------------------------------+

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;
+   }
+};

MQL5/Libraries/libsodium.dll

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

MQL5/Libraries/libzmq.dll

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

Rust-ZMQ Library for SUM3API.md

@@ -0,0 +1,920 @@
+# Rust ZeroMQ Wrapper Library for MT5 Communication
+
+A comprehensive reusable Rust library for ZeroMQ socket operations, designed for real-time communication with MetaTrader 5 via the MQL5-ZMQ bridge.
+
+---
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Architecture](#architecture)
+3. [Prerequisites and Installation](#prerequisites-and-installation)
+4. [API Reference](#api-reference)
+5. [Usage Guide](#usage-guide)
+6. [Data Structures](#data-structures)
+7. [Complete Examples](#complete-examples)
+8. [Error Handling](#error-handling)
+9. [Best Practices](#best-practices)
+10. [Integration with Other Languages](#integration-with-other-languages)
+
+---
+
+## Overview
+
+This library provides a high-level Rust wrapper for ZeroMQ socket operations, specifically designed to communicate with MetaTrader 5 Expert Advisors running the MQL5-ZMQ bridge.
+
+> [!NOTE]
+> For the companion MQL5 server library, see [MQL5-ZMQ Library for SUM3API](MQL5-ZMQ%20Library%20for%20SUM3API.md).
+
+### Key Features
+
+- **Async/Await Support**: Built on Tokio for non-blocking operations
+- **Type-Safe Messages**: Serde-based JSON serialization with strongly typed structs
+- **Dual Socket Pattern**: SUB socket for tick streaming, REQ socket for order execution
+- **Channel-Based Architecture**: Uses MPSC channels for thread-safe message passing
+- **Automatic Reconnection**: Resilient connection handling
+
+### Supported Socket Types
+
+| Pattern | Rust Socket | MQL5 Socket | Purpose |
+|---------|-------------|-------------|---------|
+| PUB/SUB | `SubSocket` | `ZMQ_PUB` | Real-time tick data streaming |
+| REQ/REP | `ReqSocket` | `ZMQ_REP` | Order execution and commands |
+
+---
+
+## Architecture
+
+### System Integration
+
+```mermaid
+flowchart TB
+    subgraph MT5["MetaTrader 5"]
+        EA["ZmqPublisher EA"]
+        MQL["CZmq Wrapper"]
+        EA --> MQL
+    end
+
+    subgraph ZMQ["ZeroMQ Layer"]
+        PUB["PUB :5555"]
+        REP["REP :5556"]
+    end
+
+    subgraph Rust["Rust Application"]
+        SUB["SubSocket"]
+        REQ["ReqSocket"]
+        TICK_CH["Tick Channel"]
+        ORDER_CH["Order Channel"]
+        APP["Application Logic"]
+        
+        SUB --> TICK_CH
+        TICK_CH --> APP
+        APP --> ORDER_CH
+        ORDER_CH --> REQ
+    end
+
+    MQL --> PUB
+    MQL --> REP
+    PUB -->|"JSON Tick Data"| SUB
+    REQ <-->|"JSON Orders"| REP
+```
+
+### Data Flow
+
+```mermaid
+sequenceDiagram
+    participant MT5 as MT5 EA
+    participant PUB as PUB Socket
+    participant SUB as Rust SubSocket
+    participant CH as MPSC Channel
+    participant APP as Rust App
+    participant REQ as Rust ReqSocket
+    participant REP as REP Socket
+
+    Note over MT5,APP: Tick Data Flow
+    loop Every Tick
+        MT5->>PUB: Publish JSON
+        PUB->>SUB: Broadcast
+        SUB->>CH: tx.send(tick)
+        CH->>APP: rx.recv()
+    end
+
+    Note over APP,MT5: Order Execution Flow
+    APP->>REQ: Order Request
+    REQ->>REP: Send JSON
+    REP->>MT5: Parse Order
+    MT5->>MT5: Execute Trade
+    MT5->>REP: Response
+    REP->>REQ: JSON Response
+    REQ->>APP: OrderResponse
+```
+
+---
+
+## Prerequisites and Installation
+
+### Cargo.toml Dependencies
+
+```toml
+[dependencies]
+zeromq = "0.3"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+chrono = "0.4"
+```
+
+### System Requirements
+
+- Rust 1.70 or later
+- ZeroMQ library installed on system (for zeromq crate)
+- MetaTrader 5 with MQL5-ZMQ EA running
+
+### Installation Steps
+
+1. **Add dependencies to Cargo.toml** (see above)
+
+2. **Build the project**
+   ```bash
+   cargo build --release
+   ```
+
+3. **Verify MT5 EA is running**
+   - Ensure `ZmqPublisher.mq5` is attached to a chart
+   - Verify ports 5555 (tick data) and 5556 (orders) are accessible
+
+---
+
+## API Reference
+
+### Data Structures
+
+#### TickData
+
+Represents real-time market data received from MT5.
+
+```rust
+#[derive(Clone, Debug, Deserialize)]
+pub struct TickData {
+    pub symbol: String,
+    pub bid: f64,
+    pub ask: f64,
+    pub time: i64,
+    #[serde(default)]
+    pub volume: u64,
+    #[serde(default)]
+    pub balance: f64,
+    #[serde(default)]
+    pub equity: f64,
+    #[serde(default)]
+    pub margin: f64,
+    #[serde(default)]
+    pub free_margin: f64,
+    #[serde(default)]
+    pub min_lot: f64,
+    #[serde(default)]
+    pub max_lot: f64,
+    #[serde(default)]
+    pub lot_step: f64,
+    #[serde(default)]
+    pub positions: Vec<PositionData>,
+    #[serde(default)]
+    pub orders: Vec<PendingOrderData>,
+}
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `symbol` | `String` | Trading symbol (e.g., "EURUSD") |
+| `bid` | `f64` | Current bid price |
+| `ask` | `f64` | Current ask price |
+| `time` | `i64` | Unix timestamp |
+| `volume` | `u64` | Tick volume |
+| `balance` | `f64` | Account balance |
+| `equity` | `f64` | Account equity |
+| `margin` | `f64` | Used margin |
+| `free_margin` | `f64` | Available margin |
+| `min_lot` | `f64` | Minimum lot size |
+| `max_lot` | `f64` | Maximum lot size |
+| `lot_step` | `f64` | Lot size increment |
+| `positions` | `Vec<PositionData>` | Active positions |
+| `orders` | `Vec<PendingOrderData>` | Pending orders |
+
+---
+
+#### PositionData
+
+Represents an active trading position.
+
+```rust
+#[derive(Clone, Debug, Deserialize)]
+pub struct PositionData {
+    pub ticket: u64,
+    #[serde(rename = "type")]
+    pub pos_type: String,  // "BUY" or "SELL"
+    pub volume: f64,
+    pub price: f64,
+    pub profit: f64,
+}
+```
+
+---
+
+#### PendingOrderData
+
+Represents a pending order.
+
+```rust
+#[derive(Clone, Debug, Deserialize)]
+pub struct PendingOrderData {
+    pub ticket: u64,
+    #[serde(rename = "type")]
+    pub order_type: String,  // "BUY LIMIT", "SELL STOP", etc.
+    pub volume: f64,
+    pub price: f64,
+}
+```
+
+---
+
+#### OrderRequest
+
+Request structure for sending orders to MT5.
+
+```rust
+#[derive(Clone, Debug, Serialize)]
+pub struct OrderRequest {
+    #[serde(rename = "type")]
+    pub order_type: String,
+    pub symbol: String,
+    pub volume: f64,
+    pub price: f64,
+    #[serde(default)]
+    pub ticket: u64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timeframe: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub start: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
+}
+```
+
+**Supported Order Types:**
+
+| Type | Description |
+|------|-------------|
+| `market_buy` | Execute market buy order |
+| `market_sell` | Execute market sell order |
+| `limit_buy` | Place buy limit pending order |
+| `limit_sell` | Place sell limit pending order |
+| `stop_buy` | Place buy stop pending order |
+| `stop_sell` | Place sell stop pending order |
+| `close_position` | Close position by ticket |
+| `cancel_order` | Cancel pending order by ticket |
+| `download_history` | Request historical data |
+
+---
+
+#### OrderResponse
+
+Response structure from MT5 order execution.
+
+```rust
+#[derive(Clone, Debug, Deserialize)]
+pub struct OrderResponse {
+    pub success: bool,
+    pub ticket: Option<i64>,
+    pub error: Option<String>,
+    pub message: Option<String>,
+}
+```
+
+---
+
+## Usage Guide
+
+### Step 1: Create Channels
+
+```rust
+use tokio::sync::mpsc;
+
+// Channel for tick data (MT5 -> App)
+let (tick_tx, tick_rx) = mpsc::channel::<TickData>(100);
+
+// Channel for order requests (App -> MT5)
+let (order_tx, order_rx) = mpsc::channel::<OrderRequest>(10);
+
+// Channel for order responses (MT5 -> App)
+let (response_tx, response_rx) = mpsc::channel::<OrderResponse>(10);
+```
+
+### Step 2: Spawn Tick Subscriber Task
+
+```rust
+tokio::spawn(async move {
+    let mut socket = zeromq::SubSocket::new();
+    socket.connect("tcp://127.0.0.1:5555").await.unwrap();
+    socket.subscribe("").await.unwrap();
+
+    loop {
+        match socket.recv().await {
+            Ok(msg) => {
+                if let Some(bytes) = msg.get(0) {
+                    if let Ok(json) = std::str::from_utf8(bytes) {
+                        if let Ok(tick) = serde_json::from_str::<TickData>(json) {
+                            let _ = tick_tx.send(tick).await;
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Tick recv error: {}", e);
+                tokio::time::sleep(Duration::from_secs(1)).await;
+            }
+        }
+    }
+});
+```
+
+### Step 3: Spawn Order Handler Task
+
+```rust
+tokio::spawn(async move {
+    let mut socket = zeromq::ReqSocket::new();
+    socket.connect("tcp://127.0.0.1:5556").await.unwrap();
+
+    while let Some(request) = order_rx.recv().await {
+        let json = serde_json::to_string(&request).unwrap();
+        
+        if let Err(e) = socket.send(json.into()).await {
+            let _ = response_tx.send(OrderResponse {
+                success: false,
+                ticket: None,
+                error: Some(format!("Send failed: {}", e)),
+                message: None,
+            }).await;
+            continue;
+        }
+
+        match socket.recv().await {
+            Ok(msg) => {
+                if let Some(bytes) = msg.get(0) {
+                    if let Ok(json) = std::str::from_utf8(bytes) {
+                        if let Ok(response) = serde_json::from_str::<OrderResponse>(json) {
+                            let _ = response_tx.send(response).await;
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                let _ = response_tx.send(OrderResponse {
+                    success: false,
+                    ticket: None,
+                    error: Some(format!("Recv failed: {}", e)),
+                    message: None,
+                }).await;
+            }
+        }
+    }
+});
+```
+
+### Step 4: Process Ticks and Send Orders
+
+```rust
+// Process incoming ticks
+while let Some(tick) = tick_rx.recv().await {
+    println!("{}: Bid={}, Ask={}", tick.symbol, tick.bid, tick.ask);
+    
+    // Example: Send a buy order when certain condition is met
+    if some_trading_condition(&tick) {
+        let order = OrderRequest {
+            order_type: "market_buy".to_string(),
+            symbol: tick.symbol.clone(),
+            volume: 0.01,
+            price: 0.0,
+            ticket: 0,
+            timeframe: None,
+            start: None,
+            end: None,
+            mode: None,
+        };
+        let _ = order_tx.send(order).await;
+    }
+}
+```
+
+---
+
+## Complete Examples
+
+### Example 1: Basic Tick Subscriber
+
+```rust
+use serde::Deserialize;
+use zeromq::{Socket, SocketRecv};
+
+#[derive(Debug, Deserialize)]
+struct TickData {
+    symbol: String,
+    bid: f64,
+    ask: f64,
+    time: i64,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut socket = zeromq::SubSocket::new();
+    socket.connect("tcp://127.0.0.1:5555").await?;
+    socket.subscribe("").await?;
+    
+    println!("Connected to MT5 tick publisher");
+
+    loop {
+        let msg = socket.recv().await?;
+        if let Some(bytes) = msg.get(0) {
+            if let Ok(json) = std::str::from_utf8(bytes) {
+                if let Ok(tick) = serde_json::from_str::<TickData>(json) {
+                    println!("{}: {:.5} / {:.5}", tick.symbol, tick.bid, tick.ask);
+                }
+            }
+        }
+    }
+}
+```
+
+### Example 2: Order Execution Client
+
+```rust
+use serde::{Deserialize, Serialize};
+use zeromq::{Socket, SocketRecv, SocketSend};
+
+#[derive(Serialize)]
+struct OrderRequest {
+    #[serde(rename = "type")]
+    order_type: String,
+    symbol: String,
+    volume: f64,
+    price: f64,
+}
+
+#[derive(Debug, Deserialize)]
+struct OrderResponse {
+    success: bool,
+    ticket: Option<i64>,
+    error: Option<String>,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut socket = zeromq::ReqSocket::new();
+    socket.connect("tcp://127.0.0.1:5556").await?;
+    
+    println!("Connected to MT5 order handler");
+
+    // Send a market buy order
+    let order = OrderRequest {
+        order_type: "market_buy".to_string(),
+        symbol: "EURUSD".to_string(),
+        volume: 0.01,
+        price: 0.0,
+    };
+
+    let json = serde_json::to_string(&order)?;
+    println!("Sending: {}", json);
+    
+    socket.send(json.into()).await?;
+
+    let response = socket.recv().await?;
+    if let Some(bytes) = response.get(0) {
+        if let Ok(json) = std::str::from_utf8(bytes) {
+            let resp: OrderResponse = serde_json::from_str(json)?;
+            if resp.success {
+                println!("Order executed! Ticket: {:?}", resp.ticket);
+            } else {
+                println!("Order failed: {:?}", resp.error);
+            }
+        }
+    }
+
+    Ok(())
+}
+```
+
+### Example 3: Full Trading Application
+
+```rust
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc;
+use zeromq::{Socket, SocketRecv, SocketSend};
+use std::time::Duration;
+
+// ============================================================================
+// Data Structures
+// ============================================================================
+
+#[derive(Clone, Debug, Deserialize)]
+struct PositionData {
+    ticket: u64,
+    #[serde(rename = "type")]
+    pos_type: String,
+    volume: f64,
+    price: f64,
+    profit: f64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct TickData {
+    symbol: String,
+    bid: f64,
+    ask: f64,
+    time: i64,
+    #[serde(default)]
+    balance: f64,
+    #[serde(default)]
+    equity: f64,
+    #[serde(default)]
+    positions: Vec<PositionData>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+struct OrderRequest {
+    #[serde(rename = "type")]
+    order_type: String,
+    symbol: String,
+    volume: f64,
+    #[serde(default)]
+    price: f64,
+    #[serde(default)]
+    ticket: u64,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+struct OrderResponse {
+    success: bool,
+    ticket: Option<i64>,
+    error: Option<String>,
+}
+
+// ============================================================================
+// Main Application
+// ============================================================================
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create channels
+    let (tick_tx, mut tick_rx) = mpsc::channel::<TickData>(100);
+    let (order_tx, mut order_rx) = mpsc::channel::<OrderRequest>(10);
+    let (response_tx, mut response_rx) = mpsc::channel::<OrderResponse>(10);
+
+    // Spawn tick subscriber
+    tokio::spawn(async move {
+        let mut socket = zeromq::SubSocket::new();
+        if let Err(e) = socket.connect("tcp://127.0.0.1:5555").await {
+            eprintln!("Failed to connect to tick publisher: {}", e);
+            return;
+        }
+        let _ = socket.subscribe("").await;
+        println!("Tick subscriber connected");
+
+        loop {
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(bytes) = msg.get(0) {
+                        if let Ok(json) = std::str::from_utf8(bytes) {
+                            if let Ok(tick) = serde_json::from_str::<TickData>(json) {
+                                if tick_tx.send(tick).await.is_err() {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Tick error: {}", e);
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+                }
+            }
+        }
+    });
+
+    // Spawn order handler
+    let resp_tx = response_tx.clone();
+    tokio::spawn(async move {
+        let mut socket = zeromq::ReqSocket::new();
+        if let Err(e) = socket.connect("tcp://127.0.0.1:5556").await {
+            eprintln!("Failed to connect to order handler: {}", e);
+            return;
+        }
+        println!("Order handler connected");
+
+        while let Some(request) = order_rx.recv().await {
+            let json = match serde_json::to_string(&request) {
+                Ok(j) => j,
+                Err(e) => {
+                    let _ = resp_tx.send(OrderResponse {
+                        success: false,
+                        ticket: None,
+                        error: Some(format!("Serialize error: {}", e)),
+                    }).await;
+                    continue;
+                }
+            };
+
+            println!("Sending order: {}", json);
+
+            if let Err(e) = socket.send(json.into()).await {
+                let _ = resp_tx.send(OrderResponse {
+                    success: false,
+                    ticket: None,
+                    error: Some(format!("Send error: {}", e)),
+                }).await;
+                continue;
+            }
+
+            match socket.recv().await {
+                Ok(msg) => {
+                    if let Some(bytes) = msg.get(0) {
+                        if let Ok(json) = std::str::from_utf8(bytes) {
+                            if let Ok(resp) = serde_json::from_str::<OrderResponse>(json) {
+                                let _ = resp_tx.send(resp).await;
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    let _ = resp_tx.send(OrderResponse {
+                        success: false,
+                        ticket: None,
+                        error: Some(format!("Recv error: {}", e)),
+                    }).await;
+                }
+            }
+        }
+    });
+
+    // Spawn response handler
+    tokio::spawn(async move {
+        while let Some(response) = response_rx.recv().await {
+            if response.success {
+                println!("Order SUCCESS: Ticket {:?}", response.ticket);
+            } else {
+                println!("Order FAILED: {:?}", response.error);
+            }
+        }
+    });
+
+    // Main loop - process ticks
+    println!("Starting main loop...");
+    let mut tick_count = 0u64;
+
+    while let Some(tick) = tick_rx.recv().await {
+        tick_count += 1;
+        
+        // Print every 100th tick to avoid spam
+        if tick_count % 100 == 0 {
+            println!(
+                "[{}] {}: Bid={:.5}, Ask={:.5}, Balance={:.2}, Positions={}",
+                tick_count,
+                tick.symbol,
+                tick.bid,
+                tick.ask,
+                tick.balance,
+                tick.positions.len()
+            );
+        }
+
+        // Example trading logic: buy when no positions exist
+        if tick.positions.is_empty() && tick_count == 500 {
+            let order = OrderRequest {
+                order_type: "market_buy".to_string(),
+                symbol: tick.symbol.clone(),
+                volume: 0.01,
+                price: 0.0,
+                ticket: 0,
+            };
+            let _ = order_tx.send(order).await;
+        }
+    }
+
+    Ok(())
+}
+```
+
+---
+
+## Error Handling
+
+### Common Error Patterns
+
+```rust
+// Connection error handling
+match socket.connect("tcp://127.0.0.1:5555").await {
+    Ok(_) => println!("Connected"),
+    Err(e) => {
+        eprintln!("Connection failed: {}", e);
+        // Implement retry logic
+        tokio::time::sleep(Duration::from_secs(5)).await;
+    }
+}
+
+// Receive error handling with retry
+loop {
+    match socket.recv().await {
+        Ok(msg) => process_message(msg),
+        Err(e) => {
+            eprintln!("Recv error: {}", e);
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            continue;
+        }
+    }
+}
+
+// JSON parsing error handling
+match serde_json::from_str::<TickData>(json) {
+    Ok(tick) => handle_tick(tick),
+    Err(e) => eprintln!("JSON parse error: {} - Data: {}", e, json),
+}
+```
+
+### Error Response Structure
+
+Always check `OrderResponse.success` before using other fields:
+
+```rust
+if response.success {
+    let ticket = response.ticket.unwrap_or(0);
+    println!("Order executed with ticket: {}", ticket);
+} else {
+    let error = response.error.unwrap_or_else(|| "Unknown error".to_string());
+    eprintln!("Order failed: {}", error);
+}
+```
+
+---
+
+## Best Practices
+
+### 1. Use Bounded Channels
+
+Prevent memory issues with bounded channels:
+
+```rust
+// Good: Bounded channel with reasonable capacity
+let (tx, rx) = mpsc::channel::<TickData>(100);
+
+// Avoid: Unbounded channels can grow infinitely
+// let (tx, rx) = mpsc::unbounded_channel();
+```
+
+### 2. Handle Channel Errors
+
+Check for send/receive errors:
+
+```rust
+// Check if receiver is dropped
+if tx.send(tick).await.is_err() {
+    eprintln!("Receiver dropped, exiting");
+    break;
+}
+
+// Use try_send for non-blocking with backpressure
+match tx.try_send(tick) {
+    Ok(_) => {},
+    Err(mpsc::error::TrySendError::Full(_)) => {
+        eprintln!("Channel full, dropping tick");
+    }
+    Err(mpsc::error::TrySendError::Closed(_)) => break,
+}
+```
+
+### 3. Graceful Shutdown
+
+Implement proper shutdown handling:
+
+```rust
+use tokio::signal;
+
+tokio::select! {
+    _ = process_ticks(&mut tick_rx) => {},
+    _ = signal::ctrl_c() => {
+        println!("Shutting down...");
+    }
+}
+```
+
+### 4. Connection Resilience
+
+Implement reconnection logic:
+
+```rust
+async fn connect_with_retry(addr: &str, max_retries: u32) -> Result<SubSocket, Error> {
+    for attempt in 1..=max_retries {
+        let mut socket = zeromq::SubSocket::new();
+        match socket.connect(addr).await {
+            Ok(_) => return Ok(socket),
+            Err(e) => {
+                eprintln!("Attempt {}/{} failed: {}", attempt, max_retries, e);
+                tokio::time::sleep(Duration::from_secs(attempt as u64)).await;
+            }
+        }
+    }
+    Err(Error::ConnectionFailed)
+}
+```
+
+---
+
+## Integration with Other Languages
+
+This Rust library is designed to work alongside the MQL5-ZMQ bridge. The same protocol can be implemented in other languages:
+
+### Go Integration
+
+```go
+// See MQL5-ZMQ Library documentation for Go examples
+import zmq "github.com/pebbe/zmq4"
+```
+
+### Java Integration
+
+```java
+// See MQL5-ZMQ Library documentation for Java examples
+import org.zeromq.ZMQ;
+```
+
+### C++ Integration
+
+```cpp
+// See MQL5-ZMQ Library documentation for C++ examples
+#include <zmq.hpp>
+```
+
+All clients use the same JSON message protocol defined in the [MQL5-ZMQ Library](MQL5-ZMQ%20Library%20for%20SUM3API.md#message-protocol).
+
+---
+
+## Version History
+
+| Version | Date | Changes |
+|---------|------|---------|
+| 2.00 | 2026-01-27 | Added order handling, position tracking, full async support |
+| 1.00 | 2026-01-20 | Initial release with tick subscription |
+
+---
+
+## License
+
+MIT License
+
+Copyright (c) 2026 Albeos Rembrant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+## References
+
+- [ZeroMQ Rust Crate](https://crates.io/crates/zeromq)
+- [Tokio Async Runtime](https://tokio.rs/)
+- [Serde JSON](https://serde.rs/)
+- [MQL5-ZMQ Library](MQL5-ZMQ%20Library%20for%20SUM3API.md)
+- [GitHub Repository](https://github.com/algorembrant/Rust-ZMQ-MT5)
+
+---
+
+## Citation
+
+If you use this library in your research or project, please cite:
+
+```bibtex
+@software{rembrant2026sum3api,
+  author       = {Rembrant, Albeos},
+  title        = {{SUM3API}: Using Rust, ZeroMQ, and MetaQuotes Language (MQL5) API Combination to Extract, Communicate, and Externally Project Financial Data from MetaTrader 5 (MT5)},
+  year         = {2026},
+  publisher    = {GitHub},
+  url          = {https://github.com/algorembrant/Rust-ZMQ-MT5},
+  version      = {2.00}
+}
+```
+
+//end of documentattion

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"

Rustmt5-chart/output/History_XAUUSDc_H1_OHLC_ID0002_20260126_135823.csv

@@ -0,0 +1,3 @@
+Time,Open,High,Low,Close,TickVol,Spread
+2026.01.25 23:00,5019.847,5040.296,5003.575,5039.789,30600,160
+2026.01.26 00:00,5039.821,5052.099,5030.537,5041.830,25016,160

Rustmt5-chart/output/Live_XAUUSDc_ID0001_20260126_135811.csv

@@ -0,0 +1,14 @@
+Time,Bid,Ask,Volume
+1769407092,5073.44,5073.6,0
+1769407092,5073.412,5073.572,0
+1769407092,5073.463,5073.623,0
+1769407092,5073.619,5073.779,0
+1769407092,5073.69,5073.85,0
+1769407092,5073.738,5073.898,0
+1769407092,5073.828,5073.988,0
+1769407093,5073.716,5073.876,0
+1769407093,5073.626,5073.786,0
+1769407093,5073.737,5073.897,0
+1769407093,5073.607,5073.767,0
+1769407093,5073.705,5073.865,0
+1769407093,5073.744,5073.904,0

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())
+}

STRUCTURE.md

@@ -0,0 +1,33 @@
+## Project Structure
+
+```text
+SUM3API/
+├── MQL5/
+│   ├── Experts/
+│   │   └── ZmqPublisher.mq5
+│   ├── Include/
+│   │   └── Zmq/
+│   │       └── Zmq.mqh
+│   └── Libraries/
+│       ├── libsodium.dll
+│       └── libzmq.dll
+├── Rustmt5-chart/
+│   ├── output/
+│   │   ├── History_XAUUSDc_H1_OHLC_ID0002_20260126_135823.csv
+│   │   ├── History_XAUUSDc_H1_TICKS_ID0001_20260126_140825.csv
+│   │   └── Live_XAUUSDc_ID0001_20260126_135811.csv
+│   ├── src/
+│   │   └── main.rs
+│   ├── Cargo.lock
+│   └── Cargo.toml
+├── .gitignore
+├── A GUIDE to open SUM3API software (trading terminal).pdf
+├── Complete_System_Architecture.md
+├── LICENSE
+├── MQL5-ZMQ Library for SUM3API.md
+├── README.md
+├── Rust-ZMQ Library for SUM3API.md
+├── Security_Claim_Validation.md
+├── SUM3API.pdf
+└── TECHSTACK.md
+```

SUM3API.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53731656dd4830cb0710d71b53c4bc230c97dc90e35717d5f9c48b522a509426
+size 6358623

Security_Claim_Validation.md

@@ -0,0 +1,446 @@
+# Security Claim Validation: MQL5 & ZeroMQ & Rust vs MT5 Python API
+
+**Document Purpose**: This document validates the security claim made in Appendix A10 of the SUM3API research paper regarding credential exposure differences between the MQL5 & ZeroMQ & Rust approach and MT5's official Python API.
+
+**Validation Date**: January 28, 2026
+
+---
+
+## Claim Being Validated
+
+> Unlike MT5's Python API where developers must explicitly define sensitive variables such as account ID, account password, and account server in their code, the MQL5 & ZeroMQ & Rust library does not require such sensitive information to be exposed. The Expert Advisor running inside MT5 already has authenticated access to the trading account, and thus can fetch account information (balance, equity, free and used margin) and execute trading operations (placing orders, closing positions) without requiring credentials to be passed through the communication layer.
+
+---
+
+## Validation Methodology
+
+1. **Code Analysis**: Examined the actual implementation of both systems
+2. **Documentation Review**: Reviewed official MT5 Python API documentation
+3. **Security Architecture Comparison**: Analyzed the authentication flow in both approaches
+
+---
+
+## Evidence 1: MT5 Python API Requires Explicit Credentials
+
+### Official MT5 Python API Authentication Pattern
+
+According to the official MetaTrader 5 Python documentation and common usage patterns, the Python API requires explicit authentication:
+
+```python
+import MetaTrader5 as mt5
+
+# Initialize MT5 connection
+if not mt5.initialize():
+    print("initialize() failed")
+    mt5.shutdown()
+
+# Login with explicit credentials
+account = 12345678                      # Account ID (SENSITIVE)
+password = "your_password"              # Account Password (SENSITIVE)
+server = "MetaQuotes-Demo-or-Real"      # Server name (SENSITIVE)
+
+authorized = mt5.login(account, password=password, server=server)
+
+if authorized:
+    # Now can access account info
+    account_info = mt5.account_info()
+    print(f"Balance: {account_info.balance}")
+else:
+    print("Failed to connect to account")
+```
+
+### Security Implications
+
+- **Credential Exposure**: Account ID, password, and server must be hardcoded or stored in configuration files
+- **Code Repository Risk**: Credentials may be accidentally committed to version control
+- **Transmission Risk**: Credentials are transmitted through the Python API layer
+- **Storage Risk**: Credentials must be stored somewhere accessible to the Python script
+
+**VERDICT**: **CLAIM VALIDATED** - MT5 Python API does require explicit credentials in code
+
+---
+
+## Evidence 2: MQL5 & ZeroMQ & Rust Does NOT Require Credentials
+
+### Analysis of ZmqPublisher.mq5 (Expert Advisor)
+
+Examining the MQL5 Expert Advisor code at `c:\Users\User\Desktop\VSCode\SUM3API\MQL5\Experts\ZmqPublisher.mq5`:
+
+**Lines 365-369: Account Information Retrieval**
+```mql5
+// Get account info
+double balance = AccountInfoDouble(ACCOUNT_BALANCE);
+double equity = AccountInfoDouble(ACCOUNT_EQUITY);
+double margin = AccountInfoDouble(ACCOUNT_MARGIN);
+double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
+```
+
+**Key Observations**:
+- No account ID required
+- No password required
+- No server name required
+- Uses MT5's built-in authenticated session
+
+**Lines 109-119: Trade Execution**
+```mql5
+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();
+}
+```
+
+**Key Observations**:
+- Trade execution uses authenticated MT5 session
+- No credentials passed to trading functions
+- MT5 handles authentication internally
+
+### Analysis of Rust Application (main.rs)
+
+Examining the Rust application at `c:\Users\User\Desktop\VSCode\SUM3API\Rustmt5-chart\src\main.rs`:
+
+**Lines 732-738: ZeroMQ Connection**
+```rust
+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;
+```
+
+**Lines 769-776: Order Request Connection**
+```rust
+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;
+        }
+    }
+```
+
+**Key Observations**:
+- Only TCP socket addresses are specified (localhost ports)
+- No account credentials anywhere in the Rust code
+- No password variables
+- No server names
+- No account ID references
+
+**Lines 337-348: Account Data Reception**
+```rust
+// 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;
+    }
+}
+```
+
+**Key Observations**:
+- Account information received as data, not through authentication
+- No credential validation in Rust code
+- Trust model: MT5 EA is already authenticated
+
+**VERDICT**: **CLAIM VALIDATED** - MQL5 & ZeroMQ & Rust approach does NOT require credentials in code
+
+---
+
+## Evidence 3: Authentication Architecture Comparison
+
+### MT5 Python API Architecture
+
+```mermaid
+flowchart TD
+    A["Python Script"] --> |"mt5.login(account, password, server)"| B["MT5 Terminal"]
+    B --> C["Broker Server"]
+    
+    A1["account = 12345678<br/>(SENSITIVE)"] -.-> A
+    A2["password = 'xxx'<br/>(SENSITIVE)"] -.-> A
+    A3["server = 'MetaQuotes'<br/>(SENSITIVE)"] -.-> A
+    
+    B --> D["Authenticates<br/>to Broker"]
+    
+    style A fill:#ffcccc,stroke:#cc0000,stroke-width:2px
+    style A1 fill:#ff9999,stroke:#cc0000,stroke-width:2px
+    style A2 fill:#ff9999,stroke:#cc0000,stroke-width:2px
+    style A3 fill:#ff9999,stroke:#cc0000,stroke-width:2px
+    style B fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style C fill:#e6ffe6,stroke:#00cc00,stroke-width:2px
+    style D fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+```
+
+**Security Characteristics**:
+- Credentials must exist in Python code or config files
+- Credentials transmitted through Python API
+- Multiple points of potential exposure
+
+### MQL5 & ZeroMQ & Rust Architecture
+
+```mermaid
+flowchart TD
+    subgraph External["External Application"]
+        R["Rust App<br/><br/>✓ No credentials<br/>✓ Only socket addresses<br/>tcp://127.0.0.1:5555<br/>tcp://127.0.0.1:5556"]
+    end
+    
+    subgraph MT5["MT5 Terminal Process"]
+        EA["MQL5 Expert Advisor<br/><br/>✓ Uses existing session<br/>✓ No credentials needed"]
+        MT5T["MT5 Terminal<br/><br/>User logged in via GUI"]
+    end
+    
+    subgraph Broker["Broker Infrastructure"]
+        BS["Broker Server<br/><br/>Already authenticated"]
+    end
+    
+    R <-->|"ZeroMQ<br/>(localhost TCP)<br/>Port 5555: Tick Data<br/>Port 5556: Orders"| EA
+    EA -.->|"Inherits authenticated<br/>session"| MT5T
+    MT5T <-->|"Manual login<br/>(one-time)"| BS
+    
+    U["User"] -->|"Logs in via GUI<br/>(account, password, server)"| MT5T
+    
+    style R fill:#ccffcc,stroke:#00cc00,stroke-width:3px
+    style EA fill:#e6f3ff,stroke:#0066cc,stroke-width:2px
+    style MT5T fill:#fff9e6,stroke:#ffcc00,stroke-width:2px
+    style BS fill:#e6ffe6,stroke:#00cc00,stroke-width:2px
+    style U fill:#f0f0f0,stroke:#666666,stroke-width:2px
+    style External fill:#f0fff0,stroke:#00cc00,stroke-width:2px,stroke-dasharray: 5 5
+    style MT5 fill:#f0f8ff,stroke:#0066cc,stroke-width:2px,stroke-dasharray: 5 5
+    style Broker fill:#f0fff0,stroke:#00cc00,stroke-width:2px,stroke-dasharray: 5 5
+```
+
+**Security Characteristics**:
+- No credentials in code
+- No credentials transmitted over ZeroMQ
+- Authentication handled by MT5 GUI (user logs in manually)
+- EA inherits authenticated session
+- Rust app only communicates with already-authenticated EA
+
+**VERDICT**: **CLAIM VALIDATED** - Architecture confirms security advantage
+
+---
+
+## Evidence 4: Data Flow Analysis
+
+### Communication Flow Diagram
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant MT5 as MT5 Terminal
+    participant EA as MQL5 EA
+    participant Rust as Rust App
+    
+    Note over User,MT5: Initial Setup (One-time)
+    User->>MT5: Manual login via GUI<br/>(account, password, server)
+    MT5->>MT5: Authenticate with broker
+    User->>MT5: Attach EA to chart
+    MT5->>EA: Start EA (inherits session)
+    
+    Note over EA,Rust: Runtime Communication (No Credentials)
+    Rust->>EA: Connect to ZeroMQ<br/>tcp://127.0.0.1:5555 (SUB)<br/>tcp://127.0.0.1:5556 (REQ)
+    
+    loop Every Tick
+        MT5->>EA: OnTick() event
+        EA->>EA: Fetch account info<br/>(balance, equity, margin)
+        EA->>EA: Fetch positions & orders
+        EA->>Rust: Publish tick data + account info<br/>(Port 5555 - PUB/SUB)
+        Note over EA,Rust: JSON: {symbol, bid, ask, balance, equity...}
+    end
+    
+    alt Trading Command
+        Rust->>EA: Send order request<br/>(Port 5556 - REQ/REP)
+        Note over Rust,EA: JSON: {type: "market_buy", volume: 0.01...}
+        EA->>MT5: Execute trade via CTrade
+        MT5->>EA: Trade result
+        EA->>Rust: Send response<br/>{success: true, ticket: 12345}
+    end
+    
+    Note over EA,Rust: ✓ No credentials transmitted<br/>✓ All communication on localhost<br/>✓ EA uses inherited session
+```
+
+### What Gets Transmitted Over ZeroMQ?
+
+**From MQL5 EA to Rust (PUB/SUB on port 5555)**:
+```json
+{
+  "symbol": "XAUUSDc",
+  "bid": 2650.55,
+  "ask": 2650.75,
+  "time": 1706284800,
+  "volume": 100,
+  "balance": 10000.00,
+  "equity": 10150.25,
+  "margin": 500.00,
+  "free_margin": 9650.25,
+  "positions": [...],
+  "orders": [...]
+}
+```
+
+**From Rust to MQL5 EA (REQ/REP on port 5556)**:
+```json
+{
+  "type": "market_buy",
+  "symbol": "XAUUSDc",
+  "volume": 0.01,
+  "price": 0.0,
+  "ticket": 0
+}
+```
+
+**Key Observations**:
+- No account ID transmitted
+- No password transmitted
+- No server name transmitted
+- Only trading commands and market data
+- All communication on localhost (127.0.0.1)
+
+**VERDICT**: **CLAIM VALIDATED** - No sensitive credentials transmitted
+
+---
+
+## Security Advantages Summary
+
+Based on the code analysis, the following security advantages are **CONFIRMED**:
+
+### 1. No Credential Exposure
+**Validated**: The Rust application contains zero references to account credentials. The MQL5 EA uses MT5's internal authenticated session without requiring credentials to be passed.
+
+### 2. Reduced Attack Surface
+**Validated**: External applications (Rust) cannot directly authenticate to trading accounts. They can only communicate with an already-authenticated MT5 instance through localhost sockets.
+
+### 3. Separation of Concerns
+**Validated**: Authentication is handled entirely by MT5's native security mechanisms (user logs in via MT5 GUI). The external application focuses solely on data consumption and command issuance.
+
+### 4. Localhost Communication
+**Validated**: Default configuration uses localhost TCP sockets (127.0.0.1:5555 and 127.0.0.1:5556), preventing network-based credential interception. No credentials are transmitted even over this local channel.
+
+---
+
+## Additional Security Considerations
+
+### Advantages of MQL5 & ZeroMQ & Rust Approach
+
+1. **No Credential Storage**: Credentials never need to be stored in configuration files or environment variables
+2. **No Version Control Risk**: No risk of accidentally committing credentials to Git repositories
+3. **Session Inheritance**: EA inherits the authenticated session from MT5 terminal
+4. **Manual Authentication**: User authenticates once via MT5 GUI, not programmatically
+5. **Localhost-Only**: Default configuration prevents remote access without explicit configuration
+
+### Potential Security Considerations
+
+1. **Localhost Trust**: Any application on localhost can connect to ZeroMQ sockets
+2. **No Authentication Layer**: ZeroMQ sockets don't have built-in authentication (by design in this implementation)
+3. **Command Injection**: Rust app can send any trading command to authenticated MT5 session
+
+**Note**: These considerations are architectural trade-offs, not vulnerabilities. The localhost-only design is appropriate for the use case.
+
+---
+
+## Comparison with MT5 Python API Security
+
+### Visual Security Comparison
+
+```mermaid
+graph LR
+    subgraph Python["MT5 Python API Approach"]
+        P1["❌ Credentials in Code"]
+        P2["❌ Password Storage Required"]
+        P3["❌ Credential Transmission"]
+        P4["❌ High Version Control Risk"]
+        P5["⚠️ Network Exposure Risk"]
+    end
+    
+    subgraph Rust["MQL5 & ZeroMQ & Rust Approach"]
+        R1["✓ No Credentials in Code"]
+        R2["✓ No Password Storage"]
+        R3["✓ No Credential Transmission"]
+        R4["✓ Zero Version Control Risk"]
+        R5["✓ Localhost Only"]
+    end
+    
+    style Python fill:#ffe6e6,stroke:#cc0000,stroke-width:2px
+    style Rust fill:#e6ffe6,stroke:#00cc00,stroke-width:2px
+    style P1 fill:#ffcccc,stroke:#cc0000
+    style P2 fill:#ffcccc,stroke:#cc0000
+    style P3 fill:#ffcccc,stroke:#cc0000
+    style P4 fill:#ffcccc,stroke:#cc0000
+    style P5 fill:#fff4cc,stroke:#ffaa00
+    style R1 fill:#ccffcc,stroke:#00cc00
+    style R2 fill:#ccffcc,stroke:#00cc00
+    style R3 fill:#ccffcc,stroke:#00cc00
+    style R4 fill:#ccffcc,stroke:#00cc00
+    style R5 fill:#ccffcc,stroke:#00cc00
+```
+
+### Detailed Comparison Table
+
+| Aspect | MT5 Python API | MQL5 & ZeroMQ & Rust |
+|--------|----------------|----------------------|
+| Credentials in Code | Required | Not Required |
+| Password Storage | Required | Not Required |
+| Credential Transmission | Yes (via API) | No |
+| Authentication Method | Programmatic | Manual (MT5 GUI) |
+| Session Model | Python creates session | EA inherits session |
+| Attack Surface | Higher (credentials exposed) | Lower (no credentials) |
+| Version Control Risk | High | None |
+| Network Exposure | Depends on config | Localhost only |
+
+---
+
+## Conclusion
+
+### Overall Verdict: **CLAIM FULLY VALIDATED**
+
+The security claim made in Appendix A10 of the SUM3API research paper is **100% accurate and validated** through comprehensive code analysis:
+
+1. MT5 Python API **does require** explicit account ID, password, and server in code
+2. MQL5 & ZeroMQ & Rust approach **does NOT require** any credentials in code
+3. All four stated security advantages are **confirmed and validated**
+4. The architectural design provides **measurable security benefits**
+
+### Recommendation
+
+The claim is **scientifically sound** and **technically accurate**. It can be confidently included in the research paper as a legitimate security advantage of the proposed approach.
+
+---
+
+## References
+
+### Code Files Analyzed
+- `c:\Users\User\Desktop\VSCode\SUM3API\MQL5\Experts\ZmqPublisher.mq5` (451 lines)
+- `c:\Users\User\Desktop\VSCode\SUM3API\Rustmt5-chart\src\main.rs` (853 lines)
+
+### External Documentation
+- MetaTrader 5 Python API Documentation: https://www.mql5.com/en/docs/python_metatrader5
+- Official MT5 Python login() function documentation
+- ZeroMQ Security Model: https://zguide.zeromq.org/
+
+### Key Findings
+- **0 instances** of credentials in Rust code
+- **0 instances** of credentials in MQL5 EA code
+- **0 instances** of credentials transmitted over ZeroMQ
+- **100% reliance** on MT5's native authenticated session
+
+---
+
+**Document Prepared By**: Security Analysis for SUM3API Research Paper  
+**Validation Status**: CLAIM CONFIRMED  
+**Confidence Level**: Very High (based on direct code analysis)

TECHSTACK.md

@@ -0,0 +1,17 @@
+## Techstack
+
+Audit of **SUM3API** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Markdown (.md) | 5 | 208.1 |
+| CSV (.csv) | 3 | 1,195.9 |
+| (no extension) | 2 | 1.2 |
+| DLL Library (.dll) | 2 | 736.0 |
+| PDF (.pdf) | 2 | 7,454.7 |
+| Lock File (.lock) | 1 | 110.5 |
+| MQL Header (.mqh) | 1 | 3.9 |
+| MQL5 Source (.mq5) | 1 | 18.1 |
+| Rust (.rs) | 1 | 33.8 |
+| TOML (.toml) | 1 | 0.3 |
+| **Total** | **19** | **9,762.5** |