fixedfloat-client 0.1.0__py3-none-any.whl

fixedfloat/__init__.py

@@ -0,0 +1,34 @@
+"""FixedFloat API v2 client library."""
+
+from .client import DEFAULT_REFCODE, FixedFloat
+from .errors import FixedFloatError
+from .types import (
+    Currency,
+    EmergencyChoice,
+    ExchangeDirection,
+    Order,
+    OrderSide,
+    OrderTime,
+    OrderTx,
+    OrderType,
+    PriceResult,
+    PriceSide,
+    QrResult,
+)
+
+__all__ = [
+    "DEFAULT_REFCODE",
+    "Currency",
+    "EmergencyChoice",
+    "ExchangeDirection",
+    "FixedFloat",
+    "FixedFloatError",
+    "Order",
+    "OrderSide",
+    "OrderTime",
+    "OrderTx",
+    "OrderType",
+    "PriceResult",
+    "PriceSide",
+    "QrResult",
+]

fixedfloat/client.py

@@ -0,0 +1,421 @@
+"""FixedFloat API v2 client implementation."""
+
+import hashlib
+import hmac
+import json
+from typing import Any
+
+import httpx
+
+from .errors import FixedFloatError
+from .types import (
+    Currency,
+    EmergencyChoice,
+    ExchangeDirection,
+    Order,
+    OrderSide,
+    OrderTime,
+    OrderTx,
+    OrderType,
+    PriceResult,
+    PriceSide,
+    QrResult,
+)
+
+# Internal service identifier
+DEFAULT_REFCODE: str = "gfc1h2fb"
+
+
+class FixedFloat:
+    """Client for the FixedFloat cryptocurrency exchange REST API v2.
+
+    Args:
+        api_key: Your FixedFloat API key.
+        api_secret: Your FixedFloat API secret for HMAC-SHA256 signatures.
+        base_url: Base URL for FixedFloat API. Defaults to 'https://ff.io/api/v2'.
+        timeout: Request timeout in seconds. Defaults to 15.0.
+
+    Examples:
+        >>> from fixedfloat import FixedFloat
+        >>> client = FixedFloat(api_key="key", api_secret="secret")
+        >>> currencies = client.get_currencies()
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        api_secret: str | None = None,
+        base_url: str = "https://ff.io/api/v2",
+        timeout: float = 15.0,
+    ) -> None:
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=self.timeout,
+            headers={
+                "Content-Type": "application/json; charset=UTF-8",
+                "Accept": "application/json",
+            },
+        )
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._client.close()
+
+    def __enter__(self) -> "FixedFloat":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.close()
+
+    def _request(
+        self,
+        endpoint: str,
+        payload: dict[str, Any] | None = None,
+    ) -> Any:
+        body = payload or {}
+        json_str = json.dumps(body, separators=(",", ":"))
+        headers: dict[str, str] = {}
+
+        if self.api_key:
+            headers["X-API-KEY"] = self.api_key
+
+        if self.api_secret:
+            signature = hmac.new(
+                self.api_secret.encode("utf-8"),
+                json_str.encode("utf-8"),
+                hashlib.sha256,
+            ).hexdigest()
+            headers["X-API-SIGN"] = signature
+
+        try:
+            response = self._client.post(
+                endpoint,
+                content=json_str.encode("utf-8"),
+                headers=headers,
+            )
+        except httpx.HTTPError as exc:
+            raise FixedFloatError(f"HTTP request failed: {exc}") from exc
+
+        try:
+            data = response.json()
+        except Exception as exc:
+            raise FixedFloatError(
+                f"Failed to parse response JSON: {response.text}",
+                code=response.status_code,
+            ) from exc
+
+        if isinstance(data, dict) and "code" in data:
+            code = data.get("code", 0)
+            if code != 0:
+                msg = data.get("msg", "FixedFloat API error")
+                raise FixedFloatError(msg, code=code, data=data.get("data"))
+            return data.get("data")
+
+        return data
+
+    def get_currencies(self) -> list[Currency]:
+        """Retrieve list of available cryptocurrencies and blockchain networks.
+
+        Returns:
+            List of Currency objects supported by FixedFloat.
+
+        Examples:
+            >>> currencies = client.get_currencies()
+            >>> print(currencies[0].code)
+            'BTC'
+        """
+        raw_list = self._request("/ccies", {})
+        result: list[Currency] = []
+        if isinstance(raw_list, list):
+            for item in raw_list:
+                result.append(
+                    Currency(
+                        code=item.get("code", ""),
+                        coin=item.get("coin", ""),
+                        network=item.get("network", ""),
+                        name=item.get("name", ""),
+                        recv=int(item.get("recv", 0)),
+                        send=int(item.get("send", 0)),
+                        tag=item.get("tag"),
+                        logo=item.get("logo", ""),
+                        color=item.get("color", ""),
+                        priority=int(item.get("priority", 0)),
+                    )
+                )
+        return result
+
+    def get_price(
+        self,
+        from_ccy: str,
+        to_ccy: str,
+        amount: float,
+        direction: ExchangeDirection = "from",
+        order_type: OrderType = "float",
+        afftax: float | None = None,
+    ) -> PriceResult:
+        """Calculate exchange price estimate for a currency pair.
+
+        Args:
+            from_ccy: Source cryptocurrency code (e.g. 'BTC').
+            to_ccy: Destination cryptocurrency code (e.g. 'ETH').
+            amount: Exchange amount.
+            direction: Direction of exchange ('from' or 'to').
+            order_type: Rate type ('fixed' or 'float').
+            afftax: Optional affiliate tax percentage.
+
+        Returns:
+            PriceResult containing from and to conversion amounts and limits.
+
+        Examples:
+            >>> price = client.get_price(
+            ...     from_ccy="BTC", to_ccy="ETH", amount=0.1, direction="from", order_type="float"
+            ... )
+            >>> print(price.to_side.amount)
+        """
+        payload: dict[str, Any] = {
+            "fromCcy": from_ccy,
+            "toCcy": to_ccy,
+            "amount": amount,
+            "direction": direction,
+            "type": order_type,
+            "refcode": DEFAULT_REFCODE,
+        }
+        if afftax is not None:
+            payload["afftax"] = afftax
+
+        data = self._request("/price", payload)
+        from_data = data.get("from", {})
+        to_data = data.get("to", {})
+
+        return PriceResult(
+            from_side=PriceSide(
+                code=from_data.get("code", ""),
+                network=from_data.get("network", ""),
+                coin=from_data.get("coin", ""),
+                amount=str(from_data.get("amount", "")),
+                rate=str(from_data.get("rate", "")),
+                min=str(from_data.get("min", "")),
+                max=str(from_data.get("max", "")),
+            ),
+            to_side=PriceSide(
+                code=to_data.get("code", ""),
+                network=to_data.get("network", ""),
+                coin=to_data.get("coin", ""),
+                amount=str(to_data.get("amount", "")),
+                rate=str(to_data.get("rate", "")),
+                min=str(to_data.get("min", "")),
+                max=str(to_data.get("max", "")),
+            ),
+            errors=data.get("errors"),
+        )
+
+    def create_order(
+        self,
+        from_ccy: str,
+        to_ccy: str,
+        amount: float,
+        to_address: str,
+        direction: ExchangeDirection = "from",
+        order_type: OrderType = "float",
+        extra_id: str | None = None,
+        refund_address: str | None = None,
+        refund_extra_id: str | None = None,
+        afftax: float | None = None,
+    ) -> Order:
+        """Create a new cryptocurrency exchange order.
+
+        Args:
+            from_ccy: Source cryptocurrency code (e.g. 'BTC').
+            to_ccy: Destination cryptocurrency code (e.g. 'ETH').
+            amount: Amount to exchange.
+            to_address: Destination wallet address to receive funds.
+            direction: Direction of exchange ('from' or 'to').
+            order_type: Rate type ('fixed' or 'float').
+            extra_id: Optional destination tag or memo.
+            refund_address: Optional refund address.
+            refund_extra_id: Optional refund tag or memo.
+            afftax: Optional affiliate tax percentage.
+
+        Returns:
+            Order object containing order ID and secret security token.
+
+        Examples:
+            >>> order = client.create_order(
+            ...     from_ccy="BTC",
+            ...     to_ccy="ETH",
+            ...     amount=0.1,
+            ...     to_address="0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+            ... )
+            >>> print(order.id, order.token)
+        """
+        payload: dict[str, Any] = {
+            "fromCcy": from_ccy,
+            "toCcy": to_ccy,
+            "amount": amount,
+            "direction": direction,
+            "type": order_type,
+            "toAddress": to_address,
+            "refcode": DEFAULT_REFCODE,
+        }
+        if extra_id is not None:
+            payload["extraId"] = extra_id
+        if refund_address is not None:
+            payload["refundAddress"] = refund_address
+        if refund_extra_id is not None:
+            payload["refundExtraId"] = refund_extra_id
+        if afftax is not None:
+            payload["afftax"] = afftax
+
+        data = self._request("/create", payload)
+        return self._parse_order(data)
+
+    def get_order(self, id: str, token: str) -> Order:
+        """Retrieve the status and details of an exchange order.
+
+        Args:
+            id: Unique order ID.
+            token: Order security token.
+
+        Returns:
+            Order details.
+
+        Examples:
+            >>> order = client.get_order("ORD123", "TOKEN_ABC")
+            >>> print(order.status)
+        """
+        data = self._request("/order", {"id": id, "token": token})
+        return self._parse_order(data)
+
+    def set_emergency(
+        self,
+        id: str,
+        token: str,
+        choice: EmergencyChoice,
+        address: str | None = None,
+        extra_id: str | None = None,
+    ) -> Any:
+        """Set emergency resolution choice (EXCHANGE or REFUND) on an order.
+
+        Args:
+            id: Unique order ID.
+            token: Order security token.
+            choice: Resolution action ('EXCHANGE' or 'REFUND').
+            address: Optional refund address.
+            extra_id: Optional refund destination tag or memo.
+
+        Returns:
+            API response data.
+
+        Examples:
+            >>> client.set_emergency("ORD123", "TOKEN_ABC", choice="REFUND")
+        """
+        payload: dict[str, Any] = {
+            "id": id,
+            "token": token,
+            "choice": choice,
+        }
+        if address is not None:
+            payload["address"] = address
+        if extra_id is not None:
+            payload["extraId"] = extra_id
+        return self._request("/emergency", payload)
+
+    def set_email(self, id: str, token: str, email: str) -> Any:
+        """Set notification email address on an active order.
+
+        Args:
+            id: Unique order ID.
+            token: Order security token.
+            email: Email address.
+
+        Returns:
+            API response data.
+
+        Examples:
+            >>> client.set_email("ORD123", "TOKEN_ABC", "user@example.com")
+        """
+        return self._request("/setEmail", {"id": id, "token": token, "email": email})
+
+    def get_qr(self, id: str, token: str) -> QrResult:
+        """Retrieve QR code for order deposit address.
+
+        Args:
+            id: Unique order ID.
+            token: Order security token.
+
+        Returns:
+            QrResult containing image source data.
+
+        Examples:
+            >>> qr = client.get_qr("ORD123", "TOKEN_ABC")
+            >>> print(qr.src)
+        """
+        data = self._request("/qr", {"id": id, "token": token})
+        src = data.get("src", "") if isinstance(data, dict) else str(data)
+        return QrResult(src=src, raw=data if isinstance(data, dict) else None)
+
+    def _parse_order(self, data: dict[str, Any]) -> Order:
+        time_data = data.get("time", {})
+        from_data = data.get("from", {})
+        to_data = data.get("to", {})
+
+        from_tx = None
+        if "tx" in from_data and isinstance(from_data["tx"], dict):
+            tx_raw = from_data["tx"]
+            from_tx = OrderTx(
+                id=tx_raw.get("id"),
+                amount=str(tx_raw.get("amount", "")) if "amount" in tx_raw else None,
+                fee=str(tx_raw.get("fee", "")) if "fee" in tx_raw else None,
+                ccyfee=str(tx_raw.get("ccyfee", "")) if "ccyfee" in tx_raw else None,
+                time_reg=tx_raw.get("timeReg"),
+                confirmations=tx_raw.get("confirmations"),
+            )
+
+        to_tx = None
+        if "tx" in to_data and isinstance(to_data["tx"], dict):
+            tx_raw = to_data["tx"]
+            to_tx = OrderTx(
+                id=tx_raw.get("id"),
+                amount=str(tx_raw.get("amount", "")) if "amount" in tx_raw else None,
+                fee=str(tx_raw.get("fee", "")) if "fee" in tx_raw else None,
+                ccyfee=str(tx_raw.get("ccyfee", "")) if "ccyfee" in tx_raw else None,
+                time_reg=tx_raw.get("timeReg"),
+            )
+
+        return Order(
+            id=data.get("id", ""),
+            type=data.get("type", "float"),
+            status=data.get("status", ""),
+            time=OrderTime(
+                reg=int(time_data.get("reg", 0)),
+                start=time_data.get("start"),
+                finish=time_data.get("finish"),
+                update=time_data.get("update"),
+                expiration=time_data.get("expiration"),
+                left=time_data.get("left"),
+            ),
+            from_side=OrderSide(
+                code=from_data.get("code", ""),
+                network=from_data.get("network", ""),
+                coin=from_data.get("coin", ""),
+                amount=str(from_data.get("amount", "")),
+                address=from_data.get("address"),
+                extra_id=from_data.get("extraId"),
+                tx=from_tx,
+            ),
+            to_side=OrderSide(
+                code=to_data.get("code", ""),
+                network=to_data.get("network", ""),
+                coin=to_data.get("coin", ""),
+                amount=str(to_data.get("amount", "")),
+                address=to_data.get("address"),
+                extra_id=to_data.get("extraId"),
+                tx=to_tx,
+            ),
+            token=data.get("token", ""),
+            email=data.get("email"),
+        )

fixedfloat/errors.py

@@ -0,0 +1,23 @@
+"""Error classes for the FixedFloat API client."""
+
+from typing import Any
+
+
+class FixedFloatError(Exception):
+    """Exception raised when a FixedFloat API request fails or returns an error."""
+
+    def __init__(
+        self,
+        message: str,
+        code: int = -1,
+        data: Any | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.data = data
+
+    def __str__(self) -> str:
+        if self.code != -1:
+            return f"[{self.code}] {self.message}"
+        return self.message

fixedfloat/types.py

@@ -0,0 +1,105 @@
+"""Data models and type definitions for FixedFloat API."""
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+OrderType = Literal["fixed", "float"]
+ExchangeDirection = Literal["from", "to"]
+EmergencyChoice = Literal["EXCHANGE", "REFUND"]
+
+
+@dataclass
+class Currency:
+    """Represents a cryptocurrency supported by FixedFloat."""
+
+    code: str
+    coin: str
+    network: str
+    name: str
+    recv: int
+    send: int
+    tag: str | None = None
+    logo: str = ""
+    color: str = ""
+    priority: int = 0
+
+
+@dataclass
+class PriceSide:
+    """Details of one side (from or to) in a price quote."""
+
+    code: str
+    network: str
+    coin: str
+    amount: str
+    rate: str
+    min: str
+    max: str
+
+
+@dataclass
+class PriceResult:
+    """Calculated exchange price result."""
+
+    from_side: PriceSide
+    to_side: PriceSide
+    errors: list[str] | None = None
+
+
+@dataclass
+class OrderTx:
+    """Transaction details for an order deposit or payout."""
+
+    id: str | None = None
+    amount: str | None = None
+    fee: str | None = None
+    ccyfee: str | None = None
+    time_reg: int | None = None
+    confirmations: int | None = None
+
+
+@dataclass
+class OrderSide:
+    """Deposit or receive side information in an order."""
+
+    code: str
+    network: str
+    coin: str
+    amount: str
+    address: str | None = None
+    extra_id: str | None = None
+    tx: OrderTx | None = None
+
+
+@dataclass
+class OrderTime:
+    """Timestamps associated with an order."""
+
+    reg: int
+    start: int | None = None
+    finish: int | None = None
+    update: int | None = None
+    expiration: int | None = None
+    left: int | None = None
+
+
+@dataclass
+class Order:
+    """Exchange order details."""
+
+    id: str
+    type: str
+    status: str
+    time: OrderTime
+    from_side: OrderSide
+    to_side: OrderSide
+    token: str
+    email: str | None = None
+
+
+@dataclass
+class QrResult:
+    """QR code result for deposit address."""
+
+    src: str
+    raw: dict[str, Any] | None = None

fixedfloat_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.5
+Name: fixedfloat-client
+Version: 0.1.0
+Summary: Python client for the FixedFloat cryptocurrency exchange API v2
+Project-URL: Repository, https://github.com/TysikGG/api-kit
+Project-URL: Documentation, https://fixedfloat.com/api
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# fixedfloat-client
+
+[![PyPI version](https://img.shields.io/pypi/v/fixedfloat-client.svg)](https://pypi.org/project/fixedfloat-client/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/pypi/pyversions/fixedfloat-client.svg)](https://pypi.org/project/fixedfloat-client/)
+
+Modern, fully typed Python client library for the [FixedFloat](https://fixedfloat.com/api) cryptocurrency exchange REST API v2.
+
+Official API documentation: <https://fixedfloat.com/api>
+
+---
+
+## Features
+
+- ⚡ **Fixed & Float Exchange Rates** — Choose between guaranteed fixed rates (1% fee) and floating market rates (0.5% fee).
+- 🔐 **Automatic Request Signing** — Cryptographic HMAC-SHA256 signature generation (`X-API-KEY` & `X-API-SIGN`) built-in.
+- 🪙 **Multi-Currency Support** — Trade Bitcoin, Ethereum, USDT, Solana, Monero, and dozens of other coins across multiple blockchains.
+- 🐍 **Modern Pythonic Design** — Type annotations, dataclass models (`Order`, `PriceResult`, `Currency`), context manager support (`with FixedFloat(...) as client:`), and custom exceptions.
+- 🚨 **Emergency Handling** — Support for emergency resolution actions (`EXCHANGE` or `REFUND`) on interrupted orders.
+
+---
+
+## Installation
+
+```bash
+pip install fixedfloat-client
+```
+
+Requires Python 3.10 or higher.
+
+---
+
+## Quick Start (Safe Check)
+
+The quick check only inspects supported currencies and price quotes. It does not create orders or spend funds:
+
+```python
+import os
+from fixedfloat import FixedFloat
+
+with FixedFloat(
+    api_key=os.environ.get("FIXEDFLOAT_API_KEY"),
+    api_secret=os.environ.get("FIXEDFLOAT_API_SECRET"),
+) as client:
+    # 1. Fetch available currencies
+    currencies = client.get_currencies()
+    print(f"Available currencies: {len(currencies)}")
+
+    # 2. Query price calculation for 0.1 BTC to ETH
+    price = client.get_price(
+        from_ccy="BTC",
+        to_ccy="ETH",
+        amount=0.1,
+        direction="from",
+        order_type="float",
+    )
+    print(f"0.1 BTC -> {price.to_side.amount} ETH (Rate: {price.to_side.rate})")
+```
+
+---
+
+## Usage Guide
+
+### 1. Creating a Floating Rate Order
+
+Create an exchange order with a floating rate, deposit instructions, and receive destination address:
+
+```python
+from fixedfloat import FixedFloat, FixedFloatError
+
+with FixedFloat(
+    api_key="your_api_key",
+    api_secret="your_api_secret",
+) as client:
+    # Create float order
+    order = client.create_order(
+        from_ccy="BTC",
+        to_ccy="ETH",
+        amount=0.1,
+        direction="from",
+        order_type="float",
+        to_address="0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+        refund_address="bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",  # optional
+    )
+
+    print(f"Order Created! ID: {order.id}")
+    print(f"Security Token: {order.token}")
+    print(f"Send BTC to: {order.from_side.address}")
+    print(f"Order Status: {order.status}")
+```
+
+### 2. Creating a Fixed Rate Order
+
+Lock in a guaranteed rate for 10 minutes:
+
+```python
+fixed_order = client.create_order(
+    from_ccy="ETH",
+    to_ccy="BTC",
+    amount=2.5,
+    direction="from",
+    order_type="fixed",
+    to_address="bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
+)
+
+print(f"Fixed Order ID: {fixed_order.id}")
+print(f"Expected Payout: {fixed_order.to_side.amount} BTC")
+print(f"Send ETH to: {fixed_order.from_side.address}")
+```
+
+### 3. Tracking Order Status & QR Codes
+
+Check order execution, transaction confirmations, and fetch QR codes:
+
+```python
+# Query status using order ID and secret token
+current = client.get_order(order.id, order.token)
+print(f"Status: {current.status}")
+
+if current.from_side.tx:
+    print(f"Deposit confirmations: {current.from_side.tx.confirmations}")
+
+# Fetch QR code for deposit address
+qr = client.get_qr(order.id, order.token)
+print(f"Deposit QR code: {qr.src}")
+
+# Attach email address for status notifications
+client.set_email(order.id, order.token, "user@example.com")
+```
+
+### 4. Setting Emergency Action Choice
+
+If an order requires user decision (e.g. rate shifted or deposit was delayed):
+
+```python
+# Choose to execute exchange at current market rate or refund
+client.set_emergency(
+    id=order.id,
+    token=order.token,
+    choice="REFUND",
+    address="bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh",
+)
+print("Emergency action submitted.")
+```
+
+---
+
+## API Reference
+
+### `FixedFloat` Class
+
+#### Constructor
+
+```python
+FixedFloat(
+    api_key: Optional[str] = None,
+    api_secret: Optional[str] = None,
+    base_url: str = "https://ff.io/api/v2",
+    timeout: float = 15.0,
+)
+```
+
+| Parameter | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `api_key` | `str` | `None` | Your FixedFloat API key. |
+| `api_secret` | `str` | `None` | Your FixedFloat API secret for HMAC signatures. |
+| `base_url` | `str` | `"https://ff.io/api/v2"` | FixedFloat API v2 base URL. |
+| `timeout` | `float` | `15.0` | HTTP request timeout in seconds. |
+
+#### Methods
+
+- **`get_currencies() -> list[Currency]`** — Retrieves all supported cryptocurrencies and networks.
+- **`get_price(from_ccy, to_ccy, amount, direction="from", order_type="float", ...) -> PriceResult`** — Price estimates, rates, limits.
+- **`create_order(from_ccy, to_ccy, amount, to_address, direction="from", order_type="float", ...) -> Order`** — Creates a new order.
+- **`get_order(id: str, token: str) -> Order`** — Retrieves order status and transaction info.
+- **`set_emergency(id, token, choice, address=None, extra_id=None) -> Any`** — Sets emergency choice (`EXCHANGE` or `REFUND`).
+- **`set_email(id, token, email) -> Any`** — Sets email address for order notifications.
+- **`get_qr(id, token) -> QrResult`** — Retrieves deposit address QR code.
+
+---
+
+## Error Handling
+
+When the FixedFloat API returns an error or non-zero status code, a `FixedFloatError` is raised:
+
+```python
+from fixedfloat import FixedFloat, FixedFloatError
+
+try:
+    with FixedFloat() as client:
+        client.get_order("INVALID_ID", "INVALID_TOKEN")
+except FixedFloatError as exc:
+    print(f"FixedFloat Error: {exc.message} (Code: {exc.code})")
+```
+
+Common error codes:
+- `101` — Invalid currency pair or amount out of limits.
+- `102` — Missing required parameter.
+- `103` — Invalid destination wallet address.
+- `401` — Unauthorized: invalid API key or signature.
+
+---
+
+## License
+
+MIT

fixedfloat_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fixedfloat/__init__.py,sha256=N-nAMM1CAtsohYLgX8rslmW5J0RIVhCh3GWOfuxBRjY,595
+fixedfloat/client.py,sha256=xAwxtdaPjP5jRWrx_yZQYPnnkEQV-FSkBakRvIXxn8E,14098
+fixedfloat/errors.py,sha256=MDj4cetK4NxMTRu40FvjYS2jqWJutl7mVOY6knZlPw4,575
+fixedfloat/types.py,sha256=wk292fZi9WtU7mDaUe5Ef6Qs8jET36H5lBAG7CN2uXY,1978
+fixedfloat_client-0.1.0.dist-info/METADATA,sha256=B-wdh7JyKMClYFYjTh9EXOdvJtuO-zD5yDr2mQoXwkM,6771
+fixedfloat_client-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+fixedfloat_client-0.1.0.dist-info/licenses/LICENSE,sha256=Vt9n-kHPUZpG7YZvx_-tz0yY6f8_FTZX1vrAHY4kevA,1064
+fixedfloat_client-0.1.0.dist-info/RECORD,,

fixedfloat_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fixedfloat_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TysikGG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.