cryptopay-python-sdk 0.1.1__tar.gz

cryptopay_python_sdk-0.1.1/.gitignore

@@ -0,0 +1,29 @@
+# Virtual environments
+venv/
+.venv/
+env/
+
+# Build / distribution
+dist/
+build/
+*.egg-info/
+
+# Python cache
+__pycache__/
+*.py[cod]
+
+# Test / personal scripts
+TEST.py
+
+# Tools
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+
+# IDE
+.idea/
+.vscode/
+
+# Misc
+.env
+*.log

cryptopay_python_sdk-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

cryptopay_python_sdk-0.1.1/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: cryptopay-python-sdk
+Version: 0.1.1
+Summary: Sync + Async Python client for Telegram Crypto Pay API (Crypto Bot)
+Project-URL: Homepage, https://github.com/medovi40k/crypto-pay-api
+Project-URL: Repository, https://github.com/medovi40k/crypto-pay-api
+Project-URL: Issues, https://github.com/medovi40k/crypto-pay-api/issues
+Author: medovi40k
+License: MIT License
+        
+        Copyright (c) 2026
+        
+        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.
+License-File: LICENSE
+Keywords: api,asyncio,crypto,cryptopay,httpx,requests,telegram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: types-requests>=2.31; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# crypto-pay-api
+
+[![PyPI](https://img.shields.io/pypi/v/crypto-pay-api)](https://pypi.org/project/crypto-pay-api/)
+[![Python](https://img.shields.io/pypi/pyversions/crypto-pay-api)](https://pypi.org/project/crypto-pay-api/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Sync + async Python client for the [Telegram Crypto Pay API](https://help.send.tg/en/articles/10279948-crypto-pay-api).
+
+## Install
+
+```bash
+pip install crypto-pay-api
+```
+
+## Quick start
+
+**Async** (recommended)
+
+```python
+import asyncio
+from crypto_pay_api import CryptoPayAsync, CryptoPayConfig
+
+async def main():
+    cfg = CryptoPayConfig(token="YOUR_TOKEN")
+    async with CryptoPayAsync(cfg) as cp:
+        invoice = await cp.create_invoice(asset="USDT", amount=5)
+        print(invoice["pay_url"])
+
+asyncio.run(main())
+```
+
+**Sync**
+
+```python
+from crypto_pay_api import CryptoPay, CryptoPayConfig
+
+cfg = CryptoPayConfig(token="YOUR_TOKEN")
+with CryptoPay(cfg) as cp:
+    invoice = cp.create_invoice(asset="USDT", amount=5)
+    print(invoice["pay_url"])
+```
+
+## Configuration
+
+```python
+CryptoPayConfig(
+    token="YOUR_TOKEN",
+    network="mainnet",       # or "testnet"
+    timeout=20.0,
+    base_url_override=None,  # override API base URL if needed
+)
+```
+
+## Methods
+
+| Method | Description |
+|---|---|
+| `get_me()` | App info |
+| `create_invoice(...)` | Create a payment invoice |
+| `delete_invoice(invoice_id)` | Delete invoice |
+| `get_invoices(...)` | List invoices |
+| `create_check(...)` | Create a check |
+| `delete_check(check_id)` | Delete check |
+| `get_checks(...)` | List checks |
+| `transfer(...)` | Send coins to a Telegram user |
+| `get_transfers(...)` | List transfers |
+| `get_balance()` | App balance |
+| `get_exchange_rates()` | Current exchange rates |
+| `get_currencies()` | Supported currencies |
+| `get_stats(...)` | App statistics |
+
+## Webhook verification
+
+```python
+from crypto_pay_api import verify_webhook_signature
+
+ok = verify_webhook_signature(
+    token="YOUR_TOKEN",
+    raw_body=request.body,          # raw bytes
+    signature_header=request.headers["crypto-pay-api-signature"],
+)
+```
+
+## Error handling
+
+```python
+from crypto_pay_api import CryptoPayAPIError, CryptoPayHTTPError
+
+try:
+    invoice = cp.create_invoice(asset="USDT", amount=5)
+except CryptoPayAPIError as e:
+    print(e.error_code, e.raw)   # API-level error (ok=false)
+except CryptoPayHTTPError as e:
+    print(e)                     # network / HTTP error
+```
+
+## License
+
+MIT

cryptopay_python_sdk-0.1.1/README.md

@@ -0,0 +1,99 @@
+# crypto-pay-api
+
+[![PyPI](https://img.shields.io/pypi/v/crypto-pay-api)](https://pypi.org/project/crypto-pay-api/)
+[![Python](https://img.shields.io/pypi/pyversions/crypto-pay-api)](https://pypi.org/project/crypto-pay-api/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Sync + async Python client for the [Telegram Crypto Pay API](https://help.send.tg/en/articles/10279948-crypto-pay-api).
+
+## Install
+
+```bash
+pip install crypto-pay-api
+```
+
+## Quick start
+
+**Async** (recommended)
+
+```python
+import asyncio
+from crypto_pay_api import CryptoPayAsync, CryptoPayConfig
+
+async def main():
+    cfg = CryptoPayConfig(token="YOUR_TOKEN")
+    async with CryptoPayAsync(cfg) as cp:
+        invoice = await cp.create_invoice(asset="USDT", amount=5)
+        print(invoice["pay_url"])
+
+asyncio.run(main())
+```
+
+**Sync**
+
+```python
+from crypto_pay_api import CryptoPay, CryptoPayConfig
+
+cfg = CryptoPayConfig(token="YOUR_TOKEN")
+with CryptoPay(cfg) as cp:
+    invoice = cp.create_invoice(asset="USDT", amount=5)
+    print(invoice["pay_url"])
+```
+
+## Configuration
+
+```python
+CryptoPayConfig(
+    token="YOUR_TOKEN",
+    network="mainnet",       # or "testnet"
+    timeout=20.0,
+    base_url_override=None,  # override API base URL if needed
+)
+```
+
+## Methods
+
+| Method | Description |
+|---|---|
+| `get_me()` | App info |
+| `create_invoice(...)` | Create a payment invoice |
+| `delete_invoice(invoice_id)` | Delete invoice |
+| `get_invoices(...)` | List invoices |
+| `create_check(...)` | Create a check |
+| `delete_check(check_id)` | Delete check |
+| `get_checks(...)` | List checks |
+| `transfer(...)` | Send coins to a Telegram user |
+| `get_transfers(...)` | List transfers |
+| `get_balance()` | App balance |
+| `get_exchange_rates()` | Current exchange rates |
+| `get_currencies()` | Supported currencies |
+| `get_stats(...)` | App statistics |
+
+## Webhook verification
+
+```python
+from crypto_pay_api import verify_webhook_signature
+
+ok = verify_webhook_signature(
+    token="YOUR_TOKEN",
+    raw_body=request.body,          # raw bytes
+    signature_header=request.headers["crypto-pay-api-signature"],
+)
+```
+
+## Error handling
+
+```python
+from crypto_pay_api import CryptoPayAPIError, CryptoPayHTTPError
+
+try:
+    invoice = cp.create_invoice(asset="USDT", amount=5)
+except CryptoPayAPIError as e:
+    print(e.error_code, e.raw)   # API-level error (ok=false)
+except CryptoPayHTTPError as e:
+    print(e)                     # network / HTTP error
+```
+
+## License
+
+MIT

cryptopay_python_sdk-0.1.1/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling>=1.22"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cryptopay-python-sdk"
+version = "0.1.1"
+description = "Sync + Async Python client for Telegram Crypto Pay API (Crypto Bot)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [{ name = "medovi40k" }]
+keywords = ["telegram", "crypto", "cryptopay", "api", "asyncio", "httpx", "requests"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Typing :: Typed",
+]
+
+dependencies = [
+  "httpx>=0.24",
+  "requests>=2.31",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.4",
+  "pytest-asyncio>=0.23",
+  "ruff>=0.4",
+  "mypy>=1.8",
+  "types-requests>=2.31",
+]
+
+[project.urls]
+Homepage = "https://github.com/medovi40k/crypto-pay-api"
+Repository = "https://github.com/medovi40k/crypto-pay-api"
+Issues = "https://github.com/medovi40k/crypto-pay-api/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/crypto_pay_api"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_ignores = true
+disallow_untyped_defs = false
+no_implicit_optional = true
+strict_optional = true

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/__init__.py

@@ -0,0 +1,16 @@
+from .config import CryptoPayConfig
+from .errors import CryptoPayError, CryptoPayAPIError, CryptoPayHTTPError
+from .sync import CryptoPay
+from .async_ import CryptoPayAsync
+from .utils import verify_webhook_signature, canonical_json_bytes
+
+__all__ = [
+    "CryptoPayConfig",
+    "CryptoPayError",
+    "CryptoPayAPIError",
+    "CryptoPayHTTPError",
+    "CryptoPay",
+    "CryptoPayAsync",
+    "verify_webhook_signature",
+    "canonical_json_bytes",
+]

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/_core.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .config import CryptoPayConfig
+from .errors import CryptoPayAPIError, CryptoPayHTTPError
+
+
+def resolve_root(cfg: CryptoPayConfig) -> str:
+    if cfg.base_url_override:
+        return cfg.base_url_override.rstrip("/")
+    return "https://pay.crypt.bot" if cfg.network == "mainnet" else "https://testnet-pay.crypt.bot"
+
+
+def clean_params(params: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if not params:
+        return {}
+    return {k: v for k, v in params.items() if v is not None}
+
+
+def parse_api_response(data: Any) -> Any:
+    if not isinstance(data, dict) or "ok" not in data:
+        raise CryptoPayHTTPError(f"Unexpected response: {data!r}")
+
+    if data.get("ok") is True:
+        return data.get("result")
+
+    raise CryptoPayAPIError(str(data.get("error", "UNKNOWN_ERROR")), raw=data)

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/async_.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union, Literal
+
+import httpx
+
+from .config import CryptoPayConfig
+from .errors import CryptoPayHTTPError
+from ._core import resolve_root, clean_params, parse_api_response
+
+
+class CryptoPayAsync:
+    """
+    Async client for Crypto Pay API.
+    """
+
+    def __init__(self, config: CryptoPayConfig, *, client: Optional[httpx.AsyncClient] = None):
+        self.config = config
+        self._client_external = client is not None
+        self._client = client
+        self._root = resolve_root(config)
+
+    async def __aenter__(self) -> "CryptoPayAsync":
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                base_url=self._root,
+                timeout=self.config.timeout,
+                headers={
+                    "Crypto-Pay-API-Token": self.config.token,
+                    "User-Agent": self.config.user_agent,
+                },
+            )
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        if self._client and not self._client_external:
+            await self._client.aclose()
+        self._client = None
+
+    async def _request(self, method_name: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        if self._client is None:
+            async with self:
+                return await self._request(method_name, params=params)
+
+        url = f"/api/{method_name}"
+        payload = clean_params(params)
+
+        try:
+            if payload:
+                resp = await self._client.post(url, json=payload)
+            else:
+                resp = await self._client.get(url)
+        except httpx.HTTPError as e:
+            raise CryptoPayHTTPError(str(e)) from e
+
+        if resp.status_code >= 400:
+            raise CryptoPayHTTPError(f"HTTP {resp.status_code}: {resp.text}")
+
+        return parse_api_response(resp.json())
+
+    # -------- API methods --------
+
+    async def get_me(self) -> Dict[str, Any]:
+        return await self._request("getMe")
+
+    async def create_invoice(
+        self,
+        *,
+        amount: Union[str, float],
+        currency_type: Optional[Literal["crypto", "fiat"]] = None,
+        asset: Optional[str] = None,
+        fiat: Optional[str] = None,
+        accepted_assets: Optional[str] = None,
+        swap_to: Optional[str] = None,
+        description: Optional[str] = None,
+        hidden_message: Optional[str] = None,
+        paid_btn_name: Optional[str] = None,
+        paid_btn_url: Optional[str] = None,
+        payload: Optional[str] = None,
+        allow_comments: Optional[bool] = None,
+        allow_anonymous: Optional[bool] = None,
+        expires_in: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return await self._request(
+            "createInvoice",
+            {
+                "currency_type": currency_type,
+                "asset": asset,
+                "fiat": fiat,
+                "accepted_assets": accepted_assets,
+                "amount": str(amount),
+                "swap_to": swap_to,
+                "description": description,
+                "hidden_message": hidden_message,
+                "paid_btn_name": paid_btn_name,
+                "paid_btn_url": paid_btn_url,
+                "payload": payload,
+                "allow_comments": allow_comments,
+                "allow_anonymous": allow_anonymous,
+                "expires_in": expires_in,
+            },
+        )
+
+    async def delete_invoice(self, invoice_id: int) -> bool:
+        return await self._request("deleteInvoice", {"invoice_id": invoice_id})
+
+    async def get_invoices(
+        self,
+        *,
+        asset: Optional[str] = None,
+        fiat: Optional[str] = None,
+        invoice_ids: Optional[Union[str, List[int]]] = None,
+        status: Optional[Literal["active", "paid"]] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(invoice_ids, list):
+            invoice_ids = ",".join(str(i) for i in invoice_ids)
+        return await self._request(
+            "getInvoices",
+            {
+                "asset": asset,
+                "fiat": fiat,
+                "invoice_ids": invoice_ids,
+                "status": status,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    async def create_check(
+        self,
+        *,
+        asset: str,
+        amount: Union[str, float],
+        pin_to_user_id: Optional[int] = None,
+        pin_to_username: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return await self._request(
+            "createCheck",
+            {
+                "asset": asset,
+                "amount": str(amount),
+                "pin_to_user_id": pin_to_user_id,
+                "pin_to_username": pin_to_username,
+            },
+        )
+
+    async def delete_check(self, check_id: int) -> bool:
+        return await self._request("deleteCheck", {"check_id": check_id})
+
+    async def get_checks(
+        self,
+        *,
+        asset: Optional[str] = None,
+        check_ids: Optional[Union[str, List[int]]] = None,
+        status: Optional[Literal["active", "activated"]] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(check_ids, list):
+            check_ids = ",".join(str(i) for i in check_ids)
+        return await self._request(
+            "getChecks",
+            {
+                "asset": asset,
+                "check_ids": check_ids,
+                "status": status,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    async def transfer(
+        self,
+        *,
+        user_id: int,
+        asset: str,
+        amount: Union[str, float],
+        spend_id: str,
+        comment: Optional[str] = None,
+        disable_send_notification: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        return await self._request(
+            "transfer",
+            {
+                "user_id": user_id,
+                "asset": asset,
+                "amount": str(amount),
+                "spend_id": spend_id,
+                "comment": comment,
+                "disable_send_notification": disable_send_notification,
+            },
+        )
+
+    async def get_transfers(
+        self,
+        *,
+        asset: Optional[str] = None,
+        transfer_ids: Optional[Union[str, List[int]]] = None,
+        spend_id: Optional[str] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(transfer_ids, list):
+            transfer_ids = ",".join(str(i) for i in transfer_ids)
+        return await self._request(
+            "getTransfers",
+            {
+                "asset": asset,
+                "transfer_ids": transfer_ids,
+                "spend_id": spend_id,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    async def get_balance(self) -> List[Dict[str, Any]]:
+        return await self._request("getBalance")
+
+    async def get_exchange_rates(self) -> List[Dict[str, Any]]:
+        return await self._request("getExchangeRates")
+
+    async def get_currencies(self) -> Dict[str, Any]:
+        return await self._request("getCurrencies")
+
+    async def get_stats(self, *, start_at: Optional[str] = None, end_at: Optional[str] = None) -> Dict[str, Any]:
+        return await self._request("getStats", {"start_at": start_at, "end_at": end_at})

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/config.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+
+MainnetOrTestnet = Literal["mainnet", "testnet"]
+
+
+@dataclass(frozen=True)
+class CryptoPayConfig:
+    token: str
+    network: MainnetOrTestnet = "mainnet"
+    timeout: float = 20.0
+    base_url_override: Optional[str] = None  # e.g. "https://pay.crypt.bot"
+    user_agent: str = "crypto-pay-api/0.1.1"

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/errors.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+
+class CryptoPayError(Exception):
+    """Base error for Crypto Pay clients."""
+
+
+class CryptoPayAPIError(CryptoPayError):
+    """Raised when API returns ok=false."""
+
+    def __init__(self, error_code: str, raw: Optional[Dict[str, Any]] = None):
+        super().__init__(error_code)
+        self.error_code = error_code
+        self.raw = raw or {}
+
+
+class CryptoPayHTTPError(CryptoPayError):
+    """Raised on network / HTTP errors."""

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/sync.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union, Literal
+
+import requests
+from requests import Response
+
+from .config import CryptoPayConfig
+from .errors import CryptoPayHTTPError
+from ._core import resolve_root, clean_params, parse_api_response
+
+
+class CryptoPay:
+    """
+    Sync client for Crypto Pay API.
+    """
+
+    def __init__(self, config: CryptoPayConfig, *, session: Optional[requests.Session] = None):
+        self.config = config
+        self._session_external = session is not None
+        self._session = session or requests.Session()
+
+        self._root = resolve_root(config)
+        self._session.headers.update(
+            {
+                "Crypto-Pay-API-Token": self.config.token,
+                "User-Agent": self.config.user_agent,
+            }
+        )
+
+    def close(self) -> None:
+        if not self._session_external:
+            self._session.close()
+
+    def __enter__(self) -> "CryptoPay":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+    def _raise_for_http(self, resp: Response) -> None:
+        if resp.status_code >= 400:
+            raise CryptoPayHTTPError(f"HTTP {resp.status_code}: {resp.text}")
+
+    def _request(self, method_name: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        url = f"{self._root}/api/{method_name}"
+        payload = clean_params(params)
+        try:
+            if payload:
+                resp = self._session.post(url, json=payload, timeout=self.config.timeout)
+            else:
+                resp = self._session.get(url, timeout=self.config.timeout)
+        except requests.RequestException as e:
+            raise CryptoPayHTTPError(str(e)) from e
+
+        self._raise_for_http(resp)
+        return parse_api_response(resp.json())
+
+    # -------- API methods --------
+
+    def get_me(self) -> Dict[str, Any]:
+        return self._request("getMe")
+
+    def create_invoice(
+        self,
+        *,
+        amount: Union[str, float],
+        currency_type: Optional[Literal["crypto", "fiat"]] = None,
+        asset: Optional[str] = None,
+        fiat: Optional[str] = None,
+        accepted_assets: Optional[str] = None,
+        swap_to: Optional[str] = None,
+        description: Optional[str] = None,
+        hidden_message: Optional[str] = None,
+        paid_btn_name: Optional[str] = None,
+        paid_btn_url: Optional[str] = None,
+        payload: Optional[str] = None,
+        allow_comments: Optional[bool] = None,
+        allow_anonymous: Optional[bool] = None,
+        expires_in: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._request(
+            "createInvoice",
+            {
+                "currency_type": currency_type,
+                "asset": asset,
+                "fiat": fiat,
+                "accepted_assets": accepted_assets,
+                "amount": str(amount),
+                "swap_to": swap_to,
+                "description": description,
+                "hidden_message": hidden_message,
+                "paid_btn_name": paid_btn_name,
+                "paid_btn_url": paid_btn_url,
+                "payload": payload,
+                "allow_comments": allow_comments,
+                "allow_anonymous": allow_anonymous,
+                "expires_in": expires_in,
+            },
+        )
+
+    def delete_invoice(self, invoice_id: int) -> bool:
+        return self._request("deleteInvoice", {"invoice_id": invoice_id})
+
+    def get_invoices(
+        self,
+        *,
+        asset: Optional[str] = None,
+        fiat: Optional[str] = None,
+        invoice_ids: Optional[Union[str, List[int]]] = None,
+        status: Optional[Literal["active", "paid"]] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(invoice_ids, list):
+            invoice_ids = ",".join(str(i) for i in invoice_ids)
+        return self._request(
+            "getInvoices",
+            {
+                "asset": asset,
+                "fiat": fiat,
+                "invoice_ids": invoice_ids,
+                "status": status,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    def create_check(
+        self,
+        *,
+        asset: str,
+        amount: Union[str, float],
+        pin_to_user_id: Optional[int] = None,
+        pin_to_username: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return self._request(
+            "createCheck",
+            {
+                "asset": asset,
+                "amount": str(amount),
+                "pin_to_user_id": pin_to_user_id,
+                "pin_to_username": pin_to_username,
+            },
+        )
+
+    def delete_check(self, check_id: int) -> bool:
+        return self._request("deleteCheck", {"check_id": check_id})
+
+    def get_checks(
+        self,
+        *,
+        asset: Optional[str] = None,
+        check_ids: Optional[Union[str, List[int]]] = None,
+        status: Optional[Literal["active", "activated"]] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(check_ids, list):
+            check_ids = ",".join(str(i) for i in check_ids)
+        return self._request(
+            "getChecks",
+            {
+                "asset": asset,
+                "check_ids": check_ids,
+                "status": status,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    def transfer(
+        self,
+        *,
+        user_id: int,
+        asset: str,
+        amount: Union[str, float],
+        spend_id: str,
+        comment: Optional[str] = None,
+        disable_send_notification: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        return self._request(
+            "transfer",
+            {
+                "user_id": user_id,
+                "asset": asset,
+                "amount": str(amount),
+                "spend_id": spend_id,
+                "comment": comment,
+                "disable_send_notification": disable_send_notification,
+            },
+        )
+
+    def get_transfers(
+        self,
+        *,
+        asset: Optional[str] = None,
+        transfer_ids: Optional[Union[str, List[int]]] = None,
+        spend_id: Optional[str] = None,
+        offset: Optional[int] = None,
+        count: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        if isinstance(transfer_ids, list):
+            transfer_ids = ",".join(str(i) for i in transfer_ids)
+        return self._request(
+            "getTransfers",
+            {
+                "asset": asset,
+                "transfer_ids": transfer_ids,
+                "spend_id": spend_id,
+                "offset": offset,
+                "count": count,
+            },
+        )
+
+    def get_balance(self) -> List[Dict[str, Any]]:
+        return self._request("getBalance")
+
+    def get_exchange_rates(self) -> List[Dict[str, Any]]:
+        return self._request("getExchangeRates")
+
+    def get_currencies(self) -> Dict[str, Any]:
+        return self._request("getCurrencies")
+
+    def get_stats(self, *, start_at: Optional[str] = None, end_at: Optional[str] = None) -> Dict[str, Any]:
+        return self._request("getStats", {"start_at": start_at, "end_at": end_at})

cryptopay_python_sdk-0.1.1/src/crypto_pay_api/utils.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+from typing import Any, Union
+
+
+def verify_webhook_signature(*, token: str, raw_body: Union[bytes, str], signature_header: str) -> bool:
+    """
+    Verify webhook update signature.
+
+    Rule (from docs): compare header `crypto-pay-api-signature` with HMAC-SHA256(body),
+    where key = SHA256(app_token). Body is the *entire raw request body*.
+    """
+    raw = raw_body.encode("utf-8") if isinstance(raw_body, str) else raw_body
+    secret = hashlib.sha256(token.encode("utf-8")).digest()
+    digest_hex = hmac.new(secret, raw, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(digest_hex, signature_header)
+
+
+def canonical_json_bytes(obj: Any) -> bytes:
+    """
+    If your framework lost raw body bytes, serialize deterministically:
+    compact JSON without spaces.
+    """
+    return json.dumps(obj, separators=(",", ":"), ensure_ascii=False).encode("utf-8")