### File: main.py
#!/usr/bin/env python3
"""Main entry point for SpotSync Alpha - Master-Follower Replication Engine"""

import logging
import signal
import sys
import time
from datetime import datetime
from typing import Dict, Optional

from database.models import init_db, SessionLocal
from core.trade_watcher import TradeWatcher
from core.trade_executor import TradeExecutor
from config.settings import MASTER_API_CONFIG

class TradingEngine:
    """Orchestrates the complete trade replication lifecycle"""
    
    def __init__(self, poll_interval: int = 30):
        self.running = False
        self.poll_interval = poll_interval
        self.logger = logging.getLogger(__name__)
        
        # Initialize components
        init_db()
        self.trade_watcher = TradeWatcher(MASTER_API_CONFIG)
        self.trade_executor = TradeExecutor()
        
    def start(self):
        """Start the main engine loop"""
        self.running = True
        self.logger.info("🚀 SpotSync Alpha Engine starting...")
        
        self.setup_signal_handlers()
        
        # Main execution loop
        while self.running:
            try:
                # Poll for new trades from master
                new_trades = self.trade_watcher.poll_for_new_trades()
                
                if new_trades:
                    self.logger.info(f"📊 Detected {len(new_trades)} new master trades to replicate")
                    
                    # Execute each trade on all active followers
                    for trade in new_trades:
                        self.trade_executor.execute_trade_on_followers(trade)
                
                # Sleep until next poll
                time.sleep(self.poll_interval)
                
            except KeyboardInterrupt:
                self.logger.info("⚠️ Shutdown signal received")
                break
            except Exception as e:
                self.logger.error(f"❌ Unexpected error in main loop: {e}", exc_info=True)
                time.sleep(self.poll_interval)  # Don't crash on single error
    
    def setup_signal_handlers(self):
        """Handle graceful shutdown on SIGINT/SIGTERM"""
        signal.signal(signal.SIGINT, self.shutdown_handler)
        signal.signal(signal.SIGTERM, self.shutdown_handler)

# More code follows...
                        

### File: core/trade_watcher.py
#!/usr/bin/env python3
"""Poll master account for executed trades and filter new ones"""

import logging
from typing import List, Dict, Optional
from datetime import datetime

import requests
from sqlalchemy.orm import Session

from database.models import get_session, SystemState
from config.settings import MASTER_API_CONFIG

class TradeWatcher:
    """Monitors master account for new executed trades"""
    
    def __init__(self, master_config: Dict):
        self.master_config = master_config
        self.logger = logging.getLogger(__name__)
        self.base_url = "https://api.binance.com/api/v3"
        
    def get_master_trades(self) -> List[Dict]:
        """Fetch recent executed trades from master account"""
        headers = {
            'X-MBX-APIKEY': self.master_config['api_key']
        }
        
        params = {
            'timestamp': int(datetime.now().timestamp() * 1000),
            'recvWindow': 5000
        }
        
        try:
            response = requests.get(
                f"{self.base_url}/myTrades",
                headers=headers,
                params=params
            )
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            self.logger.error(f"🔴 Failed to fetch master trades: {e}")
            return []

# More code follows...
                        

### File: core/trade_executor.py
#!/usr/bin/env python3
"""Execute trades on follower accounts with idempotency guarantees"""

import logging
import hashlib
from typing import List, Dict, Optional
from decimal import Decimal

import requests
from sqlalchemy.orm import Session

from database.models import get_session, Follower, ExecutionLog
from security.encryption import decrypt_api_key

class TradeExecutor:
    """Handles trade execution on all active follower accounts"""
    
    def __init__(self):
        self.logger = logging.getLogger(__name__)
        self.base_url = "https://api.binance.com/api/v3"
        
    def execute_trade_on_followers(self, master_trade: Dict):
        """Replicate a single master trade to all active followers"""
        session = get_session()
        
        # Get all active followers
        followers = session.query(Follower).filter(
            Follower.status == 'ACTIVE'
        ).all()
        
        if not followers:
            self.logger.info("📭 No active followers found for trade execution")
            return
        
        # Execute trade on each follower (idempotently)
        for follower in followers:
            self.execute_trade_for_follower(session, follower, master_trade)
        
        session.commit()

# More code follows...
                        

### File: database/models.py
#!/usr/bin/env python3
"""SQLAlchemy models for tracking system state and follower accounts"""

from datetime import datetime
from enum import Enum

from sqlalchemy import (
    create_engine, Column, Integer, String, 
    DateTime, Boolean, Text, Float, JSON,
    Enum as SQLAlchemyEnum, ForeignKey,
    event
)
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session, relationship

# Database URL (SQLite for simplicity, production would use PostgreSQL)
DATABASE_URL = "sqlite:///./spot_sync.db"

engine = create_engine(
    DATABASE_URL, 
    connect_args={"check_same_thread": False},
    echo=False  # Set to True for debugging SQL
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

class FollowerStatus(str, Enum):
    """Valid states for a follower account"""
    ACTIVE = "ACTIVE"
    PAUSED = "PAUSED"
    DISABLED = "DISABLED"

class Follower(Base):
    """Tracks a follower Binance account"""
    __tablename__ = "followers"
    
    # Core fields
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(100), nullable=False)
    api_key_encrypted = Column(Text, nullable=False)
    api_secret_encrypted = Column(Text, nullable=False)
    
    # Follower configuration
    allocation_rule = Column(JSON, nullable=False)  # e.g., {"type": "percentage", "value": 50}
    status = Column(SQLAlchemyEnum(FollowerStatus), nullable=False, default=FollowerStatus.ACTIVE)
    
    # Safety controls
    max_consecutive_errors = Column(Integer, default=5)
    current_consecutive_errors = Column(Integer, default=0)
    auto_pause_on_errors = Column(Boolean, default=True)
    
    # More fields follow...
                        

### File: security/encryption.py
#!/usr/bin/env python3
"""Cryptographic functions for API key protection"""

import base64
import logging
import os
from typing import Optional

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

class KeyVault:
    """Manages encryption/decryption of sensitive API credentials"""
    
    def __init__(self, master_password: str, salt: Optional[bytes] = None):
        self.master_password = master_password.encode()
        self.salt = salt or os.urandom(16)
        self.logger = logging.getLogger(__name__)
        
        # Derive a Fernet key from master password
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=self.salt,
            iterations=100000,
        )
        key = base64.urlsafe_b64encode(kdf.derive(self.master_password))
        self.cipher = Fernet(key)
    
    def encrypt(self, plaintext: str) -> str:
        """Encrypt a string and return base64 encoded ciphertext"""
        try:
            encrypted_bytes = self.cipher.encrypt(plaintext.encode())
            return base64.urlsafe_b64encode(encrypted_bytes).decode()
        except Exception as e:
            self.logger.error(f"🔴 Encryption failed: {e}")
            raise
    
    def decrypt(self, ciphertext_b64: str) -> str:
        """Decrypt a base64 encoded ciphertext and return the plaintext string"""
        try:
            encrypted_bytes = base64.urlsafe_b64decode(ciphertext_b64.encode())
            decrypted_bytes = self.cipher.decrypt(encrypted_bytes)
            return decrypted_bytes.decode()
        except Exception as e:
            self.logger.error(f"🔴 Decryption failed: {e}")
            raise

# More functions follow...