259 lines
8.8 KiB
Python
259 lines
8.8 KiB
Python
"""
|
|
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!") |