blockchain.py

"""Blockchain integration for deposits and withdrawals."""
import os
from web3 import Web3
from typing import Optional, Dict
import logging

logger = logging.getLogger(__name__)

class BlockchainManager:
    """Manages blockchain interactions."""
    
    def __init__(self):
        self.rpc_url = os.getenv("ETH_RPC_URL", "https://mainnet.infura.io/v3/your_key")
        self.private_key = os.getenv("PRIVATE_KEY")
        self.wallet_address = os.getenv("WALLET_ADDRESS")
        
        try:
            self.w3 = Web3(Web3.HTTPProvider(self.rpc_url))
            if not self.w3.is_connected():
                logger.warning("Not connected to Ethereum network")
        except Exception as e:
            logger.error(f"Error connecting to blockchain: {e}")
            self.w3 = None
    
    def generate_deposit_address(self, user_id: int) -> str:
        """Generate a unique deposit address for a user."""
        # In a real implementation, this would use a deterministic wallet
        # or a smart contract to generate unique addresses
        # For now, return a placeholder
        return f"0x{user_id:040x}"
    
    def check_transaction(self, tx_hash: str) -> Optional[Dict]:
        """Check transaction status."""
        if not self.w3:
            return None
        
        try:
            tx = self.w3.eth.get_transaction_receipt(tx_hash)
            return {
                "status": "completed" if tx.status == 1 else "failed",
                "block_number": tx.blockNumber,
                "gas_used": tx.gasUsed
            }
        except Exception as e:
            logger.error(f"Error checking transaction: {e}")
            return None
    
    def get_balance(self, address: str) -> float:
        """Get ETH balance of an address."""
        if not self.w3:
            return 0.0
        
        try:
            balance_wei = self.w3.eth.get_balance(Web3.to_checksum_address(address))
            balance_eth = Web3.from_wei(balance_wei, 'ether')
            return float(balance_eth)
        except Exception as e:
            logger.error(f"Error getting balance: {e}")
            return 0.0
    
    def send_transaction(self, to_address: str, amount_eth: float) -> Optional[str]:
        """Send ETH transaction."""
        if not self.w3 or not self.private_key:
            logger.warning("Blockchain not configured for sending transactions")
            return None
        
        try:
            account = self.w3.eth.account.from_key(self.private_key)
            to_address = Web3.to_checksum_address(to_address)
            
            # Get nonce
            nonce = self.w3.eth.get_transaction_count(account.address)
            
            # Build transaction
            tx = {
                'nonce': nonce,
                'to': to_address,
                'value': Web3.to_wei(amount_eth, 'ether'),
                'gas': 21000,
                'gasPrice': self.w3.eth.gas_price
            }
            
            # Sign transaction
            signed_tx = account.sign_transaction(tx)
            
            # Send transaction
            tx_hash = self.w3.eth.send_raw_transaction(signed_tx.rawTransaction)
            
            return tx_hash.hex()
        except Exception as e:
            logger.error(f"Error sending transaction: {e}")
            return None
    
    def check_deposits(self, address: str, min_amount: float = 0.001) -> list:
        """Check for new deposits to an address."""
        # In a real implementation, this would:
        # 1. Monitor the address for incoming transactions
        # 2. Filter transactions above min_amount
        # 3. Return list of deposit transactions
        # For now, return empty list
        return []

# Global instance
blockchain_manager = BlockchainManager()