django-cfg 1.2.22__py3-none-any.whl → 1.2.25__py3-none-any.whl

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

@@ -0,0 +1,273 @@
+"""
+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

@@ -0,0 +1,310 @@
+"""
+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)}"
+            )