can u do me a favor please add these async def _update_pool_state(self, pool: str) -> Dict:
    """Update pool state with latest on-chain data"""
    try:
        with torch.cuda.stream(self.streams['update']):
            # Get latest pool data from chain
            pool_data = await self._fetch_pool_data(pool)
            
            # Calculate key metrics
            base_reserve = float(pool_data['token_a_amount'])
            quote_reserve = float(pool_data['token_b_amount'])
            liquidity = min(base_reserve, quote_reserve)
            
            return {
                'base_reserve': base_reserve,
                'quote_reserve': quote_reserve,
                'liquidity': liquidity,
                'fee': float(pool_data['fee']),
                'last_update': pool_data['last_update_time']
            }
            
    except Exception as e:
        logger.error(f"Pool state update error: {e}")
        return {}

@torch.compile(mode="reduce-overhead")
def _compute_metrics(self, data: torch.Tensor) -> torch.Tensor:
    """Compute key trading metrics using GPU acceleration"""
    with torch.cuda.stream(self.streams['compute']):
        with torch.autocast(device_type='cuda', dtype=torch.float16):
            # Calculate volume metrics
            volume = torch.sum(data[:, 0])
            
            # Calculate price metrics
            prices = data[:, 1] / data[:, 0]
            price_mean = torch.mean(prices)
            price_std = torch.std(prices)
            
            # Calculate volatility
            returns = torch.diff(prices) / prices[:-1]
            volatility = torch.std(returns)
            
            return torch.stack([volume, price_mean, price_std, volatility])

def _select_best_opportunity(
    self,
    sandwich: Optional[OpportunityInfo],
    impact: Optional[OpportunityInfo]
) -> Optional[OpportunityInfo]:
    """Select best opportunity based on profit and risk"""
    try:
        opportunities = []
        if sandwich:
            opportunities.append(sandwich)
        if impact:
            opportunities.append(impact)
            
        if not opportunities:
            return None
            
        # Sort by profit/risk ratio
        return max(
            opportunities,
            key=lambda x: (x.profit_pct / max(x.impact, 0.0001)) * x.confidence
        )
        
    except Exception as e:
        logger.error(f"Opportunity selection error: {e}")
        return None    async def _fetch_pool_data(self, pool: str) -> Dict:
    """Fetch pool data from Solana chain"""
    try:
        with torch.cuda.stream(self.streams['parse']):
            # Implement your Solana RPC call here to fetch:
            # - Token reserves
            # - Pool fees
            # - Last update timestamp
            # This is a placeholder structure
            return {
                'token_a_amount': 1000.0,
                'token_b_amount': 1000.0,
                'fee': 0.003,
                'last_update_time': time.time()
            }
    except Exception as e:
        logger.error(f"Pool data fetch error: {e}")
        return {}

def _validate_pool_state(self, pool_state: Dict) -> bool:
    """Validate pool state data"""
    required_fields = [
        'base_reserve', 
        'quote_reserve',
        'liquidity',
        'fee'
    ]
    
    return all(
        field in pool_state and pool_state[field] > 0 
        for field in required_fields
    )

async def get_metrics(self) -> Dict:
    """Get current parser metrics"""
    return {
        'processed': self.metrics.processed_count,
        'successful': self.metrics.success_count,
        'errors': self.metrics.error_count,
        'avg_time': self.metrics.avg_process_time,
        'sandwich_ops': self.metrics.sandwich_opportunities,
        'impact_ops': self.metrics.impact_opportunities,
        'profitable': self.metrics.profitable_ops,
        'missed': self.metrics.missed_ops,
        'peak_memory': self.metrics.peak_memory,
        'latency': np.mean(self.metrics.latency_stats) if self.metrics.latency_stats else 0
    }
 all of these are missing? to my script please my eyes are going back so please include all of the script all imports and all lines of code please no placeholders just how i got it full done import asyncio
import torch
import logging
from typing import Optional, Dict, List, Tuple, Set
from dataclasses import dataclass, field
import base64
import json
import time
import numpy as np
from collections import deque

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s.%(msecs)03d [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S',
    handlers=[logging.StreamHandler()]  
)
logger = logging.getLogger(__name__)

@dataclass
class ParserMetrics:
    processed_count: int = 0
    success_count: int = 0
    error_count: int = 0
    avg_process_time: float = 0.0
    sandwich_opportunities: int = 0
    impact_opportunities: int = 0
    last_gc_time: float = 0.0
    peak_memory: float = 0.0
    profitable_ops: int = 0
    missed_ops: int = 0
    latency_stats: List[float] = field(default_factory=list)

@dataclass
class OpportunityInfo:
    raw_data: bytes
    pool_address: str
    amount_in: float
    amount_out: float
    profit_pct: float
    impact: float
    confidence: float
    timestamp: float
    type: str  # 'sandwich' or 'impact'
    priority: int
    pool_state: Dict = field(default_factory=dict)
    metadata: Dict = field(default_factory=dict)

class EnhancedParser:
    def __init__(self, config: Dict):
        """Initialize parser with advanced optimizations"""
        self.config = config
        self.metrics = ParserMetrics()
        
        # Initialize GPU with optimal settings
        self.device = torch.device('cuda')
        torch.backends.cuda.matmul.allow_tf32 = True
        torch.backends.cudnn.benchmark = True
        torch.cuda.set_per_process_memory_fraction(
            self.config['gpu']['memory_fraction']
        )
        
        # Initialize CUDA streams with priorities
        self.streams = {
            'parse': torch.cuda.Stream(priority=-2),    # Highest priority
            'compute': torch.cuda.Stream(priority=-1),  # High priority
            'analyze': torch.cuda.Stream(priority=0),   # Normal priority
            'update': torch.cuda.Stream(priority=1)     # Background priority
        }
        
        # Setup processing buffers with pinned memory
        self._setup_buffers()
        
        # Initialize pattern detection
        self.pattern_cache = deque(maxlen=1000)
        self.recent_transactions = deque(maxlen=5000)
        self.pool_states: Dict[str, Dict] = {}
        
        # Initialize opportunity tracking
        self.active_opportunities: Set[str] = set()
        self.opportunity_history = deque(maxlen=10000)
        
        # Configure thresholds
        self._load_thresholds()
        
        # Warm up GPU kernels
        self._warmup()
        
        logger.info(f"Enhanced parser initialized with optimal settings")

    def _setup_buffers(self):
        """Initialize optimized GPU buffers with pinned memory"""
        try:
            batch_size = self.config['gpu']['batch_size']
            with torch.cuda.stream(self.streams['compute']):
                # Main processing buffer
                self.process_buffer = torch.zeros(
                    (batch_size, 128),
                    device=self.device,
                    dtype=torch.float16,
                    pin_memory=True
                ).contiguous()
                
                # Pattern matching buffer
                self.pattern_buffer = torch.zeros(
                    (1024, 64),
                    device=self.device,
                    dtype=torch.float16,
                    pin_memory=True
                ).contiguous()
                
                # Pool state buffer
                self.state_buffer = torch.zeros(
                    (256, 32),
                    device=self.device,
                    dtype=torch.float32,
                    pin_memory=True
                ).contiguous()
                
                torch.cuda.synchronize()
                logger.debug("GPU buffers initialized with pinned memory")
                
        except Exception as e:
            logger.error(f"Buffer initialization error: {e}")
            raise

    def _load_thresholds(self):
        """Load and validate configuration thresholds"""
        try:
            self.SANDWICH_CONFIG = self.config['trading']['sandwich']
            self.IMPACT_CONFIG = self.config['trading']['impact']
            
            # Critical thresholds
            self.MIN_PROFIT = self.config['trading']['limits']['min_profit_pct']
            self.MAX_PROFIT = self.config['trading']['limits']['max_profit_pct']
            self.MAX_IMPACT = self.config['trading']['limits']['max_price_impact']
            self.MIN_POOL_LIQUIDITY = self.config['trading']['limits'].get('min_liquidity', 100)
            
            # Pattern detection settings
            self.PATTERN_CONFIDENCE = 0.85
            self.PATTERN_HISTORY = 50
            self.MAX_LATENCY = 0.005  # 5ms maximum processing latency
            
            logger.info("Thresholds loaded successfully")
            
        except Exception as e:
            logger.error(f"Threshold loading error: {e}")
            raise

    @torch.compile(mode="reduce-overhead")
    def _warmup(self):
        """Warm up GPU kernels with compiled operations"""
        try:
            with torch.cuda.stream(self.streams['compute']):
                # Warm up main processing kernels
                dummy_data = torch.randn(
                    (self.config['gpu']['batch_size'], 64),
                    device=self.device,
                    dtype=torch.float16
                )
                
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    for _ in range(10):
                        _ = torch.matmul(dummy_data, dummy_data.T)
                        _ = self._compute_metrics(dummy_data)
                
                torch.cuda.synchronize()
                logger.debug("GPU kernels warmed up")
                
        except Exception as e:
            logger.error(f"Warmup error: {e}")
            raise

    async def parse_transaction(self, raw_data: bytes) -> Optional[OpportunityInfo]:
        """Parse transaction data with GPU acceleration"""
        start_time = time.perf_counter()
        try:
            # Convert to tensor and move to GPU
            with torch.cuda.stream(self.streams['parse']):
                data_tensor = await self._prepare_data(raw_data)
                if data_tensor is None:
                    return None
                
                # Process in parallel streams
                sandwich_future = self._check_sandwich_opportunity(
                    data_tensor.clone(), raw_data
                )
                impact_future = self._check_impact_opportunity(
                    data_tensor.clone(), raw_data
                )
                
                # Wait for results
                sandwich_result, impact_result = await asyncio.gather(
                    sandwich_future, impact_future
                )
                
                # Select best opportunity
                opportunity = self._select_best_opportunity(
                    sandwich_result,
                    impact_result
                )
                
                if opportunity:
                    self.metrics.success_count += 1
                    latency = time.perf_counter() - start_time
                    self.metrics.latency_stats.append(latency)
                    
                    if latency <= self.MAX_LATENCY:
                        self.metrics.profitable_ops += 1
                    else:
                        self.metrics.missed_ops += 1
                    
                    # Update pattern cache
                    self._update_patterns(opportunity)
                
                return opportunity
                
        except Exception as e:
            self.metrics.error_count += 1
            logger.error(f"Transaction parsing error: {e}")
            return None
        finally:
            self.metrics.processed_count += 1
            process_time = time.perf_counter() - start_time
            self._update_metrics(process_time)

    async def _prepare_data(self, raw_data: bytes) -> Optional[torch.Tensor]:
        """Prepare transaction data for GPU processing"""
        try:
            with torch.cuda.stream(self.streams['parse']):
                # Extract transaction data
                if len(raw_data) < 96:  # Validate minimum length
                    return None
                    
                amount_in = int.from_bytes(raw_data[0:8], 'little') / 1_000_000_000
                amount_out = int.from_bytes(raw_data[8:16], 'little') / 1_000_000_000
                pool = raw_data[64:96]
                
                # Create tensor with optimal layout
                data = np.array(
                    [amount_in, amount_out, *pool],
                    dtype=np.float32
                )
                
                return torch.from_numpy(data).to(
                    self.device,
                    non_blocking=True
                )
                
        except Exception as e:
            logger.error(f"Data preparation error: {e}")
            return None

    @torch.compile(mode="reduce-overhead")
    async def _check_sandwich_opportunity(
        self,
        tx_tensor: torch.Tensor,
        raw_data: bytes
    ) -> Optional[OpportunityInfo]:
        """Check for sandwich opportunities with compiled kernels"""
        try:
            with torch.cuda.stream(self.streams['analyze']):
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    # Extract data
                    amount_in = float(tx_tensor[0])
                    amount_out = float(tx_tensor[1])
                    pool = tx_tensor[2:34].cpu().numpy().tobytes().hex()
                    
                    # Skip if amount outside limits
                    if (amount_in < self.SANDWICH_CONFIG['min_victim_size'] or
                        amount_in > self.SANDWICH_CONFIG['max_victim_size']):
                        return None
                    
                    # Calculate optimal positions
                    front_run = amount_in * self.SANDWICH_CONFIG['front_run_multiplier']
                    back_run = front_run * self.SANDWICH_CONFIG['back_run_multiplier']
                    
                    # Calculate impact
                    impact = await self._calculate_price_impact(
                        amount_in,
                        amount_out,
                        pool
                    )
                    
                    if impact > self.SANDWICH_CONFIG['max_impact']:
                        return None
                    
                    # Calculate profit
                    profit = await self._calculate_sandwich_profit(
                        front_run,
                        back_run,
                        impact,
                        pool
                    )
                    
                    if profit < self.SANDWICH_CONFIG['min_profit']:
                        return None
                    
                    # Get pool state
                    pool_state = await self._get_pool_state(pool)
                    
                    return OpportunityInfo(
                        raw_data=raw_data,
                        pool_address=pool,
                        amount_in=front_run,
                        amount_out=back_run,
                        profit_pct=profit,
                        impact=impact,
                        confidence=self.PATTERN_CONFIDENCE,
                        timestamp=time.time(),
                        type='sandwich',
                        priority=1,
                        pool_state=pool_state,
                        metadata={
                            'victim_size': amount_in,
                            'front_run_size': front_run,
                            'back_run_size': back_run,
                            'estimated_profit': profit
                        }
                    )
                    
        except Exception as e:
            logger.error(f"Sandwich check error: {e}")
            return None

    @torch.compile(mode="reduce-overhead")
    async def _check_impact_opportunity(
        self,
        tx_tensor: torch.Tensor,
        raw_data: bytes
    ) -> Optional[OpportunityInfo]:
        """Check for price impact opportunities with compiled kernels"""
        try:
            with torch.cuda.stream(self.streams['analyze']):
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    # Extract data
                    amount_in = float(tx_tensor[0])
                    amount_out = float(tx_tensor[1])
                    pool = tx_tensor[2:34].cpu().numpy().tobytes().hex()
                    
                    # Calculate impact
                    impact = await self._calculate_price_impact(
                        amount_in,
                        amount_out,
                        pool
                    )
                    
                    if impact < self.IMPACT_CONFIG['min_threshold']:
                        return None
                    
                    # Calculate optimal trade size
                    trade_size = amount_in * self.IMPACT_CONFIG['size_multiplier']
                    
                    if trade_size < self.IMPACT_CONFIG['min_size']:
                        return None
                    
                    # Calculate profit
                    profit = await self._calculate_impact_profit(
                        trade_size,
                        impact,
                        pool
                    )
                    
                    if profit < self.MIN_PROFIT:
                        return None
                    
                    # Get pool state
                    pool_state = await self._get_pool_state(pool)
                    
                    # Validate liquidity
                    if pool_state['liquidity'] < self.MIN_POOL_LIQUIDITY:
                        return None
                    
                    return OpportunityInfo(
                        raw_data=raw_data,
                        pool_address=pool,
                        amount_in=trade_size,
                        amount_out=0.0,  # Will be calculated during execution
                        profit_pct=profit,
                        impact=impact,
                        confidence=0.9,
                        timestamp=time.time(),
                        type='impact',
                        priority=2,
                        pool_state=pool_state,
                        metadata={
                            'reference_size': amount_in,
                            'trade_size': trade_size,
                            'estimated_profit': profit
                        }
                    )
                    
        except Exception as e:
            logger.error(f"Impact check error: {e}")
            return None

    @torch.compile(mode="reduce-overhead")
    async def _calculate_price_impact(
        self,
        amount_in: float,
        amount_out: float,
        pool: str
    ) -> float:
        """Calculate price impact with GPU acceleration"""
        try:
            with torch.cuda.stream(self.streams['compute']):
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    # Get pool state
                    pool_state = await self._get_pool_state(pool)
                    
                    # Convert to tensors
                    amount_in_tensor = torch.tensor(amount_in, device=self.device)
                    amount_out_tensor = torch.tensor(amount_out, device=self.device)
                    reserves = torch.tensor(
                        [pool_state['base_reserve'], pool_state['quote_reserve']],
                        device=self.device
                    )
                    
                    # Calculate impact
                    k = reserves[0] * reserves[1]
                    new_reserve = reserves[0] + amount_in_tensor
                    new_out = k / new_reserve
                    
                    # Calculate price change
                    old_price = amount_out_tensor / amount_in_tensor
                    new_price = new_out / amount_in_tensor
                    
                    impact = torch.abs(new_price - old_price) / old_price
                    return float(impact)
                    
        except Exception as e:
            logger.error(f"Impact calculation error: {e}")
            return float('inf')

    async def _calculate_sandwich_profit(
        self,
        front_run: float,
        back_run: float,
        impact: float,
        pool: str
    ) -> float:
        """Calculate expected sandwich trade profit"""
        try:
            with torch.cuda.stream(self.streams['compute']):
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    # Get pool state
                    pool_state = await self._get_pool_state(pool)
                    
                    # Calculate expected output after front-run
                    k = pool_state['base_reserve'] * pool_state['quote_reserve']
                    new_reserve = pool_state['base_reserve'] + front_run
                    front_out = k / new_reserve
                    
                    # Calculate back-run profit
                    k_after = new_reserve * (pool_state['quote_reserve'] - front_out)
                    final_reserve = new_reserve + back_run
                    back_out = k_after / final_reserve
                    
                    # Calculate net profit
                    profit = back_out - front_run
                    profit_pct = (profit / front_run) * 100
                    
                    # Apply safety margin
                    return min(profit_pct * 0.95, self.MAX_PROFIT)
                    
        except Exception as e:
            logger.error(f"Profit calculation error: {e}")
            return 0.0

    async def _calculate_impact_profit(
        self,
        size: float,
        impact: float,
        pool: str
    ) -> float:
        """Calculate expected impact trade profit"""
        try:
            with torch.cuda.stream(self.streams['compute']):
                with torch.autocast(device_type='cuda', dtype=torch.float16):
                    # Get pool state
                    pool_state = await self._get_pool_state(pool)
                    
                    # Calculate optimal size based on impact
                    optimal_size = min(
                        size,
                        pool_state['base_reserve'] * self.IMPACT_CONFIG['size_multiplier']
                    )
                    
                    # Calculate expected profit
                    profit_pct = impact * 100 * (optimal_size / size)
                    
                    # Apply safety margin and limits
                    return min(profit_pct * 0.9, self.MAX_PROFIT)
                    
        except Exception as e:
            logger.error(f"Impact profit calculation error: {e}")
            return 0.0

    async def _get_pool_state(self, pool: str) -> Dict:
        """Get or update pool state"""
        try:
            current_time = time.time()
            
            # Check cache first
            if pool in self.pool_states:
                state = self.pool_states[pool]
                if current_time - state['timestamp'] < 1.0:  # 1 second cache
                    return state
            
            # Update pool state
            with torch.cuda.stream(self.streams['update']):
                state = await self._update_pool_state(pool)
                self.pool_states[pool] = {
                    **state,
                    'timestamp': current_time
                }
                return state
                
        except Exception as e:
            logger.error(f"Pool state error: {e}")
            return {
                'base_reserve': 0,
                'quote_reserve': 0,
                'liquidity': 0,
                'timestamp': current_time
            }

    def _update_patterns(self, opportunity: OpportunityInfo):
        """Update pattern detection cache"""
        try:
            self.pattern_cache.append({
                'type': opportunity.type,
                'pool': opportunity.pool_address,
                'amount': opportunity.amount_in,
                'profit': opportunity.profit_pct,
                'impact': opportunity.impact,
                'timestamp': opportunity.timestamp
            })
            
            # Remove old patterns
            while (self.pattern_cache and 
                   time.time() - self.pattern_cache[0]['timestamp'] > 3600):
                self.pattern_cache.popleft()
                
        except Exception as e:
            logger.error(f"Pattern update error: {e}")

    def _update_metrics(self, process_time: float):
        """Update parser metrics"""
        try:
            # Update average processing time
            self.metrics.avg_process_time = (
                self.metrics.avg_process_time * 0.95 + 
                process_time * 0.05
            )
            
            # Update GPU memory tracking
            if torch.cuda.is_available():
                current_memory = torch.cuda.memory_allocated() / 1024**2
                self.metrics.peak_memory = max(
                    self.metrics.peak_memory,
                    current_memory
                )
                
            # Cleanup if needed
            current_time = time.time()
            if current_time - self.metrics.last_gc_time > 300:  # 5 minutes
                self._cleanup_old_data()
                self.metrics.last_gc_time = current_time
                
        except Exception as e:
            logger.error(f"Metrics update error: {e}")

    def _cleanup_old_data(self):
        """Clean up old data and optimize memory usage"""
        try:
            current_time = time.time()
            
            # Clean up old pool states
            old_pools = [
                pool for pool, state in self.pool_states.items()
                if current_time - state['timestamp'] > 3600
            ]
            for pool in old_pools:
                del self.pool_states[pool]
            
            # Clean up GPU memory
            if torch.cuda.is_available():
                torch.cuda.empty_cache()
            
            logger.debug(f"Cleaned up {len(old_pools)} old pool states")
            
        except Exception as e:
            logger.error(f"Cleanup error: {e}")

    async def cleanup(self):
        """Cleanup resources properly"""
        try:
            # Clean GPU resources
            if torch.cuda.is_available():
                torch.cuda.synchronize()
                for stream in self.streams.values():
                    stream.synchronize()
                
                # Clear buffers
                self.process_buffer = None
                self.pattern_buffer = None
                self.state_buffer = None
                
                torch.cuda.empty_cache()
            
            # Clear data structures
            self.pool_states.clear()
            self.pattern_cache.clear()
            self.recent_transactions.clear()
            self.opportunity_history.clear()
            
            logger.info("Parser cleanup completed successfully")
            
        except Exception as e:
            logger.error(f"Cleanup error: {e}")
            raise