please add the most debuggging tracing logging u can to this import asyncio
import websockets
import json
import logging
import base64
import time
import torch
import torch.amp as amp
from concurrent.futures import ThreadPoolExecutor
from solana_rust_bot import TradingCore
from price_impact import PriceImpactCalculator
from vector_store import VectorStore

logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s')
logger = logging.getLogger(__name__)

RAYDIUM_ACCOUNTS = {
    'TOKEN_PROGRAM': 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
    'SYSTEM_PROGRAM': '11111111111111111111111111111111',
    'CLOCK': 'SysvarC1ock11111111111111111111111111111111'
}

SOL_WSOL_POOLS = [
    "EGZ7tiLeH62TPV1gL8WwbXGzEPa9zmcpVnnkPKKnrE2U",  # Main SOL-WSOL pool
    "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",  # Secondary SOL-WSOL pool
]

class RaydiumHFTMonitor:
    def __init__(self, config: dict, trading_core: TradingCore):
        self.WS_URL = "wss://marga-e56m84-fast-mainnet.helius-rpc.com/"
        
        # CUDA setup
        self.device = torch.device('cuda')
        torch.backends.cuda.matmul.allow_tf32 = True
        torch.backends.cudnn.benchmark = True
        
        self.config = config
        self.impact_calculator = PriceImpactCalculator(config)
        self.vector_store = VectorStore(config)
        
        self.thread_pool = ThreadPoolExecutor(max_workers=32)
        self.core = trading_core
        self.RAYDIUM_V4 = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
        
        self.trading_config = config["trading"]
        self.processed_txs = 0
        self.valid_signals = 0
        self.last_trade_time = 0
        
        logger.info(f"🚀 HFT Monitor initialized with WebSocket endpoint: {self.WS_URL}")

    async def start(self):
        """Start monitoring"""
        logger.info("Starting Raydium V4 monitor...")
        
        monitoring_task = asyncio.create_task(self.monitor_transactions())
        stats_task = asyncio.create_task(self.heartbeat())
        
        await asyncio.gather(monitoring_task, stats_task)

    async def monitor_transactions(self):
        """Monitor Raydium transactions"""
        while True:
            try:
                async with websockets.connect(
                    self.WS_URL,
                    ping_interval=115,
                    ping_timeout=60,
                    close_timeout=60,
                    max_size=2**24
                ) as ws:
                    # Subscribe to Raydium program
                    subscribe_msg = {
                        "jsonrpc": "2.0",
                        "id": "trade-sub",
                        "method": "logsSubscribe",
                        "params": [
                            {
                                "mentions": [self.RAYDIUM_V4]
                            },
                            {
                                "commitment": "processed"
                            }
                        ]
                    }
                    
                    await ws.send(json.dumps(subscribe_msg))
                    response = await ws.recv()
                    response_data = json.loads(response)
                    
                    if "error" in response_data:
                        logger.error(f"Subscription error: {response_data['error']}")
                        await asyncio.sleep(1)
                        continue
                    
                    logger.info("✨ Successfully subscribed to Raydium mempool")
                    
                    async for msg in ws:
                        try:
                            data = json.loads(msg)
                            if data.get("method") == "logsNotification":
                                result = data.get("params", {}).get("result", {})
                                if result:
                                    await self.process_transaction(result)
                        except json.JSONDecodeError:
                            continue
                        
            except websockets.exceptions.ConnectionClosed:
                logger.warning("WebSocket disconnected - reconnecting...")
                await asyncio.sleep(1)
            except Exception as e:
                logger.error(f"WebSocket error: {e}")
                await asyncio.sleep(1)

    async def process_transaction(self, tx_data: dict):
        """Process transaction data"""
        try:
            logs = tx_data.get('value', {}).get('logs', [])
            
            # Debug: Print first transaction that contains 'Swap'
            if any("Instruction: Swap" in log for log in logs):
                logger.debug(f"Found swap instruction. Full logs: {json.dumps(logs, indent=2)}")
            
            for log in logs:
                if "Program log: Instruction: Swap" in log:
                    # Extract pool address
                    pool_address = None
                    for log_line in logs:
                        if "Program data:" in log_line:
                            try:
                                data = log_line.split("Program data: ")[1]
                                decoded = base64.b64decode(data)
                                # Log the decoded data for debugging
                                logger.debug(f"Decoded data: {decoded.hex()[:100]}")
                            except Exception as e:
                                logger.error(f"Decoding error: {e}")
                        # Look for account addresses directly in logs
                        elif any(pool in log_line for pool in SOL_WSOL_POOLS):
                            pool_address = next((pool for pool in SOL_WSOL_POOLS if pool in log_line), None)
                            logger.info(f"Found target pool: {pool_address}")
                    
                    if pool_address in SOL_WSOL_POOLS:
                        logger.info(f"Found valid Raydium swap in pool: {pool_address}")
                        
                        # Execute trade with optimal params
                        await self.execute_trade({
                            'pool_address': pool_address,
                            'priority_fee': tx_data.get('value', {}).get('priorityFeeEstimate',
                                                                    self.trading_config["priority_fee"])
                        })
                        
            self.processed_txs += 1

        except Exception as e:
            logger.error(f"Error processing transaction: {e}")

    def _extract_pool_address(self, logs: list) -> str:
        """Extract pool address from transaction logs"""
        try:
            for log in logs:
                if f"Program {self.RAYDIUM_V4} invoke" in log:
                    pool_idx = logs.index(log)
                    for next_log in logs[pool_idx:pool_idx + 5]:
                        parts = next_log.split()
                        for part in parts:
                            if len(part) >= 44 and part.startswith(tuple("123456789")):
                                return part
            return None
        except Exception as e:
            logger.error(f"Pool address extraction failed: {e}")
            return None

    async def execute_trade(self, trade_data: dict):
        """Execute trade with optimized parameters"""
        try:
            current_time = time.time()
            if current_time - self.last_trade_time < 1/self.trading_config["trades_per_second"]:
                return
                
            # Set position size
            position_size = int(self.trading_config["position_size"] * 1e9)
            
            # Set priority fee higher than source tx
            priority_fee = int(trade_data.get('priority_fee', self.trading_config["priority_fee"]) * 1.2)
            
            trade_params = {
                "pool_address": trade_data["pool_address"],
                "amount_in": position_size,
                "min_amount_out": int(position_size * 0.995),  # 0.5% slippage
                "priority_fee": priority_fee
            }
            
            signature = self.core.execute_trade(trade_params)
            if signature:
                self.last_trade_time = current_time
                self.valid_signals += 1
                logger.info(f"""✨ Executed trade:
                    Signature: {signature}
                    Size: {position_size/1e9:.4f} SOL
                    Priority Fee: {priority_fee}""")
                
        except Exception as e:
            logger.error(f"Error executing trade: {e}")

    async def heartbeat(self):
        """Monitor heartbeat"""
        while True:
            logger.info(f"""
            💫 LIVE MONITORING STATUS
            ------------------------
            Time: {time.strftime('%H:%M:%S')}
            Processed TXs: {self.processed_txs}
            Valid Signals: {self.valid_signals}
            Signal Rate: {(self.valid_signals/max(1, self.processed_txs))*100:.2f}%
            ------------------------
            """)
            await asyncio.sleep(5)

    async def cleanup(self):
        """Cleanup resources"""
        self.thread_pool.shutdown()
        torch.cuda.synchronize()
        torch.cuda.empty_cache()
        logger.info("Resources cleaned up")