ffio.py

import hmac
import json
import hashlib
import requests
from typing import Dict, Optional, Union, Any

class FixedFloatAPI:
    """Python wrapper for the FixedFloat API"""
    
    def __init__(self, api_key: str, api_secret: str):
        """Initialize the API wrapper with your API credentials
        
        Args:
            api_key: Your FixedFloat API key
            api_secret: Your FixedFloat API secret
        """
        self.api_key = api_key
        self.api_secret = api_secret.encode()  # Convert to bytes for HMAC
        self.base_url = "https://ff.io/api/v2"
        
    def sign(data):
        return hmac.new(
            key=YOUR_API_SECRET.encode(),
            msg=data.encode(),
            digestmod=hashlib.sha256
        ).hexdigest()
  
  
    def request(self, method, params={}):
        url = 'https://ff.io/api/v2/' + method
        data = json.dumps(params)
        headers = {
            'X-API-KEY': YOUR_API_KEY,
            'X-API-SIGN': sign(data)
        }
        r = requests.post(url, data=data, headers=headers)
        return r.json()
        

    def _generate_sign(self, data: Union[Dict, str]) -> str:
        """Generate the HMAC SHA256 signature required for API requests
        
        Args:
            data: Request data to sign (dict or string)
            
        Returns:
            Hex digest of the HMAC signature
        """
        if isinstance(data, dict):
            data = json.dumps(data)
        return hmac.new(
            key=self.api_secret,
            msg=data.encode(),
            digestmod=hashlib.sha256
        ).hexdigest()
        
    def _request(self, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
        """Make a request to the API
        
        Args:
            endpoint: API endpoint to call
            data: Optional request data
            
        Returns:
            API response as a dictionary
            
        Raises:
            requests.exceptions.RequestException: If the request fails
        """
        url = f"{self.base_url}/{endpoint}"
        
        # Prepare request data and headers
        data = data or {}
        data_str = json.dumps(data)
        headers = {
            "Accept": "application/json",
            "Content-Type": "application/json; charset=UTF-8",
            "X-API-KEY": self.api_key,
            "X-API-SIGN": self._generate_sign(data_str)
        }
        
        # Make the request
        response = requests.post(url, headers=headers, data=data_str)
        response.raise_for_status()
        
        print(json.dumps(response.json(), indent=2))
        
        return response.json()
    
    def get_currencies(self) -> Dict[str, Any]:
        """Get list of supported currencies"""
        return self._request("ccies")
    
    def get_price(self, from_currency: str, to_currency: str, amount: float, 
                  direction: str = "from", order_type: str = "float", 
                  ref_code: Optional[str] = None, aff_tax: Optional[float] = None) -> Dict[str, Any]:
        """Get exchange rate for a currency pair
        
        Args:
            from_currency: Currency code to send
            to_currency: Currency code to receive
            amount: Amount to exchange
            direction: "from" or "to" indicating if amount is for sending or receiving
            order_type: "float" or "fixed" for exchange rate type
            ref_code: Optional affiliate program code
            aff_tax: Optional desired affiliate program earnings percentage
            
        Returns:
            Price information dictionary
        """
        data = {
            "fromCcy": from_currency,
            "toCcy": to_currency,
            "amount": amount,
            "direction": direction,
            "type": order_type
        }
        
        if ref_code:
            data["refcode"] = ref_code
        if aff_tax is not None:
            data["afftax"] = aff_tax
            
        return self._request("price", data)
    
    def create_order(self, from_currency: str, to_currency: str, amount: float,
                    direction: str = "from", order_type: str = "float",
                    address: str = None, extra_id: Optional[str] = None,
                    ref_code: Optional[str] = None, aff_tax: Optional[float] = None) -> Dict[str, Any]:
        """Create a new exchange order
        
        Args:
            from_currency: Currency code to send
            to_currency: Currency code to receive  
            amount: Amount to exchange
            direction: "from" or "to" indicating if amount is for sending or receiving
            order_type: "float" or "fixed" for exchange rate type
            address: Destination address for receiving currency
            extra_id: Optional extra ID/memo/tag for the destination address
            ref_code: Optional affiliate program code
            aff_tax: Optional desired affiliate program earnings percentage
            
        Returns:
            Order details dictionary
        """
        data = {
            "fromCcy": from_currency,
            "toCcy": to_currency,
            "amount": amount,
            "direction": direction,
            "type": order_type,
            "toAddress": address,
        }
            
        return self._request("create", data)

    def get_order_details(self, order_id: str, token: str) -> Dict[str, Any]:
        """Get details of a specific order
        
        Args:
            order_id: The ID of the order to check
            token: The token associated with the order
            
        Returns:
            Order details dictionary
        """
        data = {
            "id": order_id,
            "token": token
        }
        
        return self._request("order", data)