django-cfg 1.2.27__py3-none-any.whl → 1.2.31__py3-none-any.whl

django_cfg/apps/payments/services/providers/cryptapi.py

@@ -1,273 +0,0 @@
-"""
-CryptAPI provider implementation.
-
-Crypto payment provider using CryptAPI service.
-"""
-
-import logging
-import requests
-import secrets
-import string
-from typing import Optional, List
-from decimal import Decimal
-from pydantic import BaseModel, Field
-
-from .base import PaymentProvider
-from ..internal_types import ProviderResponse, WebhookData
-
-logger = logging.getLogger(__name__)
-
-
-class CryptAPIConfig(BaseModel):
-    """CryptAPI provider configuration."""
-    own_address: str = Field(..., description="Your cryptocurrency address")
-    callback_url: str = Field(..., description="Webhook callback URL")
-    convert_payments: bool = Field(default=True, description="Auto-convert payments")
-    multi_token: bool = Field(default=True, description="Support multi-token payments")
-    priority: str = Field(default='default', description="Transaction priority")
-    enabled: bool = Field(default=True, description="Provider enabled")
-
-
-class CryptAPIException(Exception):
-    """CryptAPI specific exception."""
-    pass
-
-
-class CryptAPIProvider(PaymentProvider):
-    """CryptAPI cryptocurrency payment provider."""
-    
-    CRYPTAPI_URL = 'https://api.cryptapi.io/'
-    
-    def __init__(self, config: CryptAPIConfig):
-        """Initialize CryptAPI provider."""
-        super().__init__(config.dict())
-        self.config = config
-        self.own_address = config.own_address
-        self.callback_url = config.callback_url
-        self.convert_payments = config.convert_payments
-        self.multi_token = config.multi_token
-        self.priority = config.priority
-    
-    def _make_request(self, coin: str, endpoint: str, params: Optional[dict] = None) -> Optional[dict]:
-        """Make HTTP request to CryptAPI."""
-        try:
-            if coin:
-                coin = coin.replace('/', '_')
-                url = f"{self.CRYPTAPI_URL}{coin}/{endpoint}/"
-            else:
-                url = f"{self.CRYPTAPI_URL}{endpoint}/"
-            
-            response = requests.get(url, params=params or {}, timeout=30)
-            response.raise_for_status()
-            
-            result = response.json()
-            
-            # Check for API errors
-            if 'error' in result:
-                logger.error(f"CryptAPI error: {result['error']}")
-                return None
-            
-            return result
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"CryptAPI request failed: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Unexpected CryptAPI error: {e}")
-            return None
-    
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """Create payment address via CryptAPI."""
-        try:
-            amount = Decimal(str(payment_data['amount']))
-            currency = payment_data['currency'].lower()
-            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}')
-            
-            # Generate secure nonce for replay attack protection
-            security_nonce = self._generate_nonce()
-            
-            # Build callback URL with parameters including nonce
-            callback_params = {
-                'order_id': order_id,
-                'amount': str(amount),
-                'nonce': security_nonce
-            }
-            
-            # Create payment address
-            params = {
-                'address': self.own_address,
-                'callback': self.callback_url,
-                'convert': 1 if self.convert_payments else 0,
-                'multi_token': 1 if self.multi_token else 0,
-                'priority': self.priority,
-                **callback_params
-            }
-            
-            response = self._make_request(currency, 'create', params)
-            
-            if response and 'address_in' in response:
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response['address_in'],  # Use address as payment ID
-                    payment_url=None,  # CryptAPI doesn't provide payment URLs
-                    pay_address=response['address_in'],
-                    amount=amount,
-                    currency=currency.upper(),
-                    status='pending'
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Failed to create payment address'
-                )
-                
-        except Exception as e:
-            logger.error(f"CryptAPI create_payment error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Check payment status via CryptAPI."""
-        try:
-            # For CryptAPI, payment_id is the address
-            # We need to check logs to see if payment was received
-            # This is a limitation of CryptAPI - no direct status check by address
-            
-            # Return pending status as CryptAPI uses callbacks for status updates
-            return ProviderResponse(
-                success=True,
-                provider_payment_id=payment_id,
-                status='pending',
-                pay_address=payment_id,
-                amount=Decimal('0'),  # Unknown without logs
-                currency='unknown'
-            )
-            
-        except Exception as e:
-            logger.error(f"CryptAPI check_payment_status error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def process_webhook(self, payload: dict) -> WebhookData:
-        """Process CryptAPI webhook/callback."""
-        try:
-            # CryptAPI sends callbacks with these parameters:
-            # - address_in: payment address
-            # - address_out: your address  
-            # - txid_in: transaction ID
-            # - txid_out: forwarding transaction ID (if applicable)
-            # - confirmations: number of confirmations
-            # - value: amount received
-            # - value_coin: amount in coin
-            # - value_forwarded: amount forwarded
-            # - coin: cryptocurrency
-            # - pending: 0 or 1
-            
-            confirmations = int(payload.get('confirmations', 0))
-            pending = int(payload.get('pending', 1))
-            
-            # Determine status based on confirmations and pending flag
-            if pending == 1:
-                status = 'pending'
-            elif confirmations >= 1:
-                status = 'completed'
-            else:
-                status = 'processing'
-            
-            return WebhookData(
-                provider_payment_id=payload.get('address_in', ''),
-                status=status,
-                pay_amount=Decimal(str(payload.get('value_coin', 0))),
-                actually_paid=Decimal(str(payload.get('value_coin', 0))),
-                order_id=payload.get('order_id'),  # Custom parameter we sent
-                signature=payload.get('txid_in')  # Use transaction ID as signature
-            )
-            
-        except Exception as e:
-            logger.error(f"CryptAPI webhook processing error: {e}")
-            raise
-    
-    def get_supported_currencies(self) -> List[str]:
-        """Get list of supported currencies."""
-        try:
-            response = self._make_request('', 'info')
-            
-            if response and isinstance(response, dict):
-                # CryptAPI returns a dict with coin info
-                return list(response.keys())
-            else:
-                # Fallback currencies
-                return ['BTC', 'ETH', 'LTC', 'BCH', 'XMR', 'TRX']
-                
-        except Exception as e:
-            logger.error(f"Error getting supported currencies: {e}")
-            return ['BTC', 'ETH', 'LTC']  # Minimal fallback
-    
-    def get_minimum_payment_amount(self, currency_from: str, currency_to: str = 'usd') -> Optional[Decimal]:
-        """Get minimum payment amount for currency."""
-        try:
-            response = self._make_request(currency_from.lower(), 'info')
-            
-            if response and 'minimum_transaction' in response:
-                return Decimal(str(response['minimum_transaction']))
-            
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error getting minimum amount: {e}")
-            return None
-    
-    def estimate_payment_amount(self, amount: Decimal, currency_code: str) -> Optional[dict]:
-        """Estimate payment amount - CryptAPI doesn't provide this."""
-        # CryptAPI doesn't have a direct estimation API
-        # Would need to use external price APIs
-        return None
-    
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
-        """Validate CryptAPI webhook."""
-        try:
-            # CryptAPI doesn't use HMAC signatures
-            # Validation is done by checking if the callback came from their servers
-            # and contains expected parameters
-            
-            required_fields = ['address_in', 'address_out', 'txid_in', 'value_coin', 'coin', 'confirmations']
-            
-            for field in required_fields:
-                if field not in payload:
-                    logger.warning(f"Missing required field in CryptAPI webhook: {field}")
-                    return False
-            
-            # Basic validation passed
-            return True
-            
-        except Exception as e:
-            logger.error(f"CryptAPI webhook validation error: {e}")
-            return False
-    
-    def check_api_status(self) -> bool:
-        """Check if CryptAPI is available."""
-        try:
-            response = self._make_request('', 'info')
-            return response is not None
-        except:
-            return False
-    
-    def get_logs(self, callback_url: str) -> Optional[dict]:
-        """Get payment logs for a callback URL."""
-        try:
-            params = {'callback': callback_url}
-            # Note: This would need a specific coin, but we don't know which one
-            # This is a limitation of the current implementation
-            return None
-        except Exception as e:
-            logger.error(f"Error getting logs: {e}")
-            return None
-    
-    def _generate_nonce(self, length: int = 32) -> str:
-        """Generate cryptographically secure nonce for replay attack protection."""
-        sequence = string.ascii_letters + string.digits
-        return ''.join([secrets.choice(sequence) for _ in range(length)])

django_cfg/apps/payments/services/providers/cryptomus.py

@@ -1,310 +0,0 @@
-"""
-Cryptomus payment provider implementation.
-"""
-
-import logging
-import hashlib
-import json
-import base64
-from decimal import Decimal
-from typing import Dict, Any, Optional
-from dataclasses import dataclass
-
-import requests
-from pydantic import BaseModel, Field, validator
-
-from .base import PaymentProvider, ProviderResponse, ProviderConfig
-
-logger = logging.getLogger(__name__)
-
-
-class CryptomusConfig(ProviderConfig):
-    """Configuration for Cryptomus provider."""
-    
-    merchant_id: str = Field(..., description="Cryptomus merchant ID")
-    api_key: str = Field(..., description="Cryptomus API key")
-    test_mode: bool = Field(default=False, description="Enable test mode")
-    callback_url: Optional[str] = Field(None, description="Default callback URL")
-    
-    @validator('merchant_id')
-    def validate_merchant_id(cls, v):
-        if not v or not v.strip():
-            raise ValueError("Merchant ID is required")
-        return v.strip()
-    
-    @validator('api_key')
-    def validate_api_key(cls, v):
-        if not v or len(v) < 10:
-            raise ValueError("API key must be at least 10 characters")
-        return v
-
-
-class CryptomusProvider(PaymentProvider):
-    """Cryptomus payment provider with universal field mapping."""
-    
-    def __init__(self, config: CryptomusConfig):
-        super().__init__(config)
-        self.merchant_id = config.merchant_id
-        self.api_key = config.api_key
-        self.test_mode = config.test_mode
-        self.base_url = "https://api.cryptomus.com/v1" if not config.test_mode else "https://api.cryptomus.com/v1"
-        
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """
-        Create payment using Cryptomus API.
-        Maps to universal payment fields.
-        """
-        try:
-            # Extract required data
-            order_id = payment_data.get('order_id')
-            amount = payment_data.get('amount')
-            currency = payment_data.get('currency', 'USD')
-            callback_url = payment_data.get('callback_url', self.config.callback_url)
-            
-            if not all([order_id, amount]):
-                return ProviderResponse(
-                    success=False,
-                    error_message="Missing required fields: order_id, amount"
-                )
-            
-            # Prepare Cryptomus API request
-            payload = {
-                "amount": str(amount),
-                "currency": currency,
-                "order_id": order_id,
-                "url_callback": callback_url,
-                "url_return": payment_data.get('return_url'),
-                "url_success": payment_data.get('success_url'),
-                "is_payment_multiple": False,
-                "lifetime": 3600,  # 1 hour
-                "to_currency": payment_data.get('crypto_currency', 'BTC')
-            }
-            
-            # Generate signature
-            headers = self._generate_headers(payload)
-            
-            # Make API request
-            response = requests.post(
-                f"{self.base_url}/payment",
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                
-                if result.get('state') == 0:  # Success
-                    payment_info = result.get('result', {})
-                    
-                    return ProviderResponse(
-                        success=True,
-                        transaction_id=payment_info.get('uuid'),
-                        data={
-                            # Universal field mapping
-                            'provider_payment_id': payment_info.get('uuid'),
-                            'receiver_address': payment_info.get('address'),
-                            'crypto_amount': float(payment_info.get('amount', 0)),
-                            'provider_callback_url': callback_url,
-                            'payment_url': payment_info.get('url'),
-                            'qr_code': payment_info.get('static_qr'),
-                            
-                            # Cryptomus specific fields
-                            'cryptomus_order_id': payment_info.get('order_id'),
-                            'cryptomus_currency': payment_info.get('currency'),
-                            'cryptomus_network': payment_info.get('network'),
-                            'cryptomus_status': payment_info.get('status'),
-                            'expires_at': payment_info.get('expired_at')
-                        }
-                    )
-                else:
-                    error_msg = result.get('message', 'Unknown Cryptomus error')
-                    return ProviderResponse(
-                        success=False,
-                        error_message=f"Cryptomus API error: {error_msg}"
-                    )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message=f"HTTP {response.status_code}: {response.text}"
-                )
-                
-        except requests.RequestException as e:
-            logger.error(f"Cryptomus API request failed: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=f"Network error: {str(e)}"
-            )
-        except Exception as e:
-            logger.error(f"Cryptomus payment creation failed: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=f"Unexpected error: {str(e)}"
-            )
-    
-    def validate_webhook(self, webhook_data: Dict[str, Any], 
-                        request_headers: Dict[str, str], raw_body: bytes) -> tuple[bool, Optional[str]]:
-        """
-        Validate Cryptomus webhook signature and required fields.
-        """
-        try:
-            # Check required fields
-            required_fields = ['uuid', 'order_id', 'amount', 'currency', 'status']
-            for field in required_fields:
-                if field not in webhook_data:
-                    return False, f"Missing required field: {field}"
-            
-            # Validate signature if provided
-            sign = request_headers.get('sign') or webhook_data.get('sign')
-            if sign:
-                # Generate expected signature
-                expected_sign = self._generate_webhook_signature(webhook_data)
-                if sign != expected_sign:
-                    return False, "Invalid webhook signature"
-            
-            return True, None
-            
-        except Exception as e:
-            logger.error(f"Cryptomus webhook validation failed: {e}")
-            return False, f"Validation error: {str(e)}"
-    
-    def process_webhook(self, webhook_data: Dict[str, Any]) -> ProviderResponse:
-        """
-        Process Cryptomus webhook and map to universal fields.
-        """
-        try:
-            # Map Cryptomus webhook fields to universal fields
-            universal_data = {
-                'provider_payment_id': webhook_data.get('uuid'),
-                'status': self._map_status(webhook_data.get('status')),
-                'transaction_hash': webhook_data.get('txid'),
-                'sender_address': webhook_data.get('from'),
-                'receiver_address': webhook_data.get('to'), 
-                'crypto_amount': float(webhook_data.get('amount', 0)),
-                'confirmations_count': int(webhook_data.get('confirmations', 0)),
-                
-                # Additional Cryptomus data
-                'cryptomus_network': webhook_data.get('network'),
-                'cryptomus_currency': webhook_data.get('currency'),
-                'cryptomus_commission': webhook_data.get('commission'),
-                'updated_at': webhook_data.get('updated_at')
-            }
-            
-            return ProviderResponse(
-                success=True,
-                data=universal_data
-            )
-            
-        except Exception as e:
-            logger.error(f"Cryptomus webhook processing failed: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=f"Webhook processing error: {str(e)}"
-            )
-    
-    def get_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Get payment status from Cryptomus."""
-        try:
-            payload = {"uuid": payment_id}
-            headers = self._generate_headers(payload)
-            
-            response = requests.post(
-                f"{self.base_url}/payment/info",
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('state') == 0:
-                    payment_info = result.get('result', {})
-                    
-                    return ProviderResponse(
-                        success=True,
-                        data={
-                            'status': self._map_status(payment_info.get('status')),
-                            'provider_payment_id': payment_info.get('uuid'),
-                            'transaction_hash': payment_info.get('txid'),
-                            'crypto_amount': float(payment_info.get('amount', 0)),
-                            'confirmations_count': int(payment_info.get('confirmations', 0))
-                        }
-                    )
-            
-            return ProviderResponse(
-                success=False,
-                error_message="Failed to get payment status"
-            )
-            
-        except Exception as e:
-            logger.error(f"Cryptomus status check failed: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=f"Status check error: {str(e)}"
-            )
-    
-    def _generate_headers(self, payload: dict) -> dict:
-        """Generate required headers for Cryptomus API."""
-        data_string = base64.b64encode(json.dumps(payload).encode()).decode()
-        sign = hashlib.md5(f"{data_string}{self.api_key}".encode()).hexdigest()
-        
-        return {
-            "merchant": self.merchant_id,
-            "sign": sign,
-            "Content-Type": "application/json"
-        }
-    
-    def _generate_webhook_signature(self, webhook_data: dict) -> str:
-        """Generate expected webhook signature for validation."""
-        # Cryptomus webhook signature generation
-        data_string = base64.b64encode(json.dumps(webhook_data, sort_keys=True).encode()).decode()
-        return hashlib.md5(f"{data_string}{self.api_key}".encode()).hexdigest()
-    
-    def _map_status(self, cryptomus_status: str) -> str:
-        """Map Cryptomus status to universal status."""
-        status_mapping = {
-            'check': 'pending',
-            'process': 'pending', 
-            'confirm_check': 'pending',
-            'confirmed': 'completed',
-            'fail': 'failed',
-            'cancel': 'cancelled',
-            'system_fail': 'failed',
-            'refund_process': 'refunding',
-            'refund_fail': 'failed',
-            'refund_paid': 'refunded'
-        }
-        return status_mapping.get(cryptomus_status, 'pending')
-    
-    def get_supported_currencies(self) -> ProviderResponse:
-        """Get supported currencies from Cryptomus."""
-        try:
-            headers = self._generate_headers({})
-            
-            response = requests.post(
-                f"{self.base_url}/exchange-rate/list",
-                json={},
-                headers=headers,
-                timeout=30
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('state') == 0:
-                    currencies = result.get('result', [])
-                    return ProviderResponse(
-                        success=True,
-                        data={'currencies': currencies}
-                    )
-            
-            return ProviderResponse(
-                success=False,
-                error_message="Failed to get supported currencies"
-            )
-            
-        except Exception as e:
-            logger.error(f"Cryptomus currencies request failed: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=f"Currencies request error: {str(e)}"
-            )