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

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

@@ -0,0 +1,439 @@
+"""
+CryptAPI provider implementation.
+
+Crypto payment provider using CryptAPI service.
+"""
+
+import requests
+import secrets
+import string
+import base64
+from typing import Optional, List, Dict, Any
+from decimal import Decimal
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.backends import default_backend
+from ..base import PaymentProvider
+from ...internal_types import ProviderResponse, WebhookData, PaymentAmountEstimate
+from .models import CryptAPIConfig, CryptAPICallback
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger("cryptapi")
+
+
+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)
+        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 with full parameter support according to documentation."""
+        try:
+            # Required parameters
+            amount = Decimal(str(payment_data['amount']))
+            currency = payment_data['currency'].lower()
+            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}')
+            
+            # Build callback URL with custom parameters
+            callback_url = payment_data.get('callback_url', self.config.callback_url)
+            
+            # Add custom parameters to callback URL for tracking
+            callback_params = []
+            if order_id:
+                callback_params.append(f'order_id={order_id}')
+            if 'user_id' in payment_data:
+                callback_params.append(f'user_id={payment_data["user_id"]}')
+            
+            # Generate nonce for security
+            security_nonce = self._generate_nonce()
+            callback_params.append(f'nonce={security_nonce}')
+            
+            # Build full callback URL
+            if callback_params:
+                separator = '&' if '?' in callback_url else '?'
+                callback_url = f"{callback_url}{separator}{'&'.join(callback_params)}"
+            
+            # Prepare API parameters according to documentation
+            params = {
+                'address': payment_data.get('address', self.config.own_address),
+                'callback': callback_url,
+            }
+            
+            # Optional parameters from documentation
+            if payment_data.get('pending', False) or self.config.convert_payments:
+                params['pending'] = 1
+            
+            if 'confirmations' in payment_data:
+                params['confirmations'] = int(payment_data['confirmations'])
+            
+            if payment_data.get('post', False):
+                params['post'] = 1
+                
+            if payment_data.get('json', True):
+                params['json'] = 1
+                
+            if self.config.priority and self.config.priority != 'default':
+                params['priority'] = self.config.priority
+                
+            if self.config.multi_token:
+                params['multi_token'] = 1
+                
+            if self.config.convert_payments:
+                params['convert'] = 1
+            
+            # Handle multi-address splitting if provided
+            if 'addresses' in payment_data and isinstance(payment_data['addresses'], list):
+                # Format: percentage@address|percentage@address
+                address_parts = []
+                for addr_info in payment_data['addresses']:
+                    if isinstance(addr_info, dict) and 'address' in addr_info and 'percentage' in addr_info:
+                        address_parts.append(f"{addr_info['percentage']}@{addr_info['address']}")
+                if address_parts:
+                    params['address'] = '|'.join(address_parts)
+            
+            # Make API request using ticker/create endpoint
+            response = self._make_request(currency, 'create', params)
+            
+            if response and 'address_in' in response:
+                return ProviderResponse(
+                    success=True,
+                    provider_payment_id=response['address_in'],
+                    payment_url=None,  # CryptAPI doesn't provide hosted payment pages
+                    pay_address=response['address_in'],
+                    amount=amount,
+                    currency=currency.upper(),
+                    status='pending',
+                    data={
+                        'callback_url': response.get('callback_url'),
+                        'minimum_transaction_coin': response.get('minimum_transaction_coin'),
+                        'priority': response.get('priority'),
+                        'nonce': security_nonce
+                    }
+                )
+            else:
+                # Standardized error message format
+                if response and 'error' in response:
+                    error_msg = f"CryptAPI error: {response['error']}"
+                elif response:
+                    error_msg = "CryptAPI error: Invalid response format"
+                else:
+                    error_msg = "CryptAPI error: No response from API"
+                    
+                return ProviderResponse(
+                    success=False,
+                    error_message=error_msg
+                )
+                
+        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 according to official documentation."""
+        try:
+            # Parse and validate webhook using Pydantic model
+            webhook = CryptAPICallback(**payload)
+            
+            # Determine status based on pending flag
+            pending = webhook.pending if webhook.pending is not None else 0
+            if pending == 1:
+                status = 'pending'
+            elif pending == 0:
+                # Confirmed webhook - check confirmations if available
+                if webhook.confirmations is not None and webhook.confirmations >= 1:
+                    status = 'completed'
+                else:
+                    status = 'processing'
+            else:
+                status = 'unknown'
+            
+            # Use value_coin for confirmed webhooks, or estimate for pending
+            pay_amount = webhook.value_coin if webhook.value_coin is not None else Decimal('0')
+            
+            # Use UUID if available, otherwise fall back to address_in
+            payment_id = webhook.uuid if webhook.uuid else webhook.address_in
+            
+            return WebhookData(
+                provider_payment_id=payment_id,
+                status=status,
+                pay_amount=pay_amount,
+                pay_currency=webhook.coin.lower(),
+                actually_paid=pay_amount,
+                order_id=payload.get('order_id'),  # Custom parameter from callback URL
+                signature=webhook.txid_in  # Transaction hash as signature
+            )
+            
+        except Exception as e:
+            logger.error(f"CryptAPI webhook processing error: {e}")
+            raise
+    
+    def get_logs(self, callback_url: str) -> Optional[dict]:
+        """Get payment logs for a specific callback URL."""
+        try:
+            response = self._make_request('GET', 'logs', {
+                'callback': callback_url
+            })
+            
+            if response:
+                return {
+                    'success': True,
+                    'logs': response,
+                    'callback_url': callback_url
+                }
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"CryptAPI get_logs error: {e}")
+            return None
+    
+    def generate_qr_code(self, address: str, amount: Optional[Decimal] = None, 
+                        size: int = 512) -> Optional[dict]:
+        """Generate QR code for payment address."""
+        try:
+            params = {
+                'address': address,
+                'size': size
+            }
+            
+            if amount:
+                params['value'] = float(amount)
+            
+            response = self._make_request('GET', 'qrcode', params)
+            
+            if response and 'qr_code' in response:
+                return {
+                    'success': True,
+                    'qr_code_url': response['qr_code'],
+                    'address': address,
+                    'amount': amount,
+                    'size': size
+                }
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"CryptAPI generate_qr_code error: {e}")
+            return None
+
+    def get_supported_currencies(self) -> ProviderResponse:
+        """Get list of supported currencies."""
+        try:
+            response = self._make_request('', 'info')
+            
+            if response and isinstance(response, dict):
+                # CryptAPI returns a dict with coin info
+                currencies = list(response.keys())
+                return ProviderResponse(
+                    success=True,
+                    data={'currencies': [{'currency_code': c, 'name': c.upper()} for c in currencies]}
+                )
+            else:
+                return ProviderResponse(
+                    success=False,
+                    error_message="Invalid response from CryptAPI info endpoint"
+                )
+                
+        except Exception as e:
+            logger.error(f"Error getting supported currencies: {e}")
+            return ProviderResponse(
+                success=False,
+                error_message=f"Failed to get currencies from CryptAPI: {str(e)}"
+            )
+    
+    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, raw_body: Optional[bytes] = None) -> bool:
+        """Validate CryptAPI webhook with RSA SHA256 signature verification."""
+        try:
+            # Skip signature verification if disabled
+            if not self.config.verify_signatures:
+                logger.warning("CryptAPI signature verification is disabled - using basic validation only")
+                return self._basic_webhook_validation(payload)
+            
+            # Check for signature header
+            if not headers or 'x-ca-signature' not in headers:
+                logger.error("Missing x-ca-signature header in CryptAPI webhook")
+                return False
+            
+            signature_b64 = headers['x-ca-signature']
+            if not signature_b64:
+                logger.error("Empty x-ca-signature header")
+                return False
+            
+            # Verify the signature
+            if not self._verify_cryptapi_signature(payload, signature_b64, raw_body):
+                logger.error("CryptAPI webhook signature verification failed")
+                return False
+            
+            # Signature verified - do basic validation
+            return self._basic_webhook_validation(payload)
+            
+        except Exception as e:
+            logger.error(f"CryptAPI webhook validation error: {e}")
+            return False
+    
+    def _basic_webhook_validation(self, payload: dict) -> bool:
+        """Basic webhook payload validation."""
+        # Core required fields (UUID is optional for compatibility)
+        required_fields = ['address_in', 'address_out', 'txid_in', 'coin']
+        
+        for field in required_fields:
+            if field not in payload:
+                logger.warning(f"Missing required field in CryptAPI webhook: {field}")
+                return False
+        
+        # Validate coin format if present
+        if 'coin' in payload and not payload['coin']:
+            logger.warning("Empty coin field in CryptAPI webhook")
+            return False
+        
+        return True
+    
+    def _verify_cryptapi_signature(self, payload: dict, signature_b64: str, raw_body: Optional[bytes] = None) -> bool:
+        """Verify CryptAPI RSA SHA256 signature according to documentation."""
+        try:
+            # Load public key
+            public_key = serialization.load_pem_public_key(
+                self.config.public_key.encode('utf-8'),
+                backend=default_backend()
+            )
+            
+            # Decode signature
+            signature = base64.b64decode(signature_b64)
+            
+            # Determine what data to verify
+            if raw_body:
+                # For POST requests - verify raw body
+                data_to_verify = raw_body
+            else:
+                # For GET requests - construct URL from payload
+                # This is a fallback if raw_body is not provided
+                params = "&".join([f"{k}={v}" for k, v in payload.items()])
+                data_to_verify = params.encode('utf-8')
+            
+            # Verify signature using RSA SHA256
+            public_key.verify(
+                signature,
+                data_to_verify,
+                padding.PKCS1v15(),
+                hashes.SHA256()
+            )
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"CryptAPI signature verification 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/__init__.py

@@ -0,0 +1,4 @@
+from .provider import CryptomusProvider
+from .models import CryptomusConfig, CryptomusCurrency, CryptomusNetwork
+
+__all__ = ['CryptomusProvider', 'CryptomusConfig', 'CryptomusCurrency', 'CryptomusNetwork']

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

@@ -0,0 +1,176 @@
+from pydantic import BaseModel, Field, ConfigDict, field_validator
+from typing import Optional, List, Dict, Any
+from decimal import Decimal
+
+from ...internal_types import ProviderConfig
+
+
+class CryptomusConfig(ProviderConfig):
+    """Cryptomus provider configuration with Pydantic v2."""
+    
+    merchant_id: str = Field(..., description="Cryptomus merchant ID")
+    test_mode: bool = Field(default=False, description="Enable test mode")
+    callback_url: Optional[str] = Field(None, description="Default callback URL")
+    success_url: Optional[str] = Field(None, description="Success redirect URL")
+    cancel_url: Optional[str] = Field(None, description="Cancel redirect URL")
+    
+    @field_validator('merchant_id')
+    @classmethod
+    def validate_merchant_id(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Merchant ID is required")
+        return v.strip()
+
+
+class CryptomusCurrency(BaseModel):
+    """Cryptomus specific currency model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    currency_code: str = Field(..., description="Currency symbol (e.g., BTC, ETH)")
+    name: str = Field(..., description="Full currency name")
+    network: Optional[str] = Field(None, description="Network code")
+    network_name: Optional[str] = Field(None, description="Network display name")
+    min_amount: Optional[Decimal] = Field(None, description="Minimum transaction amount")
+    max_amount: Optional[Decimal] = Field(None, description="Maximum transaction amount")
+    commission_percent: Optional[Decimal] = Field(None, description="Commission percentage")
+    is_available: bool = Field(True, description="Currency availability")
+
+
+class CryptomusNetwork(BaseModel):
+    """Cryptomus specific network model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    code: str = Field(..., description="Network code")
+    name: str = Field(..., description="Network display name")
+    currency: str = Field(..., description="Currency this network belongs to")
+    min_amount: Optional[Decimal] = Field(None, description="Minimum amount for this network")
+    max_amount: Optional[Decimal] = Field(None, description="Maximum amount for this network")
+    commission_percent: Optional[Decimal] = Field(None, description="Commission percentage")
+    confirmations: int = Field(1, description="Required confirmations")
+
+
+class CryptomusPaymentRequest(BaseModel):
+    """Cryptomus payment creation request."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    amount: str = Field(..., description="Payment amount")
+    currency: str = Field(..., description="Payment currency")
+    order_id: str = Field(..., description="Unique order identifier")
+    url_callback: Optional[str] = Field(None, description="Callback URL")
+    url_return: Optional[str] = Field(None, description="Return URL")
+    url_success: Optional[str] = Field(None, description="Success URL")
+    is_payment_multiple: bool = Field(False, description="Allow multiple payments")
+    lifetime: int = Field(3600, description="Payment lifetime in seconds")
+    to_currency: Optional[str] = Field(None, description="Target cryptocurrency")
+
+
+class CryptomusPaymentResponse(BaseModel):
+    """Cryptomus payment creation response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    state: int = Field(..., description="Response state (0 = success)")
+    message: Optional[str] = Field(None, description="Response message")
+    result: Optional[Dict[str, Any]] = Field(None, description="Payment result data")
+
+
+class CryptomusPaymentInfo(BaseModel):
+    """Cryptomus payment information."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    uuid: str = Field(..., description="Payment UUID")
+    order_id: str = Field(..., description="Order ID")
+    amount: str = Field(..., description="Payment amount")
+    currency: str = Field(..., description="Payment currency")
+    address: Optional[str] = Field(None, description="Payment address")
+    url: Optional[str] = Field(None, description="Payment URL")
+    static_qr: Optional[str] = Field(None, description="QR code data")
+    network: Optional[str] = Field(None, description="Network")
+    status: str = Field(..., description="Payment status")
+    expired_at: Optional[str] = Field(None, description="Expiration timestamp")
+
+
+class CryptomusWebhook(BaseModel):
+    """Cryptomus webhook data according to official documentation."""
+    model_config = ConfigDict(validate_assignment=True, extra="allow")  # Allow extra fields
+    
+    # Required fields from documentation
+    type: str = Field(..., description="Webhook type (payment/payout)")
+    uuid: str = Field(..., description="Payment/payout UUID")
+    order_id: str = Field(..., description="Order ID from your system")
+    amount: str = Field(..., description="Amount")
+    payment_amount: Optional[str] = Field(None, description="Payment amount")
+    payment_amount_usd: Optional[str] = Field(None, description="Payment amount in USD")
+    merchant_amount: Optional[str] = Field(None, description="Merchant amount after fees")
+    commission: Optional[str] = Field(None, description="Commission amount")
+    is_final: bool = Field(..., description="Is payment final")
+    status: str = Field(..., description="Payment status")
+    from_: Optional[str] = Field(None, alias="from", description="Sender address")
+    wallet_address_uuid: Optional[str] = Field(None, description="Wallet address UUID")
+    network: Optional[str] = Field(None, description="Blockchain network")
+    currency: str = Field(..., description="Currency")
+    payer_currency: Optional[str] = Field(None, description="Payer currency")
+    additional_data: Optional[str] = Field(None, description="Additional data")
+    txid: Optional[str] = Field(None, description="Transaction hash")
+    sign: str = Field(..., description="Webhook signature")
+    
+    @property
+    def from_address(self) -> Optional[str]:
+        """Get sender address from 'from' field."""
+        return self.from_
+    
+    @field_validator('status')
+    @classmethod
+    def validate_status(cls, v):
+        """Validate status is one of expected values."""
+        valid_statuses = ['check', 'paid', 'paid_over', 'fail', 'wrong_amount', 'cancel', 
+                         'system_fail', 'refund_process', 'refund_fail', 'refund_paid']
+        if v not in valid_statuses:
+            # Don't import logger here to avoid issues, just pass
+            pass
+        return v
+
+
+class CryptomusStatusResponse(BaseModel):
+    """Cryptomus payment status response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    state: int = Field(..., description="Response state")
+    result: Optional[CryptomusPaymentInfo] = Field(None, description="Payment info")
+    message: Optional[str] = Field(None, description="Response message")
+
+
+class CryptomusCurrenciesResponse(BaseModel):
+    """Cryptomus supported currencies response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    state: int = Field(..., description="Response state")
+    result: List[CryptomusCurrency] = Field(default_factory=list, description="List of currencies")
+    message: Optional[str] = Field(None, description="Response message")
+
+
+class CryptomusNetworksResponse(BaseModel):
+    """Cryptomus supported networks response."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    state: int = Field(..., description="Response state")
+    result: Dict[str, List[CryptomusNetwork]] = Field(default_factory=dict, description="Networks by currency")
+    message: Optional[str] = Field(None, description="Response message")
+
+
+# =============================================================================
+# MONITORING & HEALTH CHECK MODELS
+# =============================================================================
+
+class CryptomusErrorResponse(BaseModel):
+    """Cryptomus API error response schema for health checks."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    error: str = Field(..., description="Error message")
+    
+    @field_validator('error')
+    @classmethod
+    def validate_not_found_error(cls, v):
+        """Validate this is a not found error (meaning API is responding)."""
+        if v.lower() not in ['not found', 'unauthorized', 'forbidden']:
+            raise ValueError(f"Unexpected error: {v}")
+        return v