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

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

@@ -1,380 +0,0 @@
-"""
-NowPayments provider implementation.
-
-Enhanced crypto payment provider with minimal typing.
-"""
-
-import requests
-import hashlib
-import hmac
-from typing import Optional, List
-from decimal import Decimal
-from datetime import datetime
-from ..base import PaymentProvider
-from ...internal_types import ProviderResponse, WebhookData, PaymentAmountEstimate, UniversalCurrency, UniversalCurrenciesResponse
-from .models import NowPaymentsConfig
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger("nowpayments")
-
-
-class NowPaymentsProvider(PaymentProvider):
-    """NowPayments cryptocurrency payment provider."""
-    
-    # Map NowPayments status to universal status
-    STATUS_MAPPING = {
-        'waiting': 'pending',
-        'confirming': 'processing',
-        'confirmed': 'completed',
-        'sending': 'processing',
-        'partially_paid': 'pending',
-        'finished': 'completed',
-        'failed': 'failed',
-        'refunded': 'refunded',
-        'expired': 'expired'
-    }
-    
-    def __init__(self, config: NowPaymentsConfig):
-        """Initialize NowPayments provider."""
-        super().__init__(config)
-        self.config = config
-        self.api_key = config.api_key
-        # TEMP: Disable sandbox since sandbox registration site is down
-        # self.sandbox = config.sandbox
-        self.sandbox = False  # Force production URL
-        self.ipn_secret = config.ipn_secret or ''
-        self.base_url = self._get_base_url()
-        
-        # Configurable URLs 
-        self.callback_url = config.callback_url
-        self.success_url = config.success_url
-        self.cancel_url = config.cancel_url
-        
-        self.headers = {
-            'x-api-key': self.api_key.get_secret_value() if hasattr(self.api_key, 'get_secret_value') else str(self.api_key),
-            'Content-Type': 'application/json'
-        }
-    
-    def _get_dynamic_callback_url(self) -> Optional[str]:
-        """Get dynamic callback URL with ngrok support."""
-        try:
-            from api.config import config
-            
-            # Try ngrok first (development)
-            ngrok_url = getattr(config, 'get_ngrok_url', lambda x: None)('/cfg/admin/django_cfg_payments/webhooks/nowpayments/')
-            if ngrok_url:
-                logger.info(f"Using ngrok webhook URL: {ngrok_url}")
-                return ngrok_url
-            
-            # Fallback to configured callback URL
-            if self.callback_url:
-                logger.info(f"Using configured webhook URL: {self.callback_url}")
-                return self.callback_url
-            
-            # Fallback to site URL
-            site_webhook = f"{config.site_url}/cfg/admin/django_cfg_payments/webhooks/nowpayments/"
-            logger.info(f"Using site webhook URL: {site_webhook}")
-            return site_webhook
-            
-        except Exception as e:
-            logger.warning(f"Failed to get dynamic callback URL: {e}")
-            return self.callback_url
-    
-    def _get_base_url(self) -> str:
-        """Get base URL based on sandbox mode."""
-        if self.sandbox:
-            return 'https://api-sandbox.nowpayments.io/v1'
-        return 'https://api.nowpayments.io/v1'
-    
-    def _make_request(self, method: str, endpoint: str, data: Optional[dict] = None) -> Optional[dict]:
-        """Make HTTP request to NowPayments API with error handling."""
-        try:
-            url = f"{self.base_url}/{endpoint}"
-            
-            response = requests.request(
-                method=method,
-                url=url,
-                headers=self.headers,
-                json=data,
-                timeout=30
-            )
-            
-            response.raise_for_status()
-            return response.json()
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"NowPayments API request failed: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Unexpected error in NowPayments request: {e}")
-            return None
-    
-    def create_payment(self, payment_data: dict) -> ProviderResponse:
-        """Create payment via NowPayments API."""
-        try:
-            amount = Decimal(str(payment_data['amount']))
-            currency = payment_data['currency']
-            order_id = payment_data.get('order_id', f'payment_{int(amount * 100)}_{currency}')
-            
-            payment_request = {
-                'price_amount': float(amount),
-                'price_currency': 'usd',  # Base currency
-                'pay_currency': currency,
-                'order_id': order_id,
-                'order_description': payment_data.get('description', f'Payment {order_id}'),
-            }
-            
-            # Add optional URLs
-            if self.success_url:
-                payment_request['success_url'] = self.success_url
-            if self.cancel_url:
-                payment_request['cancel_url'] = self.cancel_url
-            
-            # Get dynamic callback URL with ngrok support
-            dynamic_callback_url = self._get_dynamic_callback_url()
-            if dynamic_callback_url:
-                payment_request['ipn_callback_url'] = dynamic_callback_url
-            
-            response = self._make_request('POST', 'payment', payment_request)
-            
-            if response:
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response.get('payment_id'),
-                    payment_url=response.get('invoice_url'),
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency'),
-                    status='pending'
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Failed to create payment'
-                )
-                
-        except Exception as e:
-            logger.error(f"NowPayments 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 NowPayments API."""
-        try:
-            response = self._make_request('GET', f'payment/{payment_id}')
-            
-            if response:
-                provider_status = response.get('payment_status', 'unknown')
-                universal_status = self.STATUS_MAPPING.get(provider_status, 'unknown')
-                
-                return ProviderResponse(
-                    success=True,
-                    provider_payment_id=response.get('payment_id'),
-                    status=universal_status,
-                    pay_address=response.get('pay_address'),
-                    amount=Decimal(str(response.get('pay_amount', 0))),
-                    currency=response.get('pay_currency')
-                )
-            else:
-                return ProviderResponse(
-                    success=False,
-                    error_message='Payment not found'
-                )
-                
-        except Exception as e:
-            logger.error(f"NowPayments check_payment_status error: {e}")
-            return ProviderResponse(
-                success=False,
-                error_message=str(e)
-            )
-    
-    def process_webhook(self, payload: dict) -> WebhookData:
-        """Process NowPayments webhook."""
-        try:
-            provider_status = payload.get('payment_status', 'unknown')
-            universal_status = self.STATUS_MAPPING.get(provider_status, 'unknown')
-            
-            return WebhookData(
-                provider_payment_id=str(payload.get('payment_id', '')),
-                status=universal_status,
-                pay_amount=Decimal(str(payload.get('pay_amount', 0))),
-                actually_paid=Decimal(str(payload.get('actually_paid', 0))),
-                order_id=payload.get('order_id'),
-                signature=payload.get('signature')
-            )
-            
-        except Exception as e:
-            logger.error(f"NowPayments webhook processing error: {e}")
-            raise
-    
-    
-    def get_parsed_currencies(self) -> UniversalCurrenciesResponse:
-        """Get parsed and normalized currencies from NowPayments."""
-        try:
-            # Use full-currencies endpoint to get detailed currency info
-            response = self._make_request('GET', 'full-currencies')
-            
-            if not response or 'currencies' not in response:
-                return UniversalCurrenciesResponse(currencies=[])
-            
-            universal_currencies = []
-            
-            for currency_data in response['currencies']:
-                if not currency_data.get('enable', True):
-                    continue  # Skip disabled currencies
-                
-                provider_code = currency_data.get('code', '').upper()
-                if not provider_code:
-                    continue
-                
-                # Parse provider code into base currency + network using API data
-                currency_name = currency_data.get('name', '')
-                api_network = currency_data.get('network')
-                ticker = currency_data.get('ticker', '')
-                base_currency_code, network_code = self._parse_currency_code(provider_code, currency_name, api_network, ticker)
-                
-                # Determine currency type
-                currency_type = 'fiat' if network_code is None else 'crypto'
-                
-                universal_currency = UniversalCurrency(
-                    provider_currency_code=provider_code,
-                    base_currency_code=base_currency_code,
-                    network_code=network_code,
-                    name=currency_data.get('name', base_currency_code),
-                    currency_type=currency_type,
-                    is_enabled=currency_data.get('enable', True),
-                    is_popular=currency_data.get('is_popular', False),
-                    is_stable=currency_data.get('is_stable', False),
-                    priority=currency_data.get('priority', 0),
-                    logo_url=currency_data.get('logo_url', ''),
-                    available_for_payment=currency_data.get('available_for_payment', True),
-                    available_for_payout=currency_data.get('available_for_payout', True),
-                    raw_data=currency_data
-                )
-                
-                universal_currencies.append(universal_currency)
-            
-            return UniversalCurrenciesResponse(currencies=universal_currencies)
-            
-        except Exception as e:
-            logger.error(f"Error parsing currencies: {e}")
-            return UniversalCurrenciesResponse(currencies=[])
-    
-    def _parse_currency_code(self, provider_code: str, currency_name: str, network_code: Optional[str] = None, ticker: str = '') -> tuple[str, Optional[str]]:
-        """
-        Smart parsing using API data, prioritizing ticker field.
-        
-        Uses ticker as primary source for base currency, then falls back to name parsing.
-        
-        Examples:
-        - "1INCHBSC", "1Inch Network (BSC)", "bsc", "1inch" → ("1INCH", "bsc") 
-        - "USDTERC20", "Tether USD (ERC-20)", "eth", "usdt" → ("USDT", "eth") 
-        - "BTC", "Bitcoin", "btc", "btc" → ("BTC", "btc")
-        """
-        # Priority 1: Use ticker if available and meaningful
-        if ticker and len(ticker.strip()) > 0:
-            base_currency = ticker.upper().strip()
-            return base_currency, network_code
-        
-        # Priority 2: Extract from name using patterns
-        base_currency = self._extract_base_currency_from_name(currency_name, provider_code)
-        return base_currency, network_code
-    
-    def _extract_base_currency_from_name(self, currency_name: str, fallback_code: str) -> str:
-        """Extract base currency from human-readable name using real API patterns."""
-        if not currency_name:
-            return fallback_code
-        
-        name_lower = currency_name.lower()
-        
-        # Precise patterns from real NowPayments API data
-        precise_patterns = {
-            # Stablecoins - most common
-            'tether usd': 'USDT',
-            'tether (': 'USDT',          # "Tether (Arbitrum One)"
-            'usd coin': 'USDC',          # "USD Coin (Ethereum)"
-            'usd coin bridged': 'USDC',  # "USD Coin Bridged (Polygon)"
-            'trueusd': 'TUSD',           # "TrueUSD (Tron)"
-            
-            # Major cryptocurrencies  
-            'bitcoin': 'BTC',
-            'ethereum': 'ETH',
-            'cardano': 'ADA',
-            'dogecoin': 'DOGE',
-            'litecoin': 'LTC',
-            
-            # Exchange tokens
-            'binance coin': 'BNB',
-            'bnb': 'BNB',
-            
-            # Layer 1/2 tokens
-            'polygon': 'MATIC',
-            'avalanche': 'AVAX',
-            'solana': 'SOL',
-            'chainlink': 'LINK',
-            
-            # Other stablecoins
-            'dai stablecoin': 'DAI',
-            'frax': 'FRAX'
-        }
-        
-        # Check precise patterns first (most reliable)
-        for pattern, base in precise_patterns.items():
-            if pattern in name_lower:
-                return base
-        
-        # Fallback patterns for edge cases
-        fallback_patterns = {
-            'usdt': 'USDT',
-            'usdc': 'USDC', 
-            'tusd': 'TUSD',
-            'btc': 'BTC',
-            'eth ': 'ETH',
-            'ada': 'ADA',
-            'doge': 'DOGE',
-            'matic': 'MATIC'
-        }
-        
-        for pattern, base in fallback_patterns.items():
-            if pattern in name_lower:
-                return base
-        
-        # Last resort: use the provider code as-is
-        return fallback_code
-    
-    
-    def validate_webhook(self, payload: dict, headers: Optional[dict] = None) -> bool:
-        """Validate NowPayments webhook signature."""
-        try:
-            if not self.ipn_secret:
-                logger.warning("IPN secret not configured, skipping webhook validation")
-                return True
-            
-            if not headers:
-                logger.warning("No headers provided for webhook validation")
-                return False
-            
-            # Get signature from headers
-            signature = headers.get('x-nowpayments-sig')
-            if not signature:
-                logger.warning("No signature found in webhook headers")
-                return False
-            
-            # TODO: Implement proper HMAC signature validation
-            # This requires the raw payload body for proper validation
-            logger.info("Webhook signature validation placeholder")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Webhook validation error: {e}")
-            return False
-    
-    def check_api_status(self) -> bool:
-        """Check if NowPayments API is available."""
-        try:
-            response = self._make_request('GET', 'status')
-            return response is not None and response.get('message') == 'OK'
-        except:
-            return False

django_cfg/apps/payments/services/providers/stripe/__init__.py

@@ -1,4 +0,0 @@
-from .provider import StripeProvider
-from .models import StripeConfig, StripeCurrency, StripeNetwork
-
-__all__ = ['StripeProvider', 'StripeConfig', 'StripeCurrency', 'StripeNetwork']

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

@@ -1,184 +0,0 @@
-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 StripeConfig(ProviderConfig):
-    """Stripe provider configuration with Pydantic v2."""
-    
-    webhook_secret: Optional[str] = Field(None, description="Webhook endpoint secret")
-    success_url: Optional[str] = Field(None, description="Payment success redirect URL")
-    cancel_url: Optional[str] = Field(None, description="Payment cancel redirect URL")
-    
-    @field_validator('api_key')
-    @classmethod
-    def validate_api_key(cls, v: str) -> str:
-        if not v or not v.startswith(('sk_test_', 'sk_live_')):
-            raise ValueError("Stripe API key must start with sk_test_ or sk_live_")
-        return v
-
-
-class StripeCurrency(BaseModel):
-    """Stripe specific currency model."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    currency_code: str = Field(..., description="Currency symbol (e.g., USD, EUR)")
-    name: str = Field(..., description="Full currency name")
-    decimal_digits: int = Field(..., description="Number of decimal digits")
-    min_amount: Optional[Decimal] = Field(None, description="Minimum charge amount")
-    max_amount: Optional[Decimal] = Field(None, description="Maximum charge amount")
-    is_zero_decimal: bool = Field(False, description="Zero-decimal currency (like JPY)")
-
-
-class StripeNetwork(BaseModel):
-    """Stripe network model (not applicable for fiat payments)."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    code: str = Field(..., description="Network code (always 'stripe')")
-    name: str = Field(..., description="Network display name")
-    currency: str = Field(..., description="Currency this network belongs to")
-
-
-class StripePaymentIntentRequest(BaseModel):
-    """Stripe PaymentIntent creation request."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    amount: int = Field(..., description="Amount in smallest currency unit")
-    currency: str = Field(..., description="Three-letter ISO currency code")
-    payment_method_types: List[str] = Field(default=["card"], description="Payment method types")
-    confirm: bool = Field(False, description="Confirm PaymentIntent immediately")
-    capture_method: str = Field("automatic", description="Capture method")
-    confirmation_method: str = Field("automatic", description="Confirmation method")
-    description: Optional[str] = Field(None, description="Payment description")
-    metadata: Optional[Dict[str, str]] = Field(None, description="Metadata")
-    receipt_email: Optional[str] = Field(None, description="Receipt email")
-    return_url: Optional[str] = Field(None, description="Return URL")
-    success_url: Optional[str] = Field(None, description="Success URL")
-    cancel_url: Optional[str] = Field(None, description="Cancel URL")
-
-
-class StripePaymentIntentResponse(BaseModel):
-    """Stripe PaymentIntent response."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    id: str = Field(..., description="PaymentIntent ID")
-    object: str = Field(..., description="Object type")
-    amount: int = Field(..., description="Amount in smallest currency unit")
-    currency: str = Field(..., description="Currency code")
-    status: str = Field(..., description="PaymentIntent status")
-    client_secret: str = Field(..., description="Client secret for confirmation")
-    created: int = Field(..., description="Creation timestamp")
-    description: Optional[str] = Field(None, description="Payment description")
-    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
-    payment_method: Optional[str] = Field(None, description="Payment method ID")
-    receipt_email: Optional[str] = Field(None, description="Receipt email")
-    latest_charge: Optional[str] = Field(None, description="Latest charge ID")
-
-
-class StripeWebhookEvent(BaseModel):
-    """Stripe webhook event data."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    id: str = Field(..., description="Event ID")
-    object: str = Field(..., description="Object type")
-    api_version: str = Field(..., description="API version")
-    created: int = Field(..., description="Creation timestamp")
-    type: str = Field(..., description="Event type")
-    data: Dict[str, Any] = Field(..., description="Event data")
-    livemode: bool = Field(..., description="Live mode flag")
-    pending_webhooks: int = Field(..., description="Pending webhooks count")
-    request: Optional[Dict[str, Any]] = Field(None, description="Request info")
-
-
-class StripeCharge(BaseModel):
-    """Stripe charge object."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    id: str = Field(..., description="Charge ID")
-    object: str = Field(..., description="Object type")
-    amount: int = Field(..., description="Amount charged")
-    currency: str = Field(..., description="Currency code")
-    status: str = Field(..., description="Charge status")
-    created: int = Field(..., description="Creation timestamp")
-    description: Optional[str] = Field(None, description="Charge description")
-    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
-    payment_intent: Optional[str] = Field(None, description="PaymentIntent ID")
-    receipt_email: Optional[str] = Field(None, description="Receipt email")
-    receipt_url: Optional[str] = Field(None, description="Receipt URL")
-
-
-class StripeCustomer(BaseModel):
-    """Stripe customer object."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    id: str = Field(..., description="Customer ID")
-    object: str = Field(..., description="Object type")
-    created: int = Field(..., description="Creation timestamp")
-    email: Optional[str] = Field(None, description="Customer email")
-    name: Optional[str] = Field(None, description="Customer name")
-    phone: Optional[str] = Field(None, description="Customer phone")
-    metadata: Dict[str, str] = Field(default_factory=dict, description="Metadata")
-
-
-class StripeError(BaseModel):
-    """Stripe error response."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    type: str = Field(..., description="Error type")
-    code: Optional[str] = Field(None, description="Error code")
-    message: str = Field(..., description="Error message")
-    param: Optional[str] = Field(None, description="Parameter causing error")
-    decline_code: Optional[str] = Field(None, description="Decline code")
-
-
-class StripeErrorResponse(BaseModel):
-    """Stripe error response wrapper."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    error: StripeError = Field(..., description="Error details")
-
-
-class StripeCurrenciesResponse(BaseModel):
-    """Stripe supported currencies response."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    currencies: List[StripeCurrency] = Field(..., description="List of supported currencies")
-
-
-class StripeWebhookEndpoint(BaseModel):
-    """Stripe webhook endpoint configuration."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    id: str = Field(..., description="Webhook endpoint ID")
-    object: str = Field(..., description="Object type")
-    api_version: Optional[str] = Field(None, description="API version")
-    created: int = Field(..., description="Creation timestamp")
-    enabled_events: List[str] = Field(..., description="Enabled event types")
-    livemode: bool = Field(..., description="Live mode flag")
-    status: str = Field(..., description="Endpoint status")
-    url: str = Field(..., description="Endpoint URL")
-
-
-# =============================================================================
-# MONITORING & HEALTH CHECK MODELS
-# =============================================================================
-
-class StripeHealthErrorResponse(BaseModel):
-    """Stripe API error response schema for health checks."""
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
-    class StripeHealthError(BaseModel):
-        message: str = Field(..., description="Error message")
-        type: str = Field(..., description="Error type")
-        
-    error: StripeHealthError = Field(..., description="Error details")
-    
-    @field_validator('error')
-    @classmethod
-    def validate_auth_error(cls, v):
-        """Validate this is an authentication error (meaning API is healthy)."""
-        if v.type != 'invalid_request_error':
-            raise ValueError(f"Expected auth error, got '{v.type}'")
-        return v

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

@@ -1,109 +0,0 @@
-from typing import Dict, Any, Optional, List
-from decimal import Decimal
-
-from ..base import PaymentProvider
-from ...internal_types import ProviderResponse, WebhookData
-from .models import StripeConfig, StripeCurrency, StripeNetwork
-from django_cfg.modules.django_logger import get_logger
-
-logger = get_logger("stripe")
-
-
-class StripeProvider(PaymentProvider):
-    """Stripe payment provider implementation."""
-    
-    name = "stripe"
-    
-    def __init__(self, config: StripeConfig):
-        super().__init__(config)
-        self.config = config
-        self.api_key = config.api_key
-        self.webhook_secret = config.webhook_secret
-        self.base_url = "https://api.stripe.com/v1"
-    
-    def create_payment(self, amount_usd: Decimal, currency_code: str, description: str = None, **kwargs) -> ProviderResponse:
-        """Create a payment intent with Stripe."""
-        # TODO: Implement Stripe payment creation
-        return ProviderResponse(
-            success=False,
-            error_message="Stripe provider not implemented yet"
-        )
-    
-    def check_payment_status(self, payment_id: str) -> ProviderResponse:
-        """Check payment status from Stripe."""
-        # TODO: Implement Stripe payment status check
-        return ProviderResponse(
-            success=False,
-            error_message="Stripe provider not implemented yet"
-        )
-    
-    def process_webhook(self, webhook_data: WebhookData) -> ProviderResponse:
-        """Process Stripe webhook."""
-        # TODO: Implement Stripe webhook processing
-        return ProviderResponse(
-            success=False,
-            error_message="Stripe provider not implemented yet"
-        )
-    
-    def validate_webhook_signature(self, payload: str, signature: str) -> bool:
-        """Validate Stripe webhook signature."""
-        # TODO: Implement Stripe signature validation
-        return False
-    
-    def get_supported_currencies(self) -> ProviderResponse:
-        """Get supported currencies from Stripe."""
-        # Common fiat currencies supported by Stripe
-        currencies = [
-            StripeCurrency(
-                currency_code='USD',
-                name='US Dollar',
-                decimal_digits=2,
-                min_amount=Decimal('0.50'),
-                is_zero_decimal=False
-            ),
-            StripeCurrency(
-                currency_code='EUR',
-                name='Euro',
-                decimal_digits=2,
-                min_amount=Decimal('0.50'),
-                is_zero_decimal=False
-            ),
-            StripeCurrency(
-                currency_code='GBP',
-                name='British Pound',
-                decimal_digits=2,
-                min_amount=Decimal('0.30'),
-                is_zero_decimal=False
-            ),
-            StripeCurrency(
-                currency_code='JPY',
-                name='Japanese Yen',
-                decimal_digits=0,
-                min_amount=Decimal('50'),
-                is_zero_decimal=True
-            ),
-        ]
-        
-        return ProviderResponse(
-            success=True,
-            data={'currencies': [c.model_dump() for c in currencies]}
-        )
-    
-    def get_supported_networks(self, currency_code: str = None) -> ProviderResponse:
-        """Get supported networks (not applicable for Stripe fiat payments)."""
-        return ProviderResponse(
-            success=True,
-            data={'networks': {}}
-        )
-    
-    def get_currency_network_mapping(self) -> Dict[str, List[str]]:
-        """Get currency network mapping (not applicable for Stripe)."""
-        return {}
-    
-    def check_api_status(self) -> Dict[str, Any]:
-        """Check Stripe API status."""
-        # TODO: Implement actual API health check
-        return {
-            'status': 'unknown',
-            'message': 'Stripe provider not implemented yet'
-        }