Automatiza Tu Estrategia de Trading con SimpleFX API

import asyncio
import websockets
import json
from datetime import datetime
import logging
import sys
import nest_asyncio
from websockets.exceptions import ConnectionClosed
import requests

# Apply nest_asyncio to allow nested event loops
nest_asyncio.apply()

# Set up logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class SimpleFXTrader:
    def __init__(self, client_id, client_secret):
        self.client_id = client_id
        self.client_secret = client_secret
        self.base_url = "https://rest.simplefx.com"
        self.token = None
        self.account_login = None
        self.account_reality = "DEMO"
        self.account_currency = "USD"
        self.price_precision = None
        
    def authenticate(self):
        """Authenticate and get token"""
        url = f"{self.base_url}/api/v3/auth/key"
        payload = {"clientId": self.client_id, "clientSecret": self.client_secret}
        headers = {"Content-Type": "application/json", "Accept": "application/json"}
        
        logger.info("Authenticating...")
        
        try:
            response = requests.post(url, json=payload, headers=headers)
            if response.status_code == 200:
                self.token = response.json()['data']['token']
                logger.info("✓ Authentication successful!")
                return True
            else:
                logger.error(f"✗ Authentication failed: {response.status_code}")
                logger.error(f"Response: {response.text}")
                return False
        except Exception as e:
            logger.error(f"✗ Error: {e}")
            return False
    
    def get_headers(self):
        return {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json",
            "Accept": "application/json"
        }
    
    def get_accounts(self):
        """Get account information"""
        url = f"{self.base_url}/api/v3/accounts"
        logger.info("Fetching accounts...")
        
        try:
            response = requests.get(url, headers=self.get_headers())
            if response.status_code == 200:
                accounts = response.json()['data']
                logger.info(f"✓ Found {len(accounts)} account(s)")
                
                for i, account in enumerate(accounts, 1):
                    logger.info(f"\n  [{i}] Login: {account['login']}")
                    logger.info(f"      Currency: {account['currency']}")
                    logger.info(f"      Balance: {account['balance']}")
                    logger.info(f"      Type: {account['reality']}")
                
                for account in accounts:
                    if account['balance'] > 0:
                        self.account_login = account['login']
                        self.account_reality = account['reality']
                        self.account_currency = account['currency']
                        logger.info(f"\n  ➜ Selected account: {self.account_login} ({self.account_reality})")
                        logger.info(f"     Balance: {account['balance']} {account['currency']}")
                        return True
                
                logger.error("✗ No account with balance found")
                return False
            else:
                logger.error(f"✗ Failed: {response.status_code}")
                logger.error(f"Response: {response.text}")
                return False
        except Exception as e:
            logger.error(f"✗ Error: {e}")
            return False
    
    def get_instrument_precision(self, symbol):
        """Get price precision for the symbol"""
        logger.info(f"Fetching instrument precision for {symbol}...")
        
        try:
            url = "https://simplefx.com/utils/instruments.json"
            response = requests.get(url, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                
                if isinstance(data, dict):
                    for key, instrument in data.items():
                        if isinstance(instrument, dict):
                            if instrument.get('symbol') == symbol or key == symbol:
                                digits = instrument.get('digits')
                                if digits is not None:
                                    self.price_precision = digits
                                    logger.info(f"  ✓ Precision: {digits} digits")
                                    return digits
                
                elif isinstance(data, list):
                    for instrument in data:
                        if isinstance(instrument, dict):
                            if instrument.get('symbol') == symbol:
                                digits = instrument.get('digits')
                                if digits is not None:
                                    self.price_precision = digits
                                    logger.info(f"  ✓ Precision: {digits} digits")
                                    return digits
                
                logger.warning(f"  ⚠ Symbol not found, using default: 2 digits")
                self.price_precision = 2
                return 2
            else:
                logger.warning(f"  Using default precision: 2 digits")
                self.price_precision = 2
                return 2
                
        except Exception as e:
            logger.error(f"  ✗ Error: {e}")
            self.price_precision = 2
            return 2
    
    def round_price(self, price):
        """Round price to instrument's precision"""
        if self.price_precision is None:
            self.price_precision = 2
        return round(price, self.price_precision)
    
    def open_market_order(self, symbol, side, amount, tp_price=None, sl_price=None):
        """Open a market order"""
        url = f"{self.base_url}/api/v3/trading/orders/market"
        
        order_data = {
            "Reality": self.account_reality,
            "Login": self.account_login,
            "Symbol": symbol,
            "Side": side.upper(),
            "Volume": amount,
            "IsFIFO": True
        }
        
        if tp_price:
            order_data["TakeProfit"] = tp_price
        if sl_price:
            order_data["StopLoss"] = sl_price
        
        logger.info(f"\n{'='*60}")
        logger.info(f"Placing {side.upper()} Market Order")
        logger.info(f"{'='*60}")
        logger.info(f"  Symbol: {symbol}")
        logger.info(f"  Volume: {amount} lots")
        logger.info(f"  Account: {self.account_login} ({self.account_reality})")
        if tp_price:
            logger.info(f"  Take Profit: ${tp_price:,.{self.price_precision}f}")
        if sl_price:
            logger.info(f"  Stop Loss: ${sl_price:,.{self.price_precision}f}")
        
        try:
            response = requests.post(url, json=order_data, headers=self.get_headers(), timeout=10)
            
            if response.status_code in [200, 201]:
                response_data = response.json()
                logger.info(f"\n✓ SUCCESS! Market order placed")
                
                market_orders = response_data.get('data', {}).get('marketOrders', [])
                if market_orders:
                    order = market_orders[0].get('order', {})
                    order_id = order.get('id')
                    open_price = order.get('openPrice')
                    
                    logger.info(f"\n✓ Order Details:")
                    logger.info(f"  Order ID: {order_id}")
                    logger.info(f"  Symbol: {order.get('symbol')}")
                    logger.info(f"  Side: {order.get('side')}")
                    logger.info(f"  Volume: {order.get('volume')}")
                    if open_price:
                        logger.info(f"  Open Price: ${open_price:,.{self.price_precision}f}")
                    
                    return {
                        "id": order_id,
                        "open_price": open_price,
                        "volume": order.get('volume'),
                        "side": order.get('side'),
                        "symbol": order.get('symbol')
                    }
                return response_data
            else:
                logger.error(f"\n✗ FAILED to place order")
                logger.error(f"Status Code: {response.status_code}")
                return None
                
        except Exception as e:
            logger.error(f"\n✗ ERROR: {e}")
            return None

class GoldPriceMonitor:
    def __init__(self, trader, target_price, amount=0.01, tp_distance=None, sl_distance=None):
        self.trader = trader
        self.target_price = target_price
        self.amount = amount
        self.tp_distance = tp_distance
        self.sl_distance = sl_distance
        self.symbol = "XAUUSD"
        self.running = True
        self.order_placed = False
        self.ws = None
        self.subscription_id = 0
        self.last_log_time = None
        self.trigger_ask = None
        
    async def connect_and_monitor(self):
        """Connect to WebSocket and monitor XAUUSD prices"""
        uri = "wss://web-quotes-core.simplefx.com/websocket/quotes"
        
        logger.info(f"\n{'='*60}")
        logger.info("Starting Price Monitor")
        logger.info(f"{'='*60}")
        logger.info(f"  Symbol: {self.symbol}")
        logger.info(f"  Target Price: ${self.target_price:,.2f}")
        logger.info(f"  Action: Waiting for price to drop BELOW target")
        logger.info(f"  Trade Size: {self.amount} lots")
        if self.tp_distance:
            logger.info(f"  Take Profit: ${self.tp_distance} above entry")
        if self.sl_distance:
            logger.info(f"  Stop Loss: ${self.sl_distance} below entry")
        logger.info(f"{'='*60}\n")
        
        while self.running and not self.order_placed:
            try:
                async with websockets.connect(uri) as ws:
                    self.ws = ws
                    logger.info("✓ Connected to WebSocket")
                    
                    # Subscribe to XAUUSD
                    self.subscription_id += 1
                    subscription_message = json.dumps({
                        "p": "/subscribe/addList",
                        "i": self.subscription_id,
                        "d": [self.symbol]
                    })
                    await ws.send(subscription_message)
                    logger.info(f"✓ Subscribed to {self.symbol} prices")
                    logger.info(f"\n⏳ Monitoring prices... (Press Ctrl+C to stop)\n")
                    
                    # Start heartbeat
                    heartbeat_task = asyncio.create_task(self._send_heartbeat(ws))
                    
                    try:
                        while self.running and not self.order_placed:
                            response = await ws.recv()
                            await self.process_quote(response)
                    except ConnectionClosed:
                        if not self.order_placed:
                            logger.warning("WebSocket closed, reconnecting...")
                    finally:
                        heartbeat_task.cancel()
                        
            except Exception as e:
                if self.running and not self.order_placed:
                    logger.error(f"Connection error: {str(e)}")
                    logger.info("Reconnecting in 5 seconds...")
                    await asyncio.sleep(5)
                else:
                    break
    
    async def _send_heartbeat(self, ws):
        """Send periodic heartbeat"""
        while self.running and not self.order_placed:
            try:
                await asyncio.sleep(30)
                await ws.send(json.dumps({"type": "ping"}))
            except Exception as e:
                logger.error(f"Heartbeat error: {str(e)}")
                break
    
    async def process_quote(self, quote_data):
        """Process incoming quote and check if we should trade"""
        try:
            data = json.loads(quote_data)
            
            if data.get("p") == "/quotes/subscribed":
                quotes_data = data.get("d", [])
                for quote in quotes_data:
                    symbol = quote.get("s")
                    if symbol == self.symbol:
                        bid = quote.get("b")
                        ask = quote.get("a")
                        
                        if bid and ask:
                            current_time = datetime.now()
                            
                            # Log every 2 seconds
                            if self.last_log_time is None or (current_time - self.last_log_time).total_seconds() >= 2:
                                time_str = current_time.strftime('%H:%M:%S')
                                logger.info(f"[{time_str}] {symbol} - Bid: ${bid:,.2f} | Ask: ${ask:,.2f} | Target: ${self.target_price:,.2f}")
                                self.last_log_time = current_time
                            
                            # Check if ask price is below target
                            if ask <= self.target_price and not self.order_placed:
                                self.order_placed = True
                                self.trigger_ask = ask
                                
                                logger.info(f"\n{'='*60}")
                                logger.info(f"🎯 TARGET REACHED!")
                                logger.info(f"{'='*60}")
                                logger.info(f"  Current Ask: ${ask:,.2f}")
                                logger.info(f"  Target Price: ${self.target_price:,.2f}")
                                logger.info(f"{'='*60}\n")
                                
                                # Close WebSocket before placing order
                                self.running = False
                                if self.ws:
                                    await self.ws.close()
                                
                                await asyncio.sleep(1)
                                self.place_order_sync()
                        
        except json.JSONDecodeError as e:
            logger.error(f"Error decoding JSON: {e}")
        except Exception as e:
            logger.error(f"Error processing quote: {str(e)}")
    
    def place_order_sync(self):
        """Place order after WebSocket is closed"""
        tp_price = None
        sl_price = None
        
        if self.tp_distance:
            tp_price = self.trader.round_price(self.trigger_ask + self.tp_distance)
        if self.sl_distance:
            sl_price = self.trader.round_price(self.trigger_ask - self.sl_distance)
        
        order = self.trader.open_market_order(
            self.symbol, 
            "BUY", 
            self.amount,
            tp_price,
            sl_price
        )
        
        if order:
            logger.info(f"\n✓✓✓ Order placed successfully!")
        else:
            logger.error(f"\n✗ Failed to place order")
    
    def stop(self):
        """Stop monitoring"""
        self.running = False

async def main():
    print("""
╔══════════════════════════════════════════════════════════╗
║         XAUUSD Price Threshold Trading Bot              ║
║     Automatically opens BUY when price drops below       ║
║              your specified target price                 ║
╚══════════════════════════════════════════════════════════╝
    """)
    
    # Configuration
    CLIENT_ID = input("\n🔑 Enter your SimpleFX Client ID: ").strip()
    CLIENT_SECRET = input("🔑 Enter your SimpleFX Client Secret: ").strip()
    
    if not CLIENT_ID or not CLIENT_SECRET:
        print("\n✗ Error: Client ID and Secret are required")
        return
    
    # Get target price
    while True:
        try:
            target_price_input = input("\n💰 Enter target price for XAUUSD: $").strip()
            target_price = float(target_price_input)
            if target_price > 0:
                break
            else:
                print("  ✗ Please enter a positive number")
        except ValueError:
            print("  ✗ Invalid input. Please enter a valid price")
    
    # Get trade size
    while True:
        try:
            amount_input = input("\n📊 Enter trade size in lots (e.g., 0.01): ").strip() or "0.01"
            amount = float(amount_input)
            if amount > 0:
                break
            else:
                print("  ✗ Please enter a positive number")
        except ValueError:
            print("  ✗ Invalid input")
    
    # Get TP and SL
    print(f"\n{'='*60}")
    print("TAKE PROFIT & STOP LOSS (Optional)")
    print("="*60)
    
    tp_distance = None
    sl_distance = None
    
    tp_input = input("\n💰 Take Profit distance in $ (e.g., 10): $").strip()
    if tp_input:
        try:
            tp_distance = float(tp_input)
            if tp_distance > 0:
                print(f"  ➜ Take Profit set to ${tp_distance}")
            else:
                tp_distance = None
        except ValueError:
            print("  ✗ Invalid input, skipping Take Profit")
    
    sl_input = input("\n🛡️  Stop Loss distance in $ (e.g., 5): $").strip()
    if sl_input:
        try:
            sl_distance = float(sl_input)
            if sl_distance > 0:
                print(f"  ➜ Stop Loss set to ${sl_distance}")
            else:
                sl_distance = None
        except ValueError:
            print("  ✗ Invalid input, skipping Stop Loss")
    
    # Summary
    print(f"\n{'='*60}")
    print("CONFIGURATION SUMMARY")
    print("="*60)
    print(f"  Symbol: XAUUSD (Gold)")
    print(f"  Target Price: ${target_price:,.2f}")
    print(f"  Trade Size: {amount} lots")
    print(f"  Action: BUY when Ask price ≤ ${target_price:,.2f}")
    if tp_distance:
        print(f"  Take Profit: ${tp_distance} above entry")
    if sl_distance:
        print(f"  Stop Loss: ${sl_distance} below entry")
    print("="*60)
    
    user_input = input(f"\n⚠  Start monitoring? (yes/no): ").strip().lower()
    
    if user_input != 'yes':
        print("\n👋 Cancelled.")
        return
    
    # Initialize trader
    trader = SimpleFXTrader(CLIENT_ID, CLIENT_SECRET)
    
    if not trader.authenticate():
        print("\n✗ Authentication failed. Exiting.")
        return
    
    if not trader.get_accounts():
        print("\n✗ Failed to get accounts. Exiting.")
        return
    
    trader.get_instrument_precision("XAUUSD")
    
    # Start monitoring
    monitor = GoldPriceMonitor(trader, target_price, amount, tp_distance, sl_distance)
    
    try:
        await monitor.connect_and_monitor()
        
        if monitor.order_placed:
            print(f"\n{'='*60}")
            print("🎉 TRADE COMPLETED!")
            print("="*60)
        else:
            print(f"\n⚠  Monitor stopped without placing order")
            
    except KeyboardInterrupt:
        print("\n\n⚠ Interrupted by user!")
        monitor.stop()
        print("👋 Goodbye!")
    except Exception as e:
        logger.error(f"\n✗ Unexpected error: {e}")

if __name__ == "__main__":
    if sys.platform == 'win32':
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
    
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\n\n👋 Goodbye!")