pyXRocketAPI 0.3.0__tar.gz → 1.0.0__tar.gz

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyXRocketAPI
-Version: 0.3.0
+Version: 1.0.0
 Summary: Python client for the xRocket Pay API
 Author: Badiboy
 License-Expression: MIT
@@ -8,10 +8,9 @@ Project-URL: Homepage, https://github.com/Badiboy/pyXRocketAPI
 Project-URL: Documentation, https://docs.xrocket.exchange/api/pay/pay-api-overview
 Project-URL: Repository, https://github.com/Badiboy/pyXRocketAPI
 Keywords: xrocket,pay,crypto,payments,api
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.28

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyXRocketAPI/api.py

@@ -4,7 +4,7 @@ from typing import Any
 import requests
 
 from .exceptions import xRocketAPIException
-from .models import App, Balance, Cheque, ChequeCallback, ChequeUrl, ChequesList, Currency, Health, Invoice, InvoiceCallback, InvoiceCustomer, InvoicePaymentAddress, InvoicePaymentsList, InvoiceUrl, InvoicesList, MassPayout, MassPayouts, Payout, PayoutCallback, PayoutsList, Rate, Withdrawal, WithdrawalCallback, WithdrawalLink, WithdrawalQuotas, WithdrawalsList, xPage, xRocketObject
+from .models import App, Balance, Cheque, ChequeCallback, ChequeUrl, ChequesList, Currency, Health, Invoice, InvoiceCallback, InvoiceCustomer, InvoicePaymentAddress, InvoicePaymentsList, InvoiceUrl, InvoicesList, MassPayout, MassPayouts, Payout, PayoutCallback, PayoutsList, Rate, Swap, SwapAsset, SwapEstimate, SwapRoute, SwapsList, Withdrawal, WithdrawalCallback, WithdrawalLink, WithdrawalQuotas, WithdrawalsList, xPage, xRocketObject
 
 PRODUCTION_API_URL = "https://pay.api.xrocket.exchange"
 TESTNET_API_URL = "https://pay.api.testnet.xrocket.exchange"
@@ -57,6 +57,18 @@ class xRocketPayAPI:
             raise TypeError("{} must be a string or number, not bool.".format(parameter_name))
         return str(value)
 
+    @staticmethod
+    def __swap_amount_mode(
+        amount: str | int | float | None, receive_amount: str | int | float | None
+    ) -> dict[str, str]:
+        """Validate and serialize one exact-in or exact-out swap amount."""
+        if (amount is None) == (receive_amount is None):
+            raise ValueError("Specify exactly one of amount or receive_amount.")
+        return xRocketPayAPI.__without_none(
+            amount=xRocketPayAPI.__number_as_string(amount, "amount"),
+            receiveAmount=xRocketPayAPI.__number_as_string(receive_amount, "receive_amount"),
+        )
+
     def __init__(
         self,
         token: str | None = None,
@@ -190,6 +202,110 @@ class xRocketPayAPI:
         )
         return [Rate.de_json(item) for item in data]
 
+    def create_swap(
+        self, from_asset: str, to_asset: str, client_order_id: str,
+        amount: str | int | float | None = None, receive_amount: str | int | float | None = None,
+    ) -> Swap:
+        """Create swap.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-create-swap
+
+        :param from_asset: Asset to swap from.
+        :param to_asset: Asset to swap to.
+        :param client_order_id: Merchant-provided idempotency key. Re-using a
+            value returns a conflict.
+        :param amount: Exact-in amount: how much of ``from_asset`` to spend.
+            Provide exactly one of ``amount`` or ``receive_amount``. A numeric
+            value is encoded as an API string.
+        :param receive_amount: Exact-out amount: how much of ``to_asset`` to
+            receive. Provide exactly one of ``amount`` or ``receive_amount``.
+            A numeric value is encoded as an API string.
+        :return: ``Swap``.
+        """
+        body = {"fromAsset": from_asset, "toAsset": to_asset, "clientOrderId": client_order_id}
+        body.update(self.__swap_amount_mode(amount, receive_amount))
+        return Swap.de_json(self._request("POST", "/api/v1/swap", body=body))
+
+    def estimate_swap(
+        self, from_asset: str, to_asset: str,
+        amount: str | int | float | None = None, receive_amount: str | int | float | None = None,
+    ) -> SwapEstimate:
+        """Estimate swap amounts and rate without creating it.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-estimate
+
+        :param from_asset: Asset to swap from.
+        :param to_asset: Asset to swap to.
+        :param amount: Exact-in amount: how much of ``from_asset`` to spend.
+            Provide exactly one of ``amount`` or ``receive_amount``. A numeric
+            value is encoded as an API string.
+        :param receive_amount: Exact-out amount: how much of ``to_asset`` to
+            receive. Provide exactly one of ``amount`` or ``receive_amount``.
+            A numeric value is encoded as an API string.
+        :return: ``SwapEstimate``.
+        """
+        body = {"fromAsset": from_asset, "toAsset": to_asset}
+        body.update(self.__swap_amount_mode(amount, receive_amount))
+        return SwapEstimate.de_json(self._request("POST", "/api/v1/swap/estimate", body=body))
+
+    def get_swaps_list(self, cursor: str | None = None, limit: int | None = None) -> SwapsList:
+        """Get application swaps.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-swaps
+
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``SwapsList``.
+        """
+        return SwapsList.de_json(self._request(
+            "GET", "/api/v1/swaps", params=self.__without_none(cursor=cursor, limit=limit)
+        ))
+
+    def get_swap_info(self, swap_id: str) -> Swap:
+        """Get application swap info by id.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-swap
+
+        :param swap_id: Swap id (track id).
+        :return: ``Swap``.
+        """
+        return Swap.de_json(self._request("GET", "/api/v1/swap/{}".format(swap_id)))
+
+    def get_swap_input_assets(self, asset_out: str | None = None) -> list[SwapAsset]:
+        """Get available input assets, optionally filtered by a target asset.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-assets-in
+
+        :param asset_out: Target asset used to filter the result.
+        :return: ``list[SwapAsset]``.
+        """
+        data = self._request("GET", "/api/v1/swap/assets-in", params=self.__without_none(assetOut=asset_out))
+        return [SwapAsset.de_json(item) for item in data.get("items", [])]
+
+    def get_swap_output_assets(self, asset_in: str | None = None) -> list[SwapAsset]:
+        """Get available output assets, optionally filtered by a source asset.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-assets-out
+
+        :param asset_in: Source asset used to filter the result.
+        :return: ``list[SwapAsset]``.
+        """
+        data = self._request("GET", "/api/v1/swap/assets-out", params=self.__without_none(assetIn=asset_in))
+        return [SwapAsset.de_json(item) for item in data.get("items", [])]
+
+    def get_swap_route_params(self, asset_in: str, asset_out: str) -> SwapRoute:
+        """Get swap route params (min/max amounts) for an asset pair.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-params
+
+        :param asset_in: Source asset.
+        :param asset_out: Target asset.
+        :return: ``SwapRoute``.
+        """
+        return SwapRoute.de_json(self._request(
+            "GET", "/api/v1/swap/params", params={"assetIn": asset_in, "assetOut": asset_out}
+        ))
+
     def create_invoice(
         self,
         price_currency: str,
@@ -204,7 +320,6 @@ class xRocketPayAPI:
         callback: InvoiceCallback | None = None,
         url: InvoiceUrl | None = None,
         customer: InvoiceCustomer | None = None,
-        is_fee_paid_by_user: bool | None = None,
         data: Mapping[str, Any] | None = None,
         platform_id: str | None = None,
     ) -> Invoice:
@@ -224,7 +339,6 @@ class xRocketPayAPI:
         :param callback: Callback data as an ``InvoiceCallback`` instance.
         :param url: User redirect urls as an ``InvoiceUrl`` instance.
         :param customer: Customer info as an ``InvoiceCustomer`` instance.
-        :param is_fee_paid_by_user: If true, the user pays a commission.
         :param data: Custom user data passed through and returned in callbacks/webhooks (max size 4KB).
         :param platform_id: Platform identifier.
         :return: ``Invoice``.
@@ -238,7 +352,7 @@ class xRocketPayAPI:
             callback=self.__request_model(callback, InvoiceCallback, "callback"),
             url=self.__request_model(url, InvoiceUrl, "url"),
             customer=self.__request_model(customer, InvoiceCustomer, "customer"),
-            isFeePaidByUser=is_fee_paid_by_user, data=data, platformId=platform_id,
+            data=data, platformId=platform_id,
         )
         return Invoice.de_json(self._request("POST", "/api/v1/invoices", body=body))
 

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyXRocketAPI/models.py

@@ -267,6 +267,7 @@ class InvoiceCustomer(Dictionaryable, xRocketObject):
     :param telegramUsername: Customer telegram username (without @).
     """
 
+    # noinspection shadowing-builtins
     def __init__(self, id=None, email=None, telegramId=None, telegramUsername=None):
         self.id = id
         self.email = email
@@ -648,6 +649,141 @@ class Rate(xRocketObject):
         return instance
 
 
+# noinspection method-overriding
+class Swap(xRocketObject):
+    """A currency exchange performed from the application balance.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-create-swap
+
+    :param id: Swap id (track id).
+    :param status: Swap status. ``completed`` and ``cancelled`` are terminal;
+        ``pending``, ``failed`` and ``paused`` are non-terminal.
+    :param fromAsset: Asset swapped from.
+    :param toAsset: Asset swapped to.
+    :param fromAmount: Amount in ``fromAsset``.
+    :param toAmount: Guaranteed amount received in ``toAsset``. It is settled
+        on completion and reserved while pending.
+    :param rate: Applied rate.
+    :param clientOrderId: Merchant-provided idempotency key.
+    """
+    def __init__(self):
+        self.id = None
+        self.status = None
+        self.fromAsset = None
+        self.toAsset = None
+        self.fromAmount = None
+        self.toAmount = None
+        self.rate = None
+        self.clientOrderId = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(Swap, cls).de_json(data, process_mode=2)
+        for field in ("fromAmount", "toAmount", "rate"):
+            if getattr(instance, field) is not None:
+                setattr(instance, field, float(getattr(instance, field)))
+        return instance
+
+
+# noinspection method-overriding
+class SwapEstimate(xRocketObject):
+    """Estimated amounts and rate for a prospective currency exchange.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-estimate
+
+    :param fromAsset: Asset to swap from.
+    :param toAsset: Asset to swap to.
+    :param fromAmount: Amount in ``fromAsset``.
+    :param toAmount: Estimated amount in ``toAsset``.
+    :param rate: Estimated rate.
+    """
+    def __init__(self):
+        self.fromAsset = None
+        self.toAsset = None
+        self.fromAmount = None
+        self.toAmount = None
+        self.rate = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(SwapEstimate, cls).de_json(data, process_mode=2)
+        for field in ("fromAmount", "toAmount", "rate"):
+            if getattr(instance, field) is not None:
+                setattr(instance, field, float(getattr(instance, field)))
+        return instance
+
+
+# noinspection method-overriding
+class SwapAsset(xRocketObject):
+    """An asset available as one side of a swap route.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-assets-in
+
+    :param code: Asset code.
+    """
+    def __init__(self):
+        self.code = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(SwapAsset, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class SwapRouteParams(xRocketObject):
+    """Amount limits for a swap route.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-params
+
+    :param minAmount: Minimum amount in ``assetIn``.
+    :param maxAmount: Maximum amount in ``assetIn``.
+    """
+    def __init__(self):
+        self.minAmount = None
+        self.maxAmount = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(SwapRouteParams, cls).de_json(data, process_mode=2)
+        if instance.minAmount is not None:
+            instance.minAmount = float(instance.minAmount)
+        if instance.maxAmount is not None:
+            instance.maxAmount = float(instance.maxAmount)
+        return instance
+
+
+# noinspection method-overriding
+class SwapRoute(xRocketObject):
+    """Available input and output assets with limits for their swap route.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-params
+
+    :param assetIn: Route asset in.
+    :param assetOut: Route asset out.
+    :param params: Route parameters.
+    """
+    def __init__(self):
+        self.assetIn = None
+        self.assetOut = None
+        self.params = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(SwapRoute, cls).de_json(data, process_mode=2)
+        if instance.assetIn is not None:
+            instance.assetIn = SwapAsset.de_json(instance.assetIn)
+        if instance.assetOut is not None:
+            instance.assetOut = SwapAsset.de_json(instance.assetOut)
+        if instance.params is not None:
+            instance.params = SwapRouteParams.de_json(instance.params)
+        return instance
+
+
 # noinspection method-overriding
 class xPage(xRocketObject):
     """Base class for paginated xRocket Pay responses.
@@ -988,6 +1124,25 @@ class WithdrawalsList(xPage):
         return instance
 
 
+# noinspection method-overriding
+class SwapsList(xPage):
+    """Paginated list of application swaps.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/swap-controller-get-swaps
+
+    :param items: Swaps.
+    :param pagination: Cursor pagination information.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(SwapsList, cls).de_json(data)
+        instance.items = [Swap.de_json(item) for item in instance.items]
+        if instance.pagination is not None:
+            instance.pagination = CursorPagination.de_json(instance.pagination)
+        return instance
+
+
 # noinspection method-overriding
 class InvoicePaymentAddress(xRocketObject):
     """Deposit address created for an invoice payment.

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyXRocketAPI/version.py

@@ -1,3 +1,3 @@
 """Package version, read by the build configuration."""
 
-__version__ = "0.3.0"
+__version__ = "1.0.0"

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyXRocketAPI/webhooks.py

@@ -35,7 +35,7 @@ Use :func:`parse_and_verify_webhook` for the usual case::
 
 The returned object is one of :class:`InvoiceStatusChangedWebhook`,
 :class:`PaymentStatusChangedWebhook`, :class:`ChequeWebhook`,
-:class:`PayoutWebhook`, :class:`WithdrawalWebhook`, or
+:class:`PayoutWebhook`, :class:`WithdrawalWebhook`, :class:`SwapWebhook`, or
 :class:`UnknownWebhook`.
 
 The top-level webhook ``id`` identifies a delivery and remains stable across
@@ -71,7 +71,7 @@ from .exceptions import (
     xRocketWebhookSignatureException,
     xRocketWebhookUnsupportedVersionException,
 )
-from .models import Cheque, Invoice, InvoicePayment, Payout, Withdrawal, xRocketObject
+from .models import Cheque, Invoice, InvoicePayment, Payout, Swap, Withdrawal, xRocketObject
 
 
 # noinspection method-overriding
@@ -283,6 +283,57 @@ class WithdrawalWebhook(xRocketWebhook):
         return instance
 
 
+# noinspection method-overriding
+class SwapStatusChangedWebhookData(xRocketObject):
+    """Payload of a ``swap_status_changed`` webhook.
+
+    API: https://docs.xrocket.exchange/api/pay/webhooks
+
+    :param event: Event type. This value is ``swap_status_changed``.
+    :param swap: Updated swap.
+    """
+
+    def __init__(self):
+        self.event = None
+        self.swap = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        """Create the payload from a parsed webhook dictionary.
+
+        :param json_dict: Parsed swap-status-changed payload.
+        :return: ``SwapStatusChangedWebhookData``.
+        """
+        data = cls.check_json(json_dict)
+        instance = super(SwapStatusChangedWebhookData, cls).de_json(data, process_mode=2)
+        instance.swap = Swap.de_json(instance.swap)
+        return instance
+
+
+class SwapWebhook(xRocketWebhook):
+    """Webhook reporting a swap status update.
+
+    API: https://docs.xrocket.exchange/api/pay/webhooks
+
+    :param id: Unique webhook delivery id, can be used by the receiver for idempotency.
+    :param timestamp: When webhook was sent.
+    :param type: Webhook type. This value is ``swap``.
+    :param data: ``SwapStatusChangedWebhookData`` payload.
+    """
+
+    @classmethod
+    def de_json(cls, json_dict):
+        """Create the webhook from a parsed envelope dictionary.
+
+        :param json_dict: Parsed swap webhook envelope.
+        :return: ``SwapWebhook``.
+        """
+        data = cls.check_json(json_dict)
+        instance = super(SwapWebhook, cls).de_json(data)
+        instance.data = SwapStatusChangedWebhookData.de_json(instance.data)
+        return instance
+
+
 class UnknownWebhook(xRocketWebhook):
     """Webhook whose type or invoice event is not known to this library.
 
@@ -372,6 +423,8 @@ def parse_webhook(payload: bytes | bytearray | str | Mapping[str, Any]) -> xRock
     if webhook_type == "withdrawal":
         _require_mapping(envelope["data"], "data")
         return WithdrawalWebhook.de_json(envelope)
+    if webhook_type == "swap":
+        return _parse_swap_webhook(envelope)
     return UnknownWebhook.de_json(envelope)
 
 
@@ -469,6 +522,15 @@ def _parse_invoice_webhook(envelope: dict[str, Any]) -> xRocketWebhook:
     return UnknownWebhook.de_json(envelope)
 
 
+def _parse_swap_webhook(envelope: dict[str, Any]) -> xRocketWebhook:
+    """Choose the typed swap webhook model using the nested event field."""
+    data = _require_mapping(envelope["data"], "data")
+    if data.get("event") == "swap_status_changed":
+        _require_mapping(data.get("swap"), "data.swap")
+        return SwapWebhook.de_json(envelope)
+    return UnknownWebhook.de_json(envelope)
+
+
 def _require_mapping(value: Any, field_name: str) -> Mapping[str, Any]:
     """Return a payload object or raise a precise structural parse error."""
     if not isinstance(value, Mapping):

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyXRocketAPI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyXRocketAPI
-Version: 0.3.0
+Version: 1.0.0
 Summary: Python client for the xRocket Pay API
 Author: Badiboy
 License-Expression: MIT
@@ -8,10 +8,9 @@ Project-URL: Homepage, https://github.com/Badiboy/pyXRocketAPI
 Project-URL: Documentation, https://docs.xrocket.exchange/api/pay/pay-api-overview
 Project-URL: Repository, https://github.com/Badiboy/pyXRocketAPI
 Keywords: xrocket,pay,crypto,payments,api
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.28

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/pyproject.toml

@@ -7,14 +7,13 @@ name = "pyXRocketAPI"
 dynamic = ["version"]
 description = "Python client for the xRocket Pay API"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "MIT"
 authors = [{ name = "Badiboy" }]
 keywords = ["xrocket", "pay", "crypto", "payments", "api"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3 :: Only",
 ]
 dependencies = ["requests>=2.28"]
 

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/tests/test_api.py

@@ -3,10 +3,12 @@ from unittest.mock import patch
 
 from pyXRocketAPI import Cheque, ChequesList, Health, xPage, xRocketAPIException, xRocketPayAPI
 from pyXRocketAPI import api as api_module
+from pyXRocketAPI.version import __version__
 from pyXRocketAPI.models import (
     Balance,
     ChequeCallback,
     ChequeUrl,
+    CursorPagination,
     Invoice,
     InvoiceBlockchainTransaction,
     InvoiceCallback,
@@ -24,6 +26,12 @@ from pyXRocketAPI.models import (
     Payout,
     PayoutCallback,
     Rate,
+    Swap,
+    SwapAsset,
+    SwapEstimate,
+    SwapRoute,
+    SwapRouteParams,
+    SwapsList,
     Withdrawal,
     WithdrawalCallback,
     WithdrawalQuotas,
@@ -54,6 +62,9 @@ class XRocketPayAPITests(unittest.TestCase):
         self.request.return_value = response
         return xRocketPayAPI(token=token, timeout=5)
 
+    def test_package_version_is_1_0_0(self):
+        self.assertEqual(__version__, "1.0.0")
+
     def test_public_health_requires_no_token(self):
         client = self.client(Response(data={
             "status": "ok",
@@ -81,15 +92,17 @@ class XRocketPayAPITests(unittest.TestCase):
     def test_invoice_body_preserves_false_and_uses_camel_case(self):
         client = self.client(Response(201, {"id": "invoice-1", "links": {"webLink": "https://pay.example"}}))
         invoice = client.create_invoice(
-            price_currency="USDT", price_amount="10.00", client_invoice_id="order-1", is_fee_paid_by_user=False
+            price_currency="USDT", price_amount="10.00", client_invoice_id="order-1"
         )
         self.assertEqual(invoice.links.webLink, "https://pay.example")
         method, url = self.request.call_args.args[:2]
         kwargs = self.request.call_args.kwargs
         self.assertEqual((method, url), ("POST", "https://pay.api.xrocket.exchange/api/v1/invoices"))
         self.assertEqual(kwargs["json"], {
-            "priceCurrency": "USDT", "priceAmount": "10.00", "clientInvoiceId": "order-1", "isFeePaidByUser": False,
+            "priceCurrency": "USDT", "priceAmount": "10.00", "clientInvoiceId": "order-1",
         })
+        with self.assertRaises(TypeError):
+            client.create_invoice(price_currency="USDT", is_fee_paid_by_user=False)
 
     def test_invoice_deserializes_all_nested_response_schemas(self):
         client = self.client(Response(data={
@@ -208,6 +221,95 @@ class XRocketPayAPITests(unittest.TestCase):
         self.assertEqual((payout.amount, withdrawal.amount, rate.rate), (5.5, 6.25, 291.87))
         self.assertEqual((address.minAmount, quotas.withdrawMinSize, quotas.withdrawFee, quotas.precision, error.amount), (0.01, 0.001, 0.003, 6, 7.5))
 
+    def test_swap_models_decode_numeric_values_and_list_pagination(self):
+        swap_source = {
+            "id": "swap-1", "status": "pending", "fromAsset": "USDT", "toAsset": "BTC",
+            "fromAmount": "100.5", "toAmount": "0.001", "rate": "0.00001", "clientOrderId": "order-1",
+        }
+        swap = Swap.de_json(swap_source)
+        estimate = SwapEstimate.de_json({
+            "fromAsset": "USDT", "toAsset": "BTC", "fromAmount": "100.5", "toAmount": "0.001", "rate": "0.00001",
+        })
+        route = SwapRoute.de_json({
+            "assetIn": {"code": "USDT"}, "assetOut": {"code": "BTC"},
+            "params": {"minAmount": "1.5", "maxAmount": "10000"},
+        })
+        swaps = SwapsList.de_json({"items": [swap_source], "pagination": {"total": 1, "next": "cursor-2"}})
+
+        self.assertEqual((swap.fromAmount, swap.toAmount, swap.rate), (100.5, 0.001, 0.00001))
+        self.assertEqual((estimate.fromAmount, estimate.toAmount, estimate.rate), (100.5, 0.001, 0.00001))
+        self.assertIsInstance(route.assetIn, SwapAsset)
+        self.assertIsInstance(route.params, SwapRouteParams)
+        self.assertEqual((route.params.minAmount, route.params.maxAmount), (1.5, 10000.0))
+        self.assertIsInstance(swaps.items[0], Swap)
+        self.assertIsInstance(swaps.pagination, CursorPagination)
+
+    def test_create_swap_serializes_exact_in_amount(self):
+        client = self.client(Response(201, {
+            "id": "swap-1", "status": "pending", "fromAsset": "USDT", "toAsset": "BTC",
+            "fromAmount": "100.5", "toAmount": "0.001", "rate": "0.00001", "clientOrderId": "order-1",
+        }))
+
+        swap = client.create_swap("USDT", "BTC", "order-1", amount=100.5)
+
+        self.assertIsInstance(swap, Swap)
+        self.assertEqual(self.request.call_args.args[:2], ("POST", "https://pay.api.xrocket.exchange/api/v1/swap"))
+        self.assertEqual(self.request.call_args.kwargs["json"], {
+            "fromAsset": "USDT", "toAsset": "BTC", "clientOrderId": "order-1", "amount": "100.5",
+        })
+
+    def test_estimate_swap_serializes_exact_out_amount(self):
+        client = self.client(Response(data={
+            "fromAsset": "USDT", "toAsset": "BTC", "fromAmount": "100", "toAmount": "0.001", "rate": "0.00001",
+        }))
+
+        estimate = client.estimate_swap("USDT", "BTC", receive_amount=0.001)
+
+        self.assertIsInstance(estimate, SwapEstimate)
+        self.assertEqual(self.request.call_args.args[:2], ("POST", "https://pay.api.xrocket.exchange/api/v1/swap/estimate"))
+        self.assertEqual(self.request.call_args.kwargs["json"], {
+            "fromAsset": "USDT", "toAsset": "BTC", "receiveAmount": "0.001",
+        })
+
+    def test_swap_amount_modes_reject_both_or_neither_before_request(self):
+        client = self.client(Response(data={}))
+
+        with self.assertRaises(ValueError):
+            client.estimate_swap("USDT", "BTC")
+        with self.assertRaises(ValueError):
+            client.estimate_swap("USDT", "BTC", amount="1", receive_amount="2")
+        with self.assertRaises(TypeError):
+            client.estimate_swap("USDT", "BTC", amount=True)
+
+        self.assertEqual(self.request.call_count, 0)
+
+    def test_swap_queries_deserialize_typed_responses(self):
+        client = self.client(Response(data={
+            "items": [{
+                "id": "swap-1", "status": "completed", "fromAsset": "USDT", "toAsset": "BTC",
+                "fromAmount": "100", "toAmount": "0.001", "rate": "0.00001", "clientOrderId": "order-1",
+            }], "pagination": {"total": 1, "next": None},
+        }))
+        swaps = client.get_swaps_list(cursor="next", limit=10)
+        self.assertIsInstance(swaps, SwapsList)
+        self.assertIsInstance(swaps.items[0], Swap)
+        self.assertEqual(self.request.call_args.kwargs["params"], {"cursor": "next", "limit": 10})
+
+        self.request.return_value = Response(data={"id": "swap-2", "status": "pending", "fromAsset": "USDT", "toAsset": "BTC", "fromAmount": "1", "toAmount": "0.1", "rate": "0.1", "clientOrderId": "order-2"})
+        self.assertIsInstance(client.get_swap_info("swap-2"), Swap)
+        self.assertEqual(self.request.call_args.args[:2], ("GET", "https://pay.api.xrocket.exchange/api/v1/swap/swap-2"))
+
+        self.request.return_value = Response(data={"items": [{"code": "USDT"}]})
+        self.assertIsInstance(client.get_swap_input_assets(asset_out="BTC")[0], SwapAsset)
+        self.assertEqual(self.request.call_args.kwargs["params"], {"assetOut": "BTC"})
+        self.assertIsInstance(client.get_swap_output_assets(asset_in="USDT")[0], SwapAsset)
+        self.assertEqual(self.request.call_args.kwargs["params"], {"assetIn": "USDT"})
+
+        self.request.return_value = Response(data={"assetIn": {"code": "USDT"}, "assetOut": {"code": "BTC"}, "params": {"minAmount": "1", "maxAmount": "100"}})
+        route = client.get_swap_route_params("USDT", "BTC")
+        self.assertIsInstance(route, SwapRoute)
+        self.assertEqual(self.request.call_args.kwargs["params"], {"assetIn": "USDT", "assetOut": "BTC"})
+
     def test_invoice_payment_deserializes_transaction_subschemas(self):
         client = self.client(Response(data={
             "items": [{

{pyxrocketapi-0.3.0 → pyxrocketapi-1.0.0}/tests/test_webhooks.py

@@ -10,6 +10,8 @@ from pyXRocketAPI import (
     Payout,
     PayoutWebhook,
     PaymentStatusChangedWebhook,
+    Swap,
+    SwapWebhook,
     UnknownWebhook,
     Withdrawal,
     WithdrawalWebhook,
@@ -94,6 +96,36 @@ class XRocketWebhookTests(unittest.TestCase):
                 self.assertIsInstance(event, webhook_class)
                 self.assertIsInstance(event.data, data_class)
 
+    def test_parses_and_verifies_swap_status_changed_webhook(self):
+        body, headers = signed_webhook({
+            "id": "delivery-swap-1",
+            "timestamp": "2025-01-01T00:00:00.000Z",
+            "type": "swap",
+            "data": {
+                "event": "swap_status_changed",
+                "swap": {
+                    "id": "swap-1", "status": "completed", "fromAsset": "USDT", "toAsset": "BTC",
+                    "fromAmount": "100.5", "toAmount": "0.001", "rate": "0.00001", "clientOrderId": "order-1",
+                },
+            },
+        })
+
+        event = parse_and_verify_webhook(body, headers, WEBHOOK_SECRET)
+
+        self.assertIsInstance(event, SwapWebhook)
+        self.assertIsInstance(event.data.swap, Swap)
+        self.assertEqual(event.data.event, "swap_status_changed")
+        self.assertEqual(event.data.swap.fromAmount, 100.5)
+
+    def test_returns_unknown_webhook_for_future_swap_event(self):
+        event = parse_webhook({
+            "id": "delivery-swap-2", "timestamp": "now", "type": "swap",
+            "data": {"event": "future_swap_event", "swap": {"id": "swap-1"}},
+        })
+
+        self.assertIsInstance(event, UnknownWebhook)
+        self.assertEqual(event.data["event"], "future_swap_event")
+
     def test_rejects_malformed_webhook_envelope(self):
         with self.assertRaises(xRocketWebhookParseException):
             parse_webhook(b"not json")