gavindiaz/MT5-EA-Sniper-Strategy
1
0
Fork 0
mirror of https://github.com/rithsila/MT5-EA-Sniper-Strategy.git synced 2026-08-05 06:57:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
b6166d42465cae355d43adfe3c31a97e05e2dcd1
MT5-EA-Sniper-Strategy/docs/API_Documentation.md
T
sila b6166d4246 feat: Complete MT5 EA Sniper Strategy implementation with comprehensive documentation 
- Add complete MT5 Expert Advisor with institutional trading concepts
- Implement Order Blocks (OB), Break of Structure (BOS), Liquidity Sweeps, and Fair Value Gaps (FVG)
- Include AI integration with GrokAI for enhanced market analysis
- Add comprehensive risk management and session management systems
- Implement advanced optimization and backtesting frameworks
- Include complete test suite with integration, performance, and validation tests
- Add professional documentation with API docs, deployment guide, and user manual
- Update README.md with industry-standard documentation and Mermaid architecture diagram
- Add comprehensive .gitignore for MT5 development environment
- Include system validation and test results reports

Features:
✅ Multi-timeframe analysis (1M, 15M, H4)
✅ Institutional trading concepts implementation
✅ AI-powered market structure analysis
✅ Advanced risk management with Monte Carlo simulation
✅ Real-time news filtering and fundamental analysis
✅ Adaptive parameter optimization
✅ Comprehensive testing and validation framework
✅ Professional documentation and deployment guides
2025-09-20 15:25:18 +07:00

1110 lines
34 KiB
Markdown
Raw Blame History

# MT5 Sniper EA - API Documentation
## Table of Contents
1. [Core Classes](#core-classes)
2. [Market Structure Analysis](#market-structure-analysis)
3. [Risk Management](#risk-management)
4. [Session Management](#session-management)
5. [AI Integration](#ai-integration)
6. [Backtesting Framework](#backtesting-framework)
7. [Visualization System](#visualization-system)
8. [Utility Classes](#utility-classes)
9. [Data Structures](#data-structures)
10. [Enumerations](#enumerations)
---
## Core Classes
### CLogger
**File**: `Include/Utils/Logger.mqh`
Centralized logging system for the EA with multiple log levels and output options.
#### Methods
```mql5
class CLogger
{
public:
// Initialization
bool Initialize(string filename, ENUM_LOG_LEVEL level = LOG_LEVEL_INFO);
void Deinitialize();
// Logging methods
void LogError(string message, string function = "", int line = 0);
void LogWarning(string message, string function = "", int line = 0);
void LogInfo(string message, string function = "", int line = 0);
void LogDebug(string message, string function = "", int line = 0);
void LogTrace(string message, string function = "", int line = 0);
// Configuration
void SetLogLevel(ENUM_LOG_LEVEL level);
void SetConsoleOutput(bool enable);
void SetFileOutput(bool enable);
void SetMaxFileSize(long max_size_mb);
// Utility
void Flush();
string GetLogFilePath();
long GetLogFileSize();
};
```
#### Usage Example
```mql5
CLogger logger;
logger.Initialize("SniperEA.log", LOG_LEVEL_DEBUG);
logger.LogInfo("EA initialized successfully");
logger.LogError("Failed to place order", __FUNCTION__, __LINE__);
```
---
## Market Structure Analysis
### COrderBlockDetector
**File**: `Include/MarketStructure/OrderBlock.mqh`
Detects and manages institutional order blocks using price action analysis.
#### Key Methods
```mql5
class COrderBlockDetector
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void SetParameters(int min_size, int max_age, int confirmation_bars);
// Detection
bool DetectOrderBlocks();
bool IsOrderBlockValid(const SOrderBlock &block);
bool IsOrderBlockActive(const SOrderBlock &block);
// Analysis
SOrderBlock* GetNearestOrderBlock(double price, ENUM_ORDER_BLOCK_TYPE type);
int GetOrderBlockCount(ENUM_ORDER_BLOCK_TYPE type = ORDER_BLOCK_ALL);
double GetOrderBlockStrength(const SOrderBlock &block);
// Management
void UpdateOrderBlocks();
void CleanupExpiredBlocks();
void ClearAllBlocks();
// Visualization
void DrawOrderBlocks();
void RemoveOrderBlockObjects();
};
```
#### SOrderBlock Structure
```mql5
struct SOrderBlock
{
datetime time; // Formation time
double high; // Block high price
double low; // Block low price
ENUM_ORDER_BLOCK_TYPE type; // Block type (bullish/bearish)
double strength; // Block strength (0.0-1.0)
int touches; // Number of touches
bool is_active; // Active status
bool is_broken; // Broken status
datetime last_test_time; // Last test time
string id; // Unique identifier
};
```
### CBreakOfStructureDetector
**File**: `Include/MarketStructure/BreakOfStructure.mqh`
Identifies market structure breaks and trend changes using swing point analysis.
#### Key Methods
```mql5
class CBreakOfStructureDetector
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void SetParameters(int min_break_size, ENUM_BOS_CONFIRMATION_METHOD method);
// Detection
bool DetectBreakOfStructure();
bool IsValidBOS(const SBOS &bos);
bool ConfirmBOS(const SBOS &bos);
// Analysis
SBOS* GetLatestBOS(ENUM_BOS_TYPE type = BOS_TYPE_ALL);
bool IsStructureBroken(double level, ENUM_BOS_TYPE type);
double GetBOSStrength(const SBOS &bos);
// Swing Points
bool DetectSwingPoints();
SSwingPoint* GetSwingHigh(int index = 0);
SSwingPoint* GetSwingLow(int index = 0);
// Visualization
void DrawBOS();
void DrawSwingPoints();
};
```
### CLiquiditySweepDetector
**File**: `Include/MarketStructure/LiquiditySweep.mqh`
Detects liquidity sweeps and stop hunts in the market.
#### Key Methods
```mql5
class CLiquiditySweepDetector
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void SetParameters(double sensitivity, double min_strength);
// Detection
bool DetectLiquidityZones();
bool CheckForSweep();
bool IsValidSweep(const SLiquiditySweep &sweep);
// Analysis
double CalculateSweepStrength(const SLiquiditySweep &sweep);
SLiquidityZone* GetNearestLiquidityZone(double price);
bool IsLiquidityGrabbed(const SLiquidityZone &zone);
// Management
void UpdateLiquidityZones();
void CleanupOldSweeps();
// Visualization
void DrawLiquidityZones();
void DrawSweeps();
};
```
### CFairValueGapDetector
**File**: `Include/MarketStructure/FairValueGap.mqh`
Identifies and manages Fair Value Gaps (imbalance zones) in price action.
#### Key Methods
```mql5
class CFairValueGapDetector
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void SetParameters(int min_size, int max_age, bool require_confirmation);
// Detection
bool DetectFairValueGaps();
bool IsValidFVG(const SFairValueGap &fvg);
bool IsFVGFilled(const SFairValueGap &fvg);
// Analysis
SFairValueGap* GetNearestFVG(double price, ENUM_FVG_TYPE type);
double GetFVGFillPercentage(const SFairValueGap &fvg);
bool IsFVGActive(const SFairValueGap &fvg);
// Management
void UpdateFVGStatus();
void CleanupFilledFVGs();
// Visualization
void DrawFairValueGaps();
void UpdateFVGDisplay();
};
```
### CEntryStrategy
**File**: `Include/MarketStructure/EntryStrategy.mqh`
Combines all market structure components to generate entry signals.
#### Key Methods
```mql5
class CEntryStrategy
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void ConfigureDetectors();
void SetRequirements(bool require_ob, bool require_bos, bool require_ls, bool require_fvg);
// Analysis
SEntrySignal AnalyzeEntry();
bool ValidateSignal(const SEntrySignal &signal);
double CalculateSignalStrength(const SEntrySignal &signal);
// Signal Management
bool IsSignalValid(const SEntrySignal &signal);
void UpdateSignalStatus();
void ClearExpiredSignals();
// Integration
void SetOrderBlockDetector(COrderBlockDetector* detector);
void SetBOSDetector(CBreakOfStructureDetector* detector);
void SetLiquiditySweepDetector(CLiquiditySweepDetector* detector);
void SetFVGDetector(CFairValueGapDetector* detector);
};
```
---
## Risk Management
### CRiskManager
**File**: `Include/RiskManagement/RiskManager.mqh`
Comprehensive risk management system handling position sizing, stop losses, and portfolio risk.
#### Key Methods
```mql5
class CRiskManager
{
public:
// Initialization
bool Initialize(string symbol);
void SetRiskProfile(const SRiskProfile &profile);
void SetAccountInfo(double balance, double equity, double margin);
// Position Sizing
double CalculatePositionSize(double entry_price, double stop_loss, double risk_amount);
double CalculateRiskAmount(double risk_percent);
bool ValidatePositionSize(double lot_size);
// Stop Loss & Take Profit
double CalculateStopLoss(double entry_price, ENUM_ORDER_TYPE order_type, ENUM_SL_METHOD method);
double CalculateTakeProfit(double entry_price, double stop_loss, ENUM_TP_METHOD method);
double CalculateTrailingStop(double current_price, double entry_price, ENUM_ORDER_TYPE order_type);
// Risk Validation
bool ValidateRisk(double entry_price, double stop_loss, double lot_size);
bool CheckAccountRisk();
bool CheckDrawdownLimit();
bool CheckDailyLossLimit();
// Position Management
bool UpdatePosition(const SPositionInfo &position);
void CalculateUnrealizedPnL();
void UpdateRiskMetrics();
// Emergency Controls
bool TriggerEmergencyStop();
void CloseAllPositions();
void ReducePositionSizes(double reduction_factor);
// Reporting
SRiskStats GetRiskStatistics();
double GetCurrentDrawdown();
double GetMaxDrawdown();
double GetSharpeRatio();
double GetSortinoRatio();
};
```
#### SRiskProfile Structure
```mql5
struct SRiskProfile
{
ENUM_RISK_MODEL risk_model; // Risk model type
double risk_percent; // Risk per trade (%)
double max_risk_percent; // Maximum account risk (%)
double min_position_size; // Minimum lot size
double max_position_size; // Maximum lot size
ENUM_SL_METHOD sl_method; // Stop loss method
ENUM_TP_METHOD tp_method; // Take profit method
double sl_atr_multiplier; // SL ATR multiplier
double tp_rr_ratio; // Take profit risk-reward ratio
bool use_trailing_stop; // Enable trailing stop
double trailing_atr_multiplier; // Trailing stop ATR multiplier
double max_drawdown_percent; // Maximum drawdown limit
double daily_loss_limit; // Daily loss limit (%)
bool use_time_stop; // Enable time-based stop
int max_trade_duration_hours; // Maximum trade duration
};
```
---
## Session Management
### CSessionManager
**File**: `Include/SessionManagement/SessionManager.mqh`
Manages trading sessions and time-based filters for optimal trade timing.
#### Key Methods
```mql5
class CSessionManager
{
public:
// Initialization
bool Initialize();
void SetSessionConfig(const SSessionConfig &config);
void SetTimeZone(int gmt_offset);
// Session Analysis
ENUM_TRADING_SESSION GetCurrentSession();
ENUM_SESSION_PHASE GetSessionPhase();
bool IsSessionActive(ENUM_TRADING_SESSION session);
bool IsTradingAllowed();
// Session Statistics
SSessionStats GetSessionStats(ENUM_TRADING_SESSION session);
double GetSessionVolatility(ENUM_TRADING_SESSION session);
ENUM_VOLATILITY_LEVEL GetVolatilityLevel();
// Time Analysis
datetime GetSessionStart(ENUM_TRADING_SESSION session);
datetime GetSessionEnd(ENUM_TRADING_SESSION session);
int GetMinutesUntilSessionEnd();
bool IsSessionOverlap();
// Trading Permissions
bool CanOpenPosition();
bool CanClosePosition();
bool ShouldAvoidTrading();
// Session Reporting
void UpdateSessionStatistics();
SCurrentSessionInfo GetCurrentSessionInfo();
string GetSessionReport();
};
```
#### SSessionConfig Structure
```mql5
struct SSessionConfig
{
// Session Enable/Disable
bool trade_asia_session; // Trade Asia session
bool trade_london_session; // Trade London session
bool trade_ny_session; // Trade New York session
// Session Times (Server Time)
string asia_start; // Asia session start time
string asia_end; // Asia session end time
string london_start; // London session start time
string london_end; // London session end time
string ny_start; // New York session start time
string ny_end; // New York session end time
// Session Filters
double min_session_volatility; // Minimum volatility requirement
double max_session_volatility; // Maximum volatility limit
bool require_session_breakout; // Require session breakout
bool avoid_session_start; // Avoid trading at session start
bool avoid_session_end; // Avoid trading at session end
int avoid_minutes; // Minutes to avoid at session boundaries
};
```
---
## AI Integration
### CGrokAI
**File**: `Include/AIIntegration/GrokAI.mqh`
Integrates Grok AI for fundamental analysis, sentiment analysis, and news impact assessment.
#### Key Methods
```mql5
class CGrokAI
{
public:
// Initialization
bool Initialize(string api_key, string base_url = "");
void SetConfiguration(const SGrokConfig &config);
bool TestConnection();
// Analysis Methods
SGrokAnalysis GetFundamentalAnalysis(string symbol);
SGrokSentiment GetSentimentAnalysis(string symbol);
SGrokNews GetNewsAnalysis(string symbol, int hours_back = 24);
// Market Analysis
double GetMarketBias(string symbol);
ENUM_MARKET_SENTIMENT GetOverallSentiment(string symbol);
bool ShouldAvoidTrading(string symbol);
// News Impact
double GetNewsImpact(const SGrokNews &news);
bool IsHighImpactNews(const SGrokNews &news);
datetime GetNextNewsTime(string symbol);
// AI Signals
SGrokSignal GetTradingSignal(string symbol);
bool ValidateAISignal(const SGrokSignal &signal);
double GetSignalConfidence(const SGrokSignal &signal);
// Cache Management
void UpdateCache();
void ClearCache();
bool IsCacheValid(string symbol);
// Error Handling
string GetLastError();
bool IsAPIAvailable();
void HandleAPIError(int error_code);
};
```
#### SGrokAnalysis Structure
```mql5
struct SGrokAnalysis
{
string symbol; // Currency pair
datetime timestamp; // Analysis timestamp
double confidence; // Analysis confidence (0.0-1.0)
ENUM_MARKET_BIAS bias; // Market bias (bullish/bearish/neutral)
string fundamental_factors; // Key fundamental factors
double economic_score; // Economic strength score
double technical_score; // Technical analysis score
double overall_score; // Overall analysis score
string summary; // Analysis summary
string recommendations; // Trading recommendations
};
```
---
## Backtesting Framework
### CBacktester
**File**: `Include/Utils/Backtester.mqh`
Comprehensive backtesting system with advanced statistics and optimization capabilities.
#### Key Methods
```mql5
class CBacktester
{
public:
// Initialization
bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe);
void SetBacktestConfig(const SBacktestConfig &config);
void SetDateRange(datetime start_date, datetime end_date);
// Backtest Execution
bool RunBacktest();
bool RunOptimization();
bool RunWalkForward();
bool RunMonteCarloAnalysis();
// Trade Processing
void ProcessTick(const MqlTick &tick);
bool OpenPosition(ENUM_ORDER_TYPE type, double volume, double price, double sl, double tp);
bool ClosePosition(int position_id, double price);
void UpdatePositions();
// Statistics Calculation
SBacktestStats CalculateStatistics();
double CalculateSharpeRatio();
double CalculateSortinoRatio();
double CalculateMaxDrawdown();
double CalculateProfitFactor();
double CalculateRecoveryFactor();
// Risk Metrics
double CalculateVaR(double confidence_level = 0.95);
double CalculateExpectedShortfall(double confidence_level = 0.95);
double CalculateCalmarRatio();
double CalculateUlcerIndex();
// Report Generation
bool GenerateReport(string filename);
bool GenerateHTMLReport(string filename);
bool ExportTradesToCSV(string filename);
string GetSummaryReport();
// Optimization
void AddOptimizationParameter(string name, double start, double stop, double step);
SOptimizationResult GetBestParameters();
void SetOptimizationCriteria(ENUM_OPTIMIZATION_CRITERIA criteria);
// Integration
void SetEntryStrategy(CEntryStrategy* strategy);
void SetRiskManager(CRiskManager* risk_manager);
void SetSessionManager(CSessionManager* session_manager);
void SetGrokAI(CGrokAI* grok_ai);
};
```
#### SBacktestStats Structure
```mql5
struct SBacktestStats
{
// Basic Statistics
int total_trades; // Total number of trades
int winning_trades; // Number of winning trades
int losing_trades; // Number of losing trades
double win_rate; // Win rate percentage
double gross_profit; // Total gross profit
double gross_loss; // Total gross loss
double net_profit; // Net profit
double profit_factor; // Profit factor
// Trade Analysis
double average_win; // Average winning trade
double average_loss; // Average losing trade
double largest_win; // Largest winning trade
double largest_loss; // Largest losing trade
double expected_payoff; // Expected payoff per trade
// Risk Metrics
double max_drawdown; // Maximum drawdown
double max_drawdown_percent; // Maximum drawdown percentage
double recovery_factor; // Recovery factor
double sharpe_ratio; // Sharpe ratio
double sortino_ratio; // Sortino ratio
double calmar_ratio; // Calmar ratio
// Time Analysis
datetime backtest_start; // Backtest start date
datetime backtest_end; // Backtest end date
int total_bars; // Total bars processed
double bars_per_trade; // Average bars per trade
// Advanced Metrics
double var_95; // Value at Risk (95%)
double expected_shortfall; // Expected Shortfall
double ulcer_index; // Ulcer Index
double sterling_ratio; // Sterling Ratio
double burke_ratio; // Burke Ratio
};
```
---
## Visualization System
### CChartManager
**File**: `Include/Visualization/ChartManager.mqh`
Advanced chart visualization system for displaying market structure, signals, and performance metrics.
#### Key Methods
```mql5
class CChartManager
{
public:
// Initialization
bool Initialize(long chart_id = 0);
void SetColorScheme(const SColorScheme &colors);
void SetDisplaySettings(const SDisplaySettings &settings);
// Market Structure Visualization
void DrawOrderBlock(const SOrderBlock &block);
void DrawBreakOfStructure(const SBOS &bos);
void DrawLiquiditySweep(const SLiquiditySweep &sweep);
void DrawFairValueGap(const SFairValueGap &fvg);
void DrawSwingPoints(const SSwingPoint &swing);
// Signal Visualization
void DrawEntrySignal(const SEntrySignal &signal);
void DrawExitSignal(double price, datetime time, ENUM_SIGNAL_TYPE type);
void DrawSignalArrow(double price, datetime time, int arrow_code, color clr);
// Session Visualization
void DrawSessionBox(ENUM_TRADING_SESSION session, datetime start, datetime end);
void UpdateSessionDisplay();
void HighlightCurrentSession();
// Performance Visualization
void DrawEquityCurve();
void DrawDrawdownChart();
void UpdatePerformanceMetrics();
void DisplayTradeStatistics();
// Object Management
void CreateChartObject(string name, ENUM_OBJECT type, datetime time, double price);
void UpdateChartObject(string name, double price, datetime time = 0);
void DeleteChartObject(string name);
void DeleteAllObjects(string prefix = "");
// Alerts and Notifications
void ShowAlert(string message, ENUM_ALERT_TYPE type);
void PlaySound(string sound_file);
void SendNotification(string message);
void SendEmail(string subject, string message);
// Display Control
void SetObjectVisibility(string name, bool visible);
void SetTimeframeDisplay(ENUM_TIMEFRAMES tf);
void RefreshChart();
void UpdateDisplay();
};
```
#### SColorScheme Structure
```mql5
struct SColorScheme
{
// Market Structure Colors
color bullish_color; // Bullish structure color
color bearish_color; // Bearish structure color
color neutral_color; // Neutral structure color
// Signal Colors
color buy_signal_color; // Buy signal color
color sell_signal_color; // Sell signal color
color exit_signal_color; // Exit signal color
// Session Colors
color asia_session_color; // Asia session color
color london_session_color; // London session color
color ny_session_color; // New York session color
color overlap_color; // Session overlap color
// Performance Colors
color profit_color; // Profit color
color loss_color; // Loss color
color breakeven_color; // Breakeven color
// Text and Background
color text_color; // Text color
color background_color; // Background color
color grid_color; // Grid color
};
```
---
## Utility Classes
### CUtils
**File**: `Include/Utils/Utils.mqh`
General utility functions and helpers used throughout the EA.
#### Key Methods
```mql5
class CUtils
{
public:
// Time Functions
static datetime ServerTimeToGMT(datetime server_time);
static datetime GMTToServerTime(datetime gmt_time);
static bool IsMarketOpen();
static int GetDayOfWeek(datetime time);
// Price Functions
static double NormalizePrice(double price, string symbol);
static double CalculateATR(string symbol, ENUM_TIMEFRAMES timeframe, int period);
static double GetSpread(string symbol);
static double GetTickValue(string symbol);
// Math Functions
static double CalculateStandardDeviation(double &array[]);
static double CalculateCorrelation(double &array1[], double &array2[]);
static double LinearRegression(double &x[], double &y[], int period);
// String Functions
static string TimeToString(datetime time, string format = "yyyy.mm.dd hh:mi:ss");
static string DoubleToString(double value, int digits);
static bool StringToDouble(string str, double &result);
// File Functions
static bool FileExists(string filename);
static bool CreateDirectory(string path);
static long GetFileSize(string filename);
// Validation Functions
static bool IsValidSymbol(string symbol);
static bool IsValidTimeframe(ENUM_TIMEFRAMES timeframe);
static bool IsValidPrice(double price);
static bool IsValidVolume(double volume);
};
```
---
## Data Structures
### Core Structures
#### SEntrySignal
```mql5
struct SEntrySignal
{
datetime timestamp; // Signal timestamp
ENUM_ORDER_TYPE signal_type; // Signal type (buy/sell)
double entry_price; // Entry price
double stop_loss; // Stop loss price
double take_profit; // Take profit price
double confidence; // Signal confidence (0.0-1.0)
string reason; // Signal reason/description
// Component Confirmations
bool order_block_confirmed; // Order block confirmation
bool bos_confirmed; // Break of structure confirmation
bool liquidity_sweep_confirmed; // Liquidity sweep confirmation
bool fvg_confirmed; // Fair value gap confirmation
bool session_confirmed; // Session filter confirmation
bool ai_confirmed; // AI analysis confirmation
// Risk Information
double risk_amount; // Risk amount for this signal
double position_size; // Calculated position size
double risk_reward_ratio; // Risk-reward ratio
// Metadata
string signal_id; // Unique signal identifier
bool is_valid; // Signal validity status
datetime expiry_time; // Signal expiry time
};
```
#### STradeInfo
```mql5
struct STradeInfo
{
int trade_id; // Trade identifier
string symbol; // Trading symbol
ENUM_ORDER_TYPE type; // Order type
double volume; // Trade volume
double open_price; // Open price
double close_price; // Close price
double stop_loss; // Stop loss price
double take_profit; // Take profit price
datetime open_time; // Open time
datetime close_time; // Close time
double profit; // Trade profit
double commission; // Commission paid
double swap; // Swap charges
string comment; // Trade comment
ENUM_TRADE_RESULT result; // Trade result (win/loss/breakeven)
double mae; // Maximum Adverse Excursion
double mfe; // Maximum Favorable Excursion
int bars_held; // Bars held in trade
double entry_signal_strength; // Entry signal strength
string exit_reason; // Exit reason
};
```
---
## Enumerations
### Trading Enums
```mql5
// Order Block Types
enum ENUM_ORDER_BLOCK_TYPE
{
ORDER_BLOCK_BULLISH, // Bullish order block
ORDER_BLOCK_BEARISH, // Bearish order block
ORDER_BLOCK_ALL // All order blocks
};
// Break of Structure Types
enum ENUM_BOS_TYPE
{
BOS_TYPE_BULLISH, // Bullish BOS
BOS_TYPE_BEARISH, // Bearish BOS
BOS_TYPE_ALL // All BOS types
};
// BOS Confirmation Methods
enum ENUM_BOS_CONFIRMATION_METHOD
{
BOS_CONFIRM_CLOSE, // Close price confirmation
BOS_CONFIRM_BODY, // Candle body confirmation
BOS_CONFIRM_WICK // Wick confirmation
};
// Fair Value Gap Types
enum ENUM_FVG_TYPE
{
FVG_TYPE_BULLISH, // Bullish FVG
FVG_TYPE_BEARISH, // Bearish FVG
FVG_TYPE_ALL // All FVG types
};
// Trading Sessions
enum ENUM_TRADING_SESSION
{
SESSION_ASIA, // Asia session
SESSION_LONDON, // London session
SESSION_NEW_YORK, // New York session
SESSION_OVERLAP_LONDON_NY, // London-NY overlap
SESSION_NONE // No active session
};
// Session Phases
enum ENUM_SESSION_PHASE
{
PHASE_PRE_MARKET, // Pre-market phase
PHASE_OPENING, // Opening phase
PHASE_ACTIVE, // Active trading phase
PHASE_CLOSING, // Closing phase
PHASE_POST_MARKET // Post-market phase
};
// Risk Models
enum ENUM_RISK_MODEL
{
RISK_FIXED_LOT, // Fixed lot size
RISK_PERCENT_BALANCE, // Percentage of balance
RISK_ATR_BASED, // ATR-based sizing
RISK_VOLATILITY_ADJUSTED // Volatility-adjusted sizing
};
// Stop Loss Methods
enum ENUM_SL_METHOD
{
SL_FIXED_POINTS, // Fixed points
SL_ATR_MULTIPLE, // ATR multiple
SL_STRUCTURE_BASED, // Structure-based
SL_VOLATILITY_BASED // Volatility-based
};
// Take Profit Methods
enum ENUM_TP_METHOD
{
TP_FIXED_POINTS, // Fixed points
TP_ATR_MULTIPLE, // ATR multiple
TP_RISK_REWARD, // Risk-reward ratio
TP_STRUCTURE_BASED // Structure-based
};
// Market Sentiment
enum ENUM_MARKET_SENTIMENT
{
SENTIMENT_VERY_BEARISH, // Very bearish
SENTIMENT_BEARISH, // Bearish
SENTIMENT_NEUTRAL, // Neutral
SENTIMENT_BULLISH, // Bullish
SENTIMENT_VERY_BULLISH // Very bullish
};
// Log Levels
enum ENUM_LOG_LEVEL
{
LOG_LEVEL_ERROR, // Error messages only
LOG_LEVEL_WARNING, // Warning and error messages
LOG_LEVEL_INFO, // Info, warning, and error messages
LOG_LEVEL_DEBUG, // Debug and above
LOG_LEVEL_TRACE // All messages
};
```
---
## Usage Examples
### Basic EA Setup
```mql5
// Initialize core components
CLogger logger;
CEntryStrategy entry_strategy;
CRiskManager risk_manager;
CSessionManager session_manager;
CChartManager chart_manager;
// Initialize logger
logger.Initialize("SniperEA.log", LOG_LEVEL_INFO);
// Initialize entry strategy
entry_strategy.Initialize(Symbol(), Period());
entry_strategy.ConfigureDetectors();
// Initialize risk manager
SRiskProfile risk_profile;
risk_profile.risk_model = RISK_PERCENT_BALANCE;
risk_profile.risk_percent = 2.0;
risk_profile.sl_method = SL_ATR_MULTIPLE;
risk_profile.tp_method = TP_RISK_REWARD;
risk_manager.Initialize(Symbol());
risk_manager.SetRiskProfile(risk_profile);
// Initialize session manager
SSessionConfig session_config;
session_config.trade_london_session = true;
session_config.trade_ny_session = true;
session_config.london_start = "08:00";
session_config.london_end = "17:00";
session_manager.Initialize();
session_manager.SetSessionConfig(session_config);
// Initialize chart manager
chart_manager.Initialize();
```
### Signal Processing
```mql5
// Analyze entry opportunity
SEntrySignal signal = entry_strategy.AnalyzeEntry();
if(signal.is_valid && signal.confidence > 0.7)
{
// Check session permissions
if(session_manager.CanOpenPosition())
{
// Calculate position size
double position_size = risk_manager.CalculatePositionSize(
signal.entry_price,
signal.stop_loss,
risk_manager.CalculateRiskAmount(2.0)
);
// Validate risk
if(risk_manager.ValidateRisk(signal.entry_price, signal.stop_loss, position_size))
{
// Place order
int ticket = OrderSend(
Symbol(),
signal.signal_type,
position_size,
signal.entry_price,
3,
signal.stop_loss,
signal.take_profit,
"SniperEA Signal",
0,
0,
clrNONE
);
if(ticket > 0)
{
logger.LogInfo("Order placed successfully: " + IntegerToString(ticket));
chart_manager.DrawEntrySignal(signal);
}
else
{
logger.LogError("Failed to place order: " + IntegerToString(GetLastError()));
}
}
}
}
```
### Backtesting Example
```mql5
// Initialize backtester
CBacktester backtester;
backtester.Initialize(Symbol(), Period());
// Set backtest configuration
SBacktestConfig config;
config.start_date = StringToTime("2023.01.01");
config.end_date = StringToTime("2023.12.31");
config.initial_balance = 10000.0;
config.spread = 2.0;
config.commission = 7.0;
backtester.SetBacktestConfig(config);
// Set components
backtester.SetEntryStrategy(&entry_strategy);
backtester.SetRiskManager(&risk_manager);
backtester.SetSessionManager(&session_manager);
// Run backtest
if(backtester.RunBacktest())
{
// Get statistics
SBacktestStats stats = backtester.CalculateStatistics();
// Generate report
backtester.GenerateHTMLReport("backtest_report.html");
// Log results
logger.LogInfo("Backtest completed:");
logger.LogInfo("Total trades: " + IntegerToString(stats.total_trades));
logger.LogInfo("Win rate: " + DoubleToString(stats.win_rate, 2) + "%");
logger.LogInfo("Net profit: " + DoubleToString(stats.net_profit, 2));
logger.LogInfo("Max drawdown: " + DoubleToString(stats.max_drawdown_percent, 2) + "%");
logger.LogInfo("Sharpe ratio: " + DoubleToString(stats.sharpe_ratio, 3));
}
```
---
## Error Handling
### Common Error Codes
- **ERR_INVALID_PARAMETERS**: Invalid input parameters
- **ERR_NOT_INITIALIZED**: Component not properly initialized
- **ERR_INSUFFICIENT_DATA**: Insufficient historical data
- **ERR_INVALID_SYMBOL**: Invalid trading symbol
- **ERR_MARKET_CLOSED**: Market is closed
- **ERR_INSUFFICIENT_FUNDS**: Insufficient account funds
- **ERR_INVALID_STOPS**: Invalid stop loss or take profit levels
- **ERR_API_CONNECTION**: API connection failed
- **ERR_FILE_ACCESS**: File access error
### Error Handling Best Practices
1. Always check return values of initialization methods
2. Validate input parameters before processing
3. Use try-catch blocks for critical operations
4. Log errors with sufficient context information
5. Implement graceful degradation for non-critical failures
6. Provide meaningful error messages to users
---
## Performance Considerations
### Optimization Tips
1. **Minimize Indicator Calculations**: Cache indicator values and update only when necessary
2. **Efficient Object Management**: Clean up unused chart objects regularly
3. **Smart Data Processing**: Process only new bars, avoid recalculating historical data
4. **Memory Management**: Release unused arrays and objects
5. **API Rate Limiting**: Implement proper rate limiting for external API calls
### Resource Usage
- **Memory**: Typical usage 50-100MB depending on configuration
- **CPU**: Low to moderate CPU usage, spikes during analysis
- **Network**: Minimal for basic operation, higher with AI integration
- **Storage**: Log files and backtest data can grow over time
---
This API documentation provides comprehensive coverage of all classes, methods, and structures in the MT5 Sniper EA system. For additional examples and advanced usage patterns, refer to the example files in the `/examples` directory.
Reference in New Issue View Git Blame Copy Permalink