""" MEXC Session Manager Helper utilities for managing MEXC web sessions and extracting cookies from browser. """ import logging import json import re from typing import Dict, Optional, Any from pathlib import Path logger = logging.getLogger(__name__) class MEXCSessionManager: """ Helper class for managing MEXC web sessions and extracting browser cookies """ def __init__(self): self.session_file = Path("mexc_session.json") def extract_cookies_from_network_tab(self, cookie_header: str) -> Dict[str, str]: """ Extract cookies from browser Network tab cookie header Args: cookie_header: Raw cookie string from browser (copy from Request Headers) Returns: Dictionary of parsed cookies """ cookies = {} # Remove 'Cookie: ' prefix if present if cookie_header.startswith('Cookie: '): cookie_header = cookie_header[8:] elif cookie_header.startswith('cookie: '): cookie_header = cookie_header[8:] # Split by semicolon and parse each cookie cookie_pairs = cookie_header.split(';') for pair in cookie_pairs: pair = pair.strip() if '=' in pair: name, value = pair.split('=', 1) cookies[name.strip()] = value.strip() logger.info(f"Extracted {len(cookies)} cookies from browser") return cookies def validate_session_cookies(self, cookies: Dict[str, str]) -> bool: """ Validate that essential cookies are present for authentication Args: cookies: Dictionary of cookie name-value pairs Returns: bool: True if cookies appear valid for authentication """ required_cookies = [ 'uc_token', # User authentication token 'u_id', # User ID 'x-mxc-fingerprint', # Browser fingerprint 'mexc_fingerprint_visitorId' # Visitor ID ] missing_cookies = [] for cookie_name in required_cookies: if cookie_name not in cookies or not cookies[cookie_name]: missing_cookies.append(cookie_name) if missing_cookies: logger.warning(f"Missing required cookies: {missing_cookies}") return False logger.info("All required cookies are present") return True def save_session(self, cookies: Dict[str, str], metadata: Optional[Dict[str, Any]] = None): """ Save session cookies to file for reuse Args: cookies: Dictionary of cookies to save metadata: Optional metadata about the session """ session_data = { 'cookies': cookies, 'metadata': metadata or {}, 'timestamp': int(time.time()) } try: with open(self.session_file, 'w') as f: json.dump(session_data, f, indent=2) logger.info(f"Session saved to {self.session_file}") except Exception as e: logger.error(f"Failed to save session: {e}") def load_session(self) -> Optional[Dict[str, str]]: """ Load session cookies from file Returns: Dictionary of cookies if successful, None otherwise """ if not self.session_file.exists(): logger.info("No saved session found") return None try: with open(self.session_file, 'r') as f: session_data = json.load(f) cookies = session_data.get('cookies', {}) timestamp = session_data.get('timestamp', 0) # Check if session is too old (24 hours) import time if time.time() - timestamp > 24 * 3600: logger.warning("Saved session is too old (>24h), may be expired") if self.validate_session_cookies(cookies): logger.info("Loaded valid session from file") return cookies else: logger.warning("Loaded session has invalid cookies") return None except Exception as e: logger.error(f"Failed to load session: {e}") return None def extract_from_curl_command(self, curl_command: str) -> Dict[str, str]: """ Extract cookies from a curl command copied from browser Args: curl_command: Complete curl command from browser "Copy as cURL" Returns: Dictionary of extracted cookies """ cookies = {} # Find cookie header in curl command cookie_match = re.search(r'-H [\'"]cookie: ([^\'"]+)[\'"]', curl_command, re.IGNORECASE) if not cookie_match: cookie_match = re.search(r'--header [\'"]cookie: ([^\'"]+)[\'"]', curl_command, re.IGNORECASE) if cookie_match: cookie_header = cookie_match.group(1) cookies = self.extract_cookies_from_network_tab(cookie_header) logger.info(f"Extracted {len(cookies)} cookies from curl command") else: logger.warning("No cookie header found in curl command") return cookies def print_cookie_extraction_guide(self): """Print instructions for extracting cookies from browser""" print("\n" + "="*80) print("MEXC COOKIE EXTRACTION GUIDE") print("="*80) print(""" To extract cookies from your browser for MEXC futures trading: METHOD 1: Browser Network Tab 1. Open MEXC futures page and log in: https://www.mexc.com/en-GB/futures/ETH_USDT 2. Open browser Developer Tools (F12) 3. Go to Network tab 4. Try to place a small futures trade (it will fail, but we need the request) 5. Find the request to 'futures.mexc.com' in the Network tab 6. Right-click on the request -> Copy -> Copy request headers 7. Find the 'Cookie:' line and copy everything after 'Cookie: ' METHOD 2: Copy as cURL 1. Follow steps 1-5 above 2. Right-click on the futures API request -> Copy -> Copy as cURL 3. Paste the entire cURL command METHOD 3: Manual Cookie Extraction 1. While logged into MEXC, press F12 -> Application/Storage tab 2. On the left, expand 'Cookies' -> click on 'https://www.mexc.com' 3. Copy the values for these important cookies: - uc_token - u_id - x-mxc-fingerprint - mexc_fingerprint_visitorId IMPORTANT NOTES: - Cookies expire after some time (usually 24 hours) - You must be logged into MEXC futures (not just spot trading) - Keep your cookies secure - they provide access to your account - Test with small amounts first Example usage: session_manager = MEXCSessionManager() # Method 1: From cookie header cookie_header = "uc_token=ABC123; u_id=DEF456; ..." cookies = session_manager.extract_cookies_from_network_tab(cookie_header) # Method 2: From cURL command curl_cmd = "curl 'https://futures.mexc.com/...' -H 'cookie: uc_token=ABC123...'" cookies = session_manager.extract_from_curl_command(curl_cmd) # Save session for reuse session_manager.save_session(cookies) """) print("="*80) if __name__ == "__main__": # When run directly, show the extraction guide import time manager = MEXCSessionManager() manager.print_cookie_extraction_guide() print("\nWould you like to:") print("1. Load saved session") print("2. Extract cookies from clipboard") print("3. Exit") choice = input("\nEnter choice (1-3): ").strip() if choice == "1": cookies = manager.load_session() if cookies: print(f"\nLoaded {len(cookies)} cookies from saved session") if manager.validate_session_cookies(cookies): print("Session appears valid for trading") else: print("Warning: Session may be incomplete or expired") else: print("No valid saved session found") elif choice == "2": print("\nPaste your cookie header or cURL command:") user_input = input().strip() if user_input.startswith('curl'): cookies = manager.extract_from_curl_command(user_input) else: cookies = manager.extract_cookies_from_network_tab(user_input) if cookies and manager.validate_session_cookies(cookies): print(f"\nSuccessfully extracted {len(cookies)} valid cookies") save = input("Save session for reuse? (y/n): ").strip().lower() if save == 'y': manager.save_session(cookies) else: print("Failed to extract valid cookies") else: print("Goodbye!")