pyXRocketAPI 0.1.0__py3-none-any.whl

pyXRocketAPI/__init__.py

@@ -0,0 +1,3 @@
+"""Public API for pyXRocketAPI."""
+
+from .api import *

pyXRocketAPI/api.py

@@ -0,0 +1,506 @@
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+import requests
+
+from .exceptions import xRocketAPIException
+from .models import App, Balance, Cheque, ChequesList, Currency, Invoice, InvoicePaymentAddress, InvoicePaymentsList, InvoicesList, MassPayouts, xPage, Payout, PayoutsList, Rate, Withdrawal, WithdrawalLink, WithdrawalQuotas, WithdrawalsList, xRocketObject
+
+PRODUCTION_API_URL = "https://pay.api.xrocket.exchange"
+TESTNET_API_URL = "https://pay.api.testnet.xrocket.exchange"
+
+
+def _without_none(**values: Any) -> dict[str, Any]:
+    """Keep valid falsey API values while omitting arguments not supplied."""
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def _identifier(first_name: str, first_value: str | None, second_name: str, second_value: str | None) -> dict[str, str]:
+    if first_value is None and second_value is None:
+        raise ValueError(f"Specify {first_name} or {second_name}.")
+    return _without_none(**{first_name: first_value, second_name: second_value})
+
+
+class xRocketPayAPI:
+    """Client for the current xRocket Pay API.
+
+    Parameters
+    ----------
+    token:
+        App-specific Pay API Bearer token. Public calls such as
+        ``health_check()`` and ``get_available_currencies()`` do not require
+        one.
+    testnet:
+        Select the xRocket Pay testnet URL. A testnet token is required.
+    timeout:
+        Timeout passed to every request, in seconds. ``None`` uses requests'
+        default behaviour.
+    """
+
+    def __init__(
+        self,
+        token: str | None = None,
+        testnet: bool = False,
+        timeout: float | tuple[float, float] | None = 10,
+    ) -> None:
+        self.token = token
+        self.timeout = timeout
+        self.base_url = TESTNET_API_URL if testnet else PRODUCTION_API_URL
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Mapping[str, Any] | None = None,
+        body: Mapping[str, Any] | None = None,
+        auth_required: bool = True,
+    ) -> Any:
+        """Send one request to the xRocket Pay REST API.
+
+        The method builds the standard ``Accept`` header, optionally adds the
+        application's Bearer token, sends a JSON request, and converts a
+        non-success response from the API's RFC 9457 Problem Details format
+        into :class:`xRocketAPIException`.
+
+        :param method: HTTP method, for example ``"GET"`` or ``"POST"``.
+        :param path: API path beginning with ``/``, appended to the selected
+            production or testnet base URL.
+        :param params: Optional query-string parameters.
+        :param body: Optional JSON request body.
+        :param auth_required: Require an API token and send it in the Bearer
+            header. Public endpoints pass ``False`` explicitly; rates may opt
+            into authorization.
+        :return: Parsed JSON response, or ``None`` for an empty ``204``
+            response.
+        :raises xRocketAPIException: If a required token is absent, a network
+            request fails, the response is not a 2xx success, or a successful
+            response does not contain valid JSON.
+        """
+        headers = {"Accept": "application/json"}
+        if auth_required:
+            if not self.token:
+                raise xRocketAPIException("This endpoint requires an xRocket Pay API token.")
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        try:
+            response = requests.request(
+                method, f"{self.base_url}{path}", params=params, json=body, headers=headers, timeout=self.timeout
+            )
+        except requests.RequestException as error:
+            raise xRocketAPIException(f"Request to xRocket Pay failed: {error}") from error
+
+        if response.status_code < 200 or response.status_code >= 300:
+            try:
+                problem = response.json()
+            except ValueError:
+                problem = {}
+            detail = problem.get("detail") or problem.get("title") or response.text or "xRocket Pay request failed"
+            raise xRocketAPIException(
+                detail,
+                status=response.status_code,
+                problem_type=problem.get("type"),
+                title=problem.get("title"),
+                detail=problem.get("detail"),
+                instance=problem.get("instance"),
+                kind=problem.get("kind"),
+                info=problem.get("info"),
+            )
+
+        if response.status_code == 204 or not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError as error:
+            raise xRocketAPIException("xRocket Pay returned invalid JSON.", status=response.status_code) from error
+
+    def health_check(self) -> xRocketObject:
+        """Run the public health check.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/health-controller-health
+
+        :return: ``xRocketObject``.
+        """
+        return xRocketObject.de_json(self._request("GET", "/health", auth_required=False), process_mode=2)
+
+    def get_app_info(self) -> App:
+        """Get information about your application.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/app-controller-get-app
+
+        :return: ``App``.
+        """
+        return App.de_json(self._request("GET", "/api/v1/app-info"))
+
+    def get_balances(self) -> list[Balance]:
+        """Get balances of your application.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/app-controller-get-app-balances
+
+        :return: ``list[Balance]``.
+        """
+        data = self._request("GET", "/api/v1/balances")
+        return [Balance.de_json(item) for item in data.get("balances", [])]
+
+    def get_currencies(self, kind: str | None = None) -> list[Currency]:
+        """Get available currencies.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/currencies-controller-get-currencies
+
+        :param kind: No description is provided.
+        :return: ``list[Currency]``.
+        """
+        data = self._request(
+            "GET", "/api/v1/currencies", params=_without_none(kind=kind), auth_required=False
+        )
+        return [Currency.de_json(item) for item in data]
+
+    def get_rates(self, base: str, assets: Iterable[str], authorize: bool = False) -> list[Rate]:
+        """Get currencies rates (optional auth).
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/rate-controller-get-rates
+
+        :param base: Fiat currency.
+        :param assets: Asset codes.
+        :param authorize: Send the optional Bearer authorization header.
+        :return: ``list[Rate]``.
+        """
+        data = self._request(
+            "GET", "/api/v1/rates", params={"base": base, "assets": list(assets)},
+            auth_required=authorize,
+        )
+        return [Rate.de_json(item) for item in data]
+
+    def create_invoice(
+        self,
+        price_currency: str,
+        price_amount: str | None = None,
+        min_payment: str | None = None,
+        num_payments: int | None = None,
+        payout_currency: str | None = None,
+        pay_currencies: Iterable[str] | None = None,
+        client_invoice_id: str | None = None,
+        description: str | None = None,
+        expires_in: int | None = None,
+        callback: Mapping[str, Any] | None = None,
+        url: Mapping[str, Any] | None = None,
+        customer: Mapping[str, Any] | None = None,
+        is_fee_paid_by_user: bool | None = None,
+        data: Mapping[str, Any] | None = None,
+        platform_id: str | None = None,
+    ) -> Invoice:
+        """Create invoice.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-create-invoice
+
+        :param price_currency: Invoice price currency (crypto or fiat).
+        :param price_amount: Invoice price amount.
+        :param min_payment: Minimum payment amount (for open-amount invoices).
+        :param num_payments: Num payments for invoice.
+        :param payout_currency: Invoice payout crypto currency.
+        :param pay_currencies: Crypto currencies which can be used to pay the invoice.
+        :param client_invoice_id: Client Invoice ID as assigned by the client.
+        :param description: Description for invoice.
+        :param expires_in: Payment expires in milliseconds.
+        :param callback: Callback data.
+        :param url: User redirect urls.
+        :param customer: Customer info.
+        :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``.
+        """
+        body = _without_none(
+            priceCurrency=price_currency, priceAmount=price_amount, minPayment=min_payment, numPayments=num_payments,
+            payoutCurrency=payout_currency, payCurrencies=list(pay_currencies) if pay_currencies is not None else None,
+            clientInvoiceId=client_invoice_id, description=description, expiresIn=expires_in, callback=callback, url=url,
+            customer=customer, isFeePaidByUser=is_fee_paid_by_user, data=data, platformId=platform_id,
+        )
+        return Invoice.de_json(self._request("POST", "/api/v1/invoices", body=body))
+
+    def get_invoices_list(self, asset: str | None = None, fiat: str | None = None, ids: Iterable[str] | None = None,
+                 status: str | None = None, cursor: str | None = None, limit: int | None = None) -> InvoicesList:
+        """Get list of invoices.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoices
+
+        :param asset: Filtering invoices by asset.
+        :param fiat: Filtering invoices by fiat.
+        :param ids: Filtering invoices by ids.
+        :param status: Filtering invoices by status.
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``InvoicesList``.
+        """
+        params = _without_none(asset=asset, fiat=fiat, ids=list(ids) if ids is not None else None, status=status, cursor=cursor, limit=limit)
+        return InvoicesList.de_json(self._request("GET", "/api/v1/invoices", params=params))
+
+    def get_invoice_info(self, invoice_id: str | None = None, client_invoice_id: str | None = None) -> Invoice:
+        """Get invoice info.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice
+        Either invoiceId (xRocket) or clientInvoiceId (client-assigned) is required. If both are passed, invoiceId will be used.
+
+        :param invoice_id: xRocket Invoice ID. Either invoiceId or clientInvoiceId is required. If both are passed, invoiceId will be used.
+        :param client_invoice_id: Client Invoice ID assigned by the client. Either invoiceId or clientInvoiceId is required.
+        :return: ``Invoice``.
+        """
+        return Invoice.de_json(self._request("GET", "/api/v1/invoice", params=_identifier("invoiceId", invoice_id, "clientInvoiceId", client_invoice_id)))
+
+    def delete_invoice(self, invoice_id: str | None = None, client_invoice_id: str | None = None) -> None:
+        """Delete invoice.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-delete-invoice
+        Either invoiceId (xRocket) or clientInvoiceId (client-assigned) is required. If both are passed, invoiceId will be used.
+
+        :param invoice_id: xRocket Invoice ID. Either invoiceId or clientInvoiceId is required. If both are passed, invoiceId will be used.
+        :param client_invoice_id: Client Invoice ID assigned by the client. Either invoiceId or clientInvoiceId is required.
+        :return: ``None``.
+        """
+        self._request("DELETE", "/api/v1/invoice", params=_identifier("invoiceId", invoice_id, "clientInvoiceId", client_invoice_id))
+
+    def get_invoice_payments(self, invoice_id: str | None = None, client_invoice_id: str | None = None,
+                         cursor: str | None = None, limit: int | None = None) -> InvoicePaymentsList:
+        """Get invoice payments.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice-payments
+        Returns payments of an invoice in the same format as the payment_status_changed webhook. Either invoiceId (xRocket) or clientInvoiceId (client-assigned) is required. If both are passed, invoiceId will be used.
+
+        :param invoice_id: xRocket Invoice ID. Either invoiceId or clientInvoiceId is required. If both are passed, invoiceId will be used.
+        :param client_invoice_id: Client Invoice ID assigned by the client. Either invoiceId or clientInvoiceId is required.
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``InvoicePaymentsList``.
+        """
+        params = _identifier("invoiceId", invoice_id, "clientInvoiceId", client_invoice_id)
+        params.update(_without_none(cursor=cursor, limit=limit))
+        return InvoicePaymentsList.de_json(self._request("GET", "/api/v1/invoice/payments", params=params))
+
+    def create_invoice_payment_address(self, pay_network: str, invoice_id: str | None = None,
+                                       client_invoice_id: str | None = None) -> InvoicePaymentAddress:
+        """Create invoice payment address.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-payment-controller-create-invoice-payment-address
+
+        :param pay_network: Network code for payment.
+        :param invoice_id: xRocket Invoice ID. Either invoiceId or clientInvoiceId is required. If both are passed, invoiceId will be used.
+        :param client_invoice_id: Client Invoice ID assigned by the client. Either invoiceId or clientInvoiceId is required.
+        :return: ``InvoicePaymentAddress``.
+        """
+        return InvoicePaymentAddress.de_json(self._request(
+            "POST", "/api/v1/invoices/payments/address",
+            params=_identifier("invoiceId", invoice_id, "clientInvoiceId", client_invoice_id), body={"payNetwork": pay_network},
+        ))
+
+    def create_cheque(self, asset: str, amount: str, client_cheque_id: str | None = None, password: str | None = None,
+                      description: str | None = None, callback: Mapping[str, Any] | None = None, url: Mapping[str, Any] | None = None,
+                      target_type: str | None = None, target: str | None = None) -> Cheque:
+        """Create cheque.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-create-cheque
+        Issue a personal cheque to perform an accept-type payout. The amount is reserved from the application balance and can be redeemed by the recipient or cancelled before redemption. When targetType and target are set, only the addressed user is allowed to redeem the cheque.
+
+        :param asset: Currency of transfer.
+        :param amount: Cheque amount.
+        :param client_cheque_id: Unique cheque ID in your system to prevent double spends.
+        :param password: Cheque password, the recipient has to enter it to redeem the cheque.
+        :param description: Description for cheque.
+        :param callback: Webhook settings for cheque activation updates.
+        :param url: User redirect urls after cheque activation.
+        :param target_type: Target type for cheque, has to be passed together with target.
+        :param target: Target for cheque, has to be passed together with targetType.
+        :return: ``Cheque``.
+        """
+        return Cheque.de_json(self._request("POST", "/api/v1/cheques", body=_without_none(
+            asset=asset, amount=str(amount), clientChequeId=client_cheque_id, password=password, description=description,
+            callback=callback, url=url, targetType=target_type, target=target,
+        )))
+
+    def get_cheques_list(self, from_date: str | None = None, to_date: str | None = None, target_type: str | None = None,
+                target: str | None = None, state: str | None = None, cursor: str | None = None, limit: int | None = None) -> ChequesList:
+        """Get list of cheques.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-get-cheques
+        List personal cheques issued for accept-type transfers. Use this to monitor pending, redeemed, or cancelled cheques. Cancelled cheques are excluded from the list.
+
+        :param from_date: From date (ISO 8601).
+        :param to_date: To date (ISO 8601).
+        :param target_type: Target type for cheque, has to be passed together with target.
+        :param target: Target identifier for cheque (depends on targetType), has to be passed together with targetType.
+        :param state: Cheque state.
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``ChequesList``.
+        """
+        return ChequesList.de_json(self._request("GET", "/api/v1/cheques", params=_without_none(
+            fromDate=from_date, toDate=to_date, targetType=target_type, target=target, state=state, cursor=cursor, limit=limit,
+        )))
+
+    def get_cheque_info(self, cheque_id: str | None = None, client_cheque_id: str | None = None) -> Cheque:
+        """Get cheque info.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-get-cheque
+        Fetch details of a personal cheque used for an accept-type payout, including status and reserved amount. A cancelled cheque is returned with the deleted flag set.
+
+        :param cheque_id: Cheque id.
+        :param client_cheque_id: Unique cheque id in your system.
+        :return: ``Cheque``.
+        """
+        return Cheque.de_json(self._request("GET", "/api/v1/cheque", params=_identifier("chequeId", cheque_id, "clientChequeId", client_cheque_id)))
+
+    def update_cheque(self, description: str, cheque_id: str | None = None, client_cheque_id: str | None = None) -> Cheque:
+        """Update cheque.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-update-cheque
+        Modify an active unredeemed cheque. Only description can be updated, pass an empty string to clear it. The cheque must be in active state, not cancelled and not yet redeemed.
+
+        :param description: Cheque description (set empty string to clear description).
+        :param cheque_id: Cheque id.
+        :param client_cheque_id: Unique cheque id in your system.
+        :return: ``Cheque``.
+        """
+        return Cheque.de_json(self._request("PUT", "/api/v1/cheques", params=_identifier("chequeId", cheque_id, "clientChequeId", client_cheque_id), body={"description": description}))
+
+    def delete_cheque(self, cheque_id: str | None = None, client_cheque_id: str | None = None) -> None:
+        """Delete cheque.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-delete-cheque
+        Cancel an unredeemed personal cheque. Upon cancellation, the reserved funds are released back to the application balance.
+
+        :param cheque_id: Cheque id.
+        :param client_cheque_id: Unique cheque id in your system.
+        :return: ``None``.
+        """
+        self._request("DELETE", "/api/v1/cheques", params=_identifier("chequeId", cheque_id, "clientChequeId", client_cheque_id))
+
+    def payout_funds_to_user(self, target: str, target_type: str, asset: str, amount: str, client_payout_id: str | None = None,
+                      description: str | None = None, callback: Mapping[str, Any] | None = None) -> Payout:
+        """Payout funds to user.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/payout-controller-payout
+
+        :param target: Target.
+        :param target_type: Target type.
+        :param asset: Asset of transfer.
+        :param amount: Payout amount.
+        :param client_payout_id: Unique payout ID in your system to prevent double spends.
+        :param description: Payout description.
+        :param callback: Webhook settings for payout status updates.
+        :return: ``Payout``.
+        """
+        return Payout.de_json(self._request("POST", "/api/v1/payouts", body=_without_none(
+            target=target, targetType=target_type, asset=asset, amount=str(amount), clientPayoutId=client_payout_id,
+            description=description, callback=callback,
+        )))
+
+    def get_payouts_list(self, from_date: str | None = None, to_date: str | None = None, cursor: str | None = None,
+                limit: int | None = None) -> PayoutsList:
+        """Get payouts list.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/payout-controller-get-list-payouts
+
+        :param from_date: From date (ISO 8601).
+        :param to_date: To date (ISO 8601).
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``PayoutsList``.
+        """
+        return PayoutsList.de_json(self._request("GET", "/api/v1/payouts", params=_without_none(fromDate=from_date, toDate=to_date, cursor=cursor, limit=limit)))
+
+    def get_payout_info(self, payout_id: str | None = None, client_payout_id: str | None = None) -> Payout:
+        """Get payout info.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/payout-controller-get-payout
+
+        :param payout_id: Payout ID.
+        :param client_payout_id: Unique payout ID in your system to prevent double spends.
+        :return: ``Payout``.
+        """
+        return Payout.de_json(self._request("GET", "/api/v1/payout", params=_identifier("payoutId", payout_id, "clientPayoutId", client_payout_id)))
+
+    def create_mass_payouts(self, asset: str, payouts: Iterable[Mapping[str, Any]]) -> MassPayouts:
+        """Create mass payouts (Telegram users only).
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/mass-payouts-controller-create-mass-payouts
+
+        :param asset: Asset of payouts.
+        :param payouts: List of payouts to process.
+        :return: ``MassPayouts``.
+        """
+        return MassPayouts.de_json(self._request("POST", "/api/v1/mass-payouts", body={"asset": asset, "payouts": list(payouts)}))
+
+    def withdrawal_funds(self, client_withdrawal_id: str, network: str, address: str, asset: str, amount: str,
+                         comment: str | None = None, callback: Mapping[str, Any] | None = None) -> Withdrawal:
+        """Withdrawal funds from application to external wallet.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-create-withdrawal
+
+        :param client_withdrawal_id: Unique withdrawal ID in your system to prevent double spends.
+        :param network: Network code.
+        :param address: Withdrawal address.
+        :param asset: Asset code.
+        :param amount: Withdrawal amount.
+        :param comment: Withdrawal comment.
+        :param callback: Webhook settings for withdrawal status updates.
+        :return: ``Withdrawal``.
+        """
+        return Withdrawal.de_json(self._request("POST", "/api/v1/withdrawals", body=_without_none(
+            clientWithdrawalId=client_withdrawal_id, network=network, address=address, asset=asset, amount=str(amount),
+            comment=comment, callback=callback,
+        )))
+
+    def get_withdrawals_list(self, from_date: str | None = None, to_date: str | None = None, status: str | None = None,
+                             cursor: str | None = None, limit: int | None = None) -> WithdrawalsList:
+        """Get application withdrawals.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawals
+
+        :param from_date: From date (ISO 8601).
+        :param to_date: To date (ISO 8601).
+        :param status: Withdrawal status.
+        :param cursor: Cursor for pagination.
+        :param limit: No description is provided.
+        :return: ``WithdrawalsList``.
+        """
+        return WithdrawalsList.de_json(self._request("GET", "/api/v1/withdrawals", params=_without_none(
+            fromDate=from_date, toDate=to_date, status=status, cursor=cursor, limit=limit,
+        )))
+
+    def get_withdrawal_info(self, withdrawal_id: str | None = None, client_withdrawal_id: str | None = None) -> Withdrawal:
+        """Get application withdrawal info.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawal
+
+        :param withdrawal_id: Withdrawal ID.
+        :param client_withdrawal_id: Unique withdrawal ID in your system to prevent double spends.
+        :return: ``Withdrawal``.
+        """
+        return Withdrawal.de_json(self._request("GET", "/api/v1/withdrawal", params=_identifier("withdrawalId", withdrawal_id, "clientWithdrawalId", client_withdrawal_id)))
+
+    def get_withdrawal_quotas(self, network: str, asset: str) -> WithdrawalQuotas:
+        """Get application withdrawal quotas.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawal-fees
+
+        :param network: Network code.
+        :param asset: Asset code.
+        :return: ``WithdrawalQuotas``.
+        """
+        return WithdrawalQuotas.de_json(self._request("GET", "/api/v1/withdrawal-quotas", params={"network": network, "asset": asset}))
+
+    def create_withdrawal_link(self, network: str, address: str, asset: str, amount: str, comment: str | None = None,
+                               platform: str | None = None) -> WithdrawalLink:
+        """Create withdrawal link.
+
+        API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-links-controller-create-withdrawal-link
+
+        :param network: Network code.
+        :param address: Withdrawal address.
+        :param asset: Asset code.
+        :param amount: Withdrawal amount.
+        :param comment: Withdrawal comment.
+        :param platform: Platform identifier (optional, use only if provided by xRocket).
+        :return: ``WithdrawalLink``.
+        """
+        return WithdrawalLink.de_json(self._request("POST", "/api/v1/withdrawal-link", body=_without_none(
+            network=network, address=address, asset=asset, amount=str(amount), comment=comment, platform=platform,
+        )))

pyXRocketAPI/exceptions.py

@@ -0,0 +1,22 @@
+class xRocketAPIException(Exception):
+    """An HTTP or transport failure returned while calling xRocket Pay."""
+
+    def __init__(
+        self,
+        message: str,
+        status: int | None = None,
+        problem_type: str | None = None,
+        title: str | None = None,
+        detail: str | None = None,
+        instance: str | None = None,
+        kind: str | None = None,
+        info: object | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.problem_type = problem_type
+        self.title = title
+        self.detail = detail
+        self.instance = instance
+        self.kind = kind
+        self.info = info

pyXRocketAPI/models.py

@@ -0,0 +1,692 @@
+import json
+from abc import ABC
+
+
+class xRocketObject(ABC):
+    """Base class for xRocket Pay API response models.
+
+    Subclasses declare their API fields in ``__init__`` and override
+    ``de_json`` to deserialize nested response objects where necessary.
+    """
+
+    @classmethod
+    def de_json(cls, json_dict, process_mode=0):
+        """Create an instance of this class from an xRocket response dictionary.
+
+        This common implementation is used by subclasses after they validate
+        ``json_dict`` with :meth:`check_json`.
+
+        :param json_dict: Parsed response dictionary.
+        :param process_mode: ``0`` returns ``None``; ``1`` creates an empty
+            instance; ``2`` creates an instance and fills its fields from the
+            response dictionary.
+        :return: A class instance or ``None`` when ``process_mode`` is ``0``.
+        """
+        if process_mode == 0:
+            return None
+        instance = cls()
+        if process_mode == 2:
+            for key, value in json_dict.items():
+                setattr(instance, key, value)
+        return instance
+
+    @staticmethod
+    def check_json(input_json, dict_copy=False):
+        """Validate and normalize an API response dictionary or JSON string.
+
+        :param input_json: A parsed dictionary or a JSON-formatted string.
+        :param dict_copy: Return a shallow copy when ``input_json`` is a
+            dictionary.
+        :return: The parsed dictionary or the original dictionary.
+        :raises ValueError: If the input is neither a dictionary nor a JSON
+            string.
+        """
+        if isinstance(input_json, dict):
+            return input_json.copy() if dict_copy else input_json
+        if isinstance(input_json, str):
+            return json.loads(input_json)
+        raise ValueError("input_json should be a JSON dictionary or string.")
+
+    def __str__(self):
+        """Return a readable string representation of the model fields."""
+        data = {}
+        for key, value in self.__dict__.items():
+            if isinstance(value, list):
+                data[key] = [str(item) for item in value]
+            elif isinstance(value, dict):
+                data[key] = {item_key: str(item_value) for item_key, item_value in value.items()}
+            elif hasattr(value, "__dict__"):
+                data[key] = value.__dict__
+            else:
+                data[key] = value
+        return str(data)
+
+
+# noinspection method-overriding
+class App(xRocketObject):
+    """Current application returned by xRocket Pay.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/app-controller-get-app
+
+    :ivar id: No description is provided.
+    :ivar name: Name of current app.
+    """
+    def __init__(self):
+        self.id = None
+        self.name = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(App, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class Balance(xRocketObject):
+    """Balance of an asset belonging to the current application.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/app-controller-get-app-balances
+
+    :ivar asset: Balance asset.
+    :ivar balance: Asset balance.
+    :ivar available: Available balance.
+    :ivar holds: Holds balance.
+    """
+    def __init__(self):
+        self.asset = None
+        self.balance = None
+        self.available = None
+        self.holds = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(Balance, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class InvoiceLinks(xRocketObject):
+    """Links used to open an invoice payment page.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice
+
+    :ivar telegramBotLink: Invoice telegram bot link.
+    :ivar telegramMiniAppLink: Invoice telegram mini app link.
+    :ivar webLink: Invoice web link.
+    """
+    def __init__(self):
+        self.telegramBotLink = None
+        self.telegramMiniAppLink = None
+        self.webLink = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(InvoiceLinks, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class Invoice(xRocketObject):
+    """Invoice created in xRocket Pay.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice
+
+    :ivar id: Invoice id.
+    :ivar priceAmount: Invoice price amount.
+    :ivar minPayment: Minimum payment amount (for open-amount invoices).
+    :ivar priceCurrency: Invoice price currency (crypto or fiat).
+    :ivar payCurrencies: Currencies which can be used to pay the invoice (crypto or fiat).
+    :ivar clientInvoiceId: Your unique identifier for this invoice to link with your internal system (e.g., order ID).
+    :ivar description: Description for invoice.
+    :ivar expiresIn: Invoice expires in milliseconds (from creation time).
+    :ivar createdAt: Invoice creation time.
+    :ivar expiresAt: Invoice expiration time (null if no expiration).
+    :ivar status: Invoice status. **WARNING**: This list may be extended in the future. Always use exact status comparison and handle unknown statuses gracefully.
+    :ivar callback: No description is provided.
+    :ivar url: No description is provided.
+    :ivar customer: No description is provided.
+    :ivar links: No description is provided.
+    """
+    def __init__(self):
+        self.id = None
+        self.priceAmount = None
+        self.minPayment = None
+        self.priceCurrency = None
+        self.payCurrencies = []
+        self.clientInvoiceId = None
+        self.description = None
+        self.expiresIn = None
+        self.createdAt = None
+        self.expiresAt = None
+        self.status = None
+        self.callback = None
+        self.url = None
+        self.customer = None
+        self.links = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(Invoice, cls).de_json(data, process_mode=2)
+        if instance.links is not None:
+            instance.links = InvoiceLinks.de_json(instance.links)
+        return instance
+
+
+# noinspection method-overriding
+class ChequeLinks(xRocketObject):
+    """Links used to activate a cheque.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-get-cheque
+
+    :ivar telegramBotLink: Cheque activation telegram bot link.
+    :ivar telegramMiniAppLink: Cheque activation telegram mini app link (soon).
+    :ivar webLink: Cheque activation web link (soon).
+    """
+    def __init__(self):
+        self.telegramBotLink = None
+        self.telegramMiniAppLink = None
+        self.webLink = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(ChequeLinks, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class Cheque(xRocketObject):
+    """Cheque created in xRocket Pay.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-get-cheque
+
+    :ivar chequeId: Cheque ID.
+    :ivar clientChequeId: Unique cheque ID in your system to prevent double spends.
+    :ivar asset: Currency of transfer.
+    :ivar description: Description for cheque.
+    :ivar targetType: Target type for cheque.
+    :ivar target: Target for cheque.
+    :ivar links: Cheque activation links.
+    :ivar state: Cheque state.
+    :ivar deleted: Cheque is cancelled and the reserved funds are returned to the application balance.
+    :ivar callback: No description is provided.
+    :ivar url: No description is provided.
+    """
+    def __init__(self):
+        self.chequeId = None
+        self.clientChequeId = None
+        self.asset = None
+        self.description = None
+        self.targetType = None
+        self.target = None
+        self.links = None
+        self.state = None
+        self.deleted = None
+        self.callback = None
+        self.url = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(Cheque, cls).de_json(data, process_mode=2)
+        if instance.links is not None:
+            instance.links = ChequeLinks.de_json(instance.links)
+        return instance
+
+
+# noinspection method-overriding
+class Payout(xRocketObject):
+    """Payout from the current application to a user.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/payout-controller-get-payout
+
+    :ivar payoutId: Payout ID.
+    :ivar clientPayoutId: Unique payout ID in your system to prevent double spends.
+    :ivar target: Target.
+    :ivar targetType: Target type.
+    :ivar asset: Asset of payout.
+    :ivar amount: Payout amount.
+    :ivar description: Payout description.
+    :ivar status: Payout status.
+    :ivar callback: Webhook settings of this payout.
+    """
+    def __init__(self):
+        self.payoutId = None
+        self.clientPayoutId = None
+        self.target = None
+        self.targetType = None
+        self.asset = None
+        self.amount = None
+        self.description = None
+        self.status = None
+        self.callback = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(Payout, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class Withdrawal(xRocketObject):
+    """Withdrawal from the current application to an external wallet.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawal
+
+    :ivar withdrawalId: Unique withdrawal ID in your system to prevent double spends.
+    :ivar network: Network code.
+    :ivar address: Withdrawal address.
+    :ivar asset: Asset code.
+    :ivar amount: Withdrawal amount. 9 decimal places, others cut off.
+    :ivar status: Withdrawal status.
+    :ivar comment: Withdrawal comment.
+    :ivar txHash: Withdrawal TX hash. Provided only after withdrawal.
+    :ivar txLink: Withdrawal TX link. Provided only after withdrawal.
+    :ivar callback: Webhook settings of this withdrawal.
+    """
+    def __init__(self):
+        self.withdrawalId = None
+        self.network = None
+        self.address = None
+        self.asset = None
+        self.amount = None
+        self.status = None
+        self.comment = None
+        self.txHash = None
+        self.txLink = None
+        self.callback = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(Withdrawal, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class CurrencyNetwork(xRocketObject):
+    """Network supported by a currency.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/currencies-controller-get-currencies
+
+    :ivar code: Network code.
+    """
+    def __init__(self):
+        self.code = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(CurrencyNetwork, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class Currency(xRocketObject):
+    """Currency available in xRocket Pay.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/currencies-controller-get-currencies
+
+    :ivar code: No description is provided.
+    :ivar title: No description is provided.
+    :ivar kind: No description is provided.
+    :ivar networks: No description is provided.
+    """
+    def __init__(self):
+        self.code = None
+        self.title = None
+        self.kind = None
+        self.networks = []
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(Currency, cls).de_json(data, process_mode=2)
+        instance.networks = [CurrencyNetwork.de_json(item) for item in instance.networks]
+        return instance
+
+
+# noinspection method-overriding
+class Rate(xRocketObject):
+    """Current exchange rate for a currency.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/rate-controller-get-rates
+
+    :ivar currency: No description is provided.
+    :ivar rate: Current rate.
+    """
+    def __init__(self):
+        self.currency = None
+        self.rate = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(Rate, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class xPage(xRocketObject):
+    """Base class for paginated xRocket Pay responses.
+
+    This is an SDK base model; the API has no standalone page endpoint.
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    def __init__(self):
+        self.items = []
+        self.pagination = None
+
+    @classmethod
+    def de_json(cls, json_dict, process_mode=None):
+        data = cls.check_json(json_dict)
+        return super(xPage, cls).de_json(data, process_mode=2 if process_mode is None else process_mode)
+
+
+# noinspection method-overriding
+class CursorPagination(xRocketObject):
+    """Cursor pagination information for list responses.
+
+    This shared response fragment has no standalone API endpoint.
+
+    :ivar total: Total quantity of campaigns.
+    :ivar next: Cursor for the next page of results.
+    """
+    def __init__(self):
+        self.total = None
+        self.next = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(CursorPagination, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class InvoicePaymentsPagination(xRocketObject):
+    """Cursor pagination information for invoice-payment lists.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice-payments
+
+    :ivar next: Cursor for the next page of results.
+    """
+    def __init__(self):
+        self.next = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(InvoicePaymentsPagination, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class InvoicePayment(xRocketObject):
+    """A payment made for an invoice.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice-payments
+
+    :ivar id: Unique payment id. Use it to match webhook events with the invoice payments endpoint.
+    :ivar status: Invoice status. **WARNING**: This list may be extended in the future. Always use exact status comparison and handle unknown statuses gracefully.
+    :ivar finalizedAt: When payment reached final state (null for in-progress payments).
+    :ivar payAmount: Gross amount payer sent in total across all transactions of this payment (before fees).
+    :ivar payCurrency: Currency payer used.
+    :ivar receiveAmount: Net amount merchant receives after fees, summed across all transactions of this payment (in invoice priceCurrency).
+    :ivar receiveCurrency: Currency merchant receives (= invoice priceCurrency).
+    :ivar transactions: No description is provided.
+    """
+    def __init__(self):
+        self.id = None
+        self.status = None
+        self.finalizedAt = None
+        self.payAmount = None
+        self.payCurrency = None
+        self.receiveAmount = None
+        self.receiveCurrency = None
+        self.transactions = []
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(InvoicePayment, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class InvoicesList(xPage):
+    """Paginated list of invoices.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoices
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(InvoicesList, cls).de_json(data)
+        instance.items = [Invoice.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 InvoicePaymentsList(xPage):
+    """Paginated list of invoice payments.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-controller-get-invoice-payments
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(InvoicePaymentsList, cls).de_json(data)
+        instance.items = [InvoicePayment.de_json(item) for item in instance.items]
+        if instance.pagination is not None:
+            instance.pagination = InvoicePaymentsPagination.de_json(instance.pagination)
+        return instance
+
+
+# noinspection method-overriding
+class ChequesList(xPage):
+    """Paginated list of cheques.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/cheque-controller-get-cheques
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(ChequesList, cls).de_json(data)
+        instance.items = [Cheque.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 PayoutsList(xPage):
+    """Paginated list of payouts.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/payout-controller-get-list-payouts
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(PayoutsList, cls).de_json(data)
+        instance.items = [Payout.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 WithdrawalsList(xPage):
+    """Paginated list of withdrawals.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawals
+
+    :ivar items: No description is provided.
+    :ivar pagination: No description is provided.
+    """
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(WithdrawalsList, cls).de_json(data)
+        instance.items = [Withdrawal.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.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/invoice-payment-controller-create-invoice-payment-address
+
+    :ivar address: Deposit address.
+    :ivar payCurrency: Currency code.
+    :ivar payNetwork: Network code.
+    :ivar expiresAt: Payment expired at.
+    :ivar minAmount: Minimum deposit amount (invoice has no fixed amount).
+    """
+    def __init__(self):
+        self.address = None
+        self.payCurrency = None
+        self.payNetwork = None
+        self.expiresAt = None
+        self.minAmount = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(InvoicePaymentAddress, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class WithdrawalQuotas(xRocketObject):
+    """Withdrawal quotas for an asset and network.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-controller-get-withdrawal-fees
+
+    :ivar withdrawMinSize: Minimum withdrawal amount.
+    :ivar withdrawFee: Withdrawal fee.
+    :ivar withdrawFeeAsset: Withdrawal fee asset.
+    :ivar precision: Floating point precision.
+    """
+    def __init__(self):
+        self.withdrawMinSize = None
+        self.withdrawFee = None
+        self.withdrawFeeAsset = None
+        self.precision = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(WithdrawalQuotas, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class WithdrawalLink(xRocketObject):
+    """Links used to create a withdrawal from a user.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/withdrawal-links-controller-create-withdrawal-link
+
+    :ivar telegramBotLink: Withdrawal telegram bot link.
+    :ivar telegramMiniAppLink: Withdrawal telegram mini app link (soon).
+    :ivar webLink: Withdrawal web link (soon).
+    """
+    def __init__(self):
+        self.telegramBotLink = None
+        self.telegramMiniAppLink = None
+        self.webLink = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(WithdrawalLink, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class MassPayoutReason(xRocketObject):
+    """Problem details for one failed mass payout.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/mass-payouts-controller-create-mass-payouts
+
+    :ivar type: A URI reference that identifies the problem type.
+    :ivar title: A short, human-readable summary of the problem type.
+    :ivar status: HTTP status code.
+    :ivar detail: A human-readable explanation specific to this occurrence of the problem.
+    :ivar instance: A URI reference that identifies the specific occurrence of the problem.
+    :ivar kind: Problem category for easier error handling.
+    """
+    def __init__(self):
+        self.type = None
+        self.title = None
+        self.status = None
+        self.detail = None
+        self.instance = None
+        self.kind = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        return super(MassPayoutReason, cls).de_json(data, process_mode=2)
+
+
+# noinspection method-overriding
+class MassPayoutError(xRocketObject):
+    """A failed payout returned by a mass-payout request.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/mass-payouts-controller-create-mass-payouts
+
+    :ivar target: Target.
+    :ivar targetType: Target type (only TelegramUserId is supported for mass payouts).
+    :ivar amount: Payout amount.
+    :ivar clientPayoutId: Unique payout ID in your system to prevent double spends.
+    :ivar description: Payout description.
+    :ivar reason: Payout error reason.
+    """
+    def __init__(self):
+        self.target = None
+        self.targetType = None
+        self.amount = None
+        self.clientPayoutId = None
+        self.description = None
+        self.reason = None
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(MassPayoutError, cls).de_json(data, process_mode=2)
+        if instance.reason is not None:
+            instance.reason = MassPayoutReason.de_json(instance.reason)
+        return instance
+
+
+# noinspection method-overriding
+class MassPayouts(xRocketObject):
+    """Result of a mass-payout request.
+
+    API: https://docs.xrocket.exchange/api/pay/reference/http/mass-payouts-controller-create-mass-payouts
+
+    :ivar successPayouts: Successful payouts.
+    :ivar errorPayouts: Error payouts.
+    """
+    def __init__(self):
+        self.successPayouts = []
+        self.errorPayouts = []
+
+    @classmethod
+    def de_json(cls, json_dict):
+        data = cls.check_json(json_dict)
+        instance = super(MassPayouts, cls).de_json(data, process_mode=2)
+        instance.successPayouts = [Payout.de_json(item) for item in instance.successPayouts]
+        instance.errorPayouts = [MassPayoutError.de_json(item) for item in instance.errorPayouts]
+        return instance

pyXRocketAPI/version.py

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

pyxrocketapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: pyXRocketAPI
+Version: 0.1.0
+Summary: Python client for the xRocket Pay API
+Author: Badiboy
+License-Expression: MIT
+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: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# pyXRocketAPI
+
+**pyXRocketAPI** is a Python client for the [xRocket Pay API](https://docs.xrocket.exchange/api/pay/pay-api-overview). It supports application information, balances, invoices, cheques, payouts, withdrawals, currency rates, and health checks.
+
+## Installation
+
+```shell
+pip install pyXRocketAPI
+```
+
+## Quick start
+
+```python
+from pyXRocketAPI import xRocketPayAPI
+
+client = xRocketPayAPI(token="your-pay-api-token")
+invoice = client.create_invoice(price_currency="USDT", price_amount="10.00")
+print(invoice.id, invoice.links.web_link)
+```
+
+For integration testing, use the xRocket testnet instead of production:
+
+```python
+client = xRocketPayAPI(token="testnet-token", testnet=True)
+```
+
+## Safety
+
+The token grants access to the application and must not be committed to source control. Financial POST operations are not retried automatically. Supply and retain the relevant client identifier (`client_invoice_id`, `client_payout_id`, `client_cheque_id`, or `client_withdrawal_id`) so that a timed-out operation can be reconciled safely.
+
+Errors from the API raise `xRocketAPIException`; its `problem_type`, `kind`, `status`, and `instance` attributes expose the RFC 9457 error response.
+
+_AI-supported creation._

pyxrocketapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyXRocketAPI/__init__.py,sha256=yihLUNgpvxfUS1eSXXpE33IYdGGc_sxI7G-DyfTRsBs,55
+pyXRocketAPI/api.py,sha256=5LJJf5q3o1xJS5uIRJrMQ-VQ_o-q5jWVtsnPqvkuW1M,26164
+pyXRocketAPI/exceptions.py,sha256=H-L4mJA-BgvwCBqh_TSvP5qTABtJe4RtDkZ5lix60og,677
+pyXRocketAPI/models.py,sha256=gpVp75FpSA5GXCWgTYhwiseWceAwpHj3dyh0X3GB5DQ,24041
+pyXRocketAPI/version.py,sha256=udWknsv3LDLQEwP4_UQUQeRp1okJILh9rKefhiqdBl4,79
+pyxrocketapi-0.1.0.dist-info/licenses/LICENSE,sha256=iw-28FPO0DiYiTwy8rfgljZxjhA12F5hhqHe_BpYW-o,1064
+pyxrocketapi-0.1.0.dist-info/METADATA,sha256=FLnuVcbfbGDWeJnCL4LEsB1L8yREeudgNC-I8ouDZlk,1965
+pyxrocketapi-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyxrocketapi-0.1.0.dist-info/top_level.txt,sha256=33Ju2GBtWw8-eJeVkNtL7TR1g7SV-g9_3dw_Y56KvmU,13
+pyxrocketapi-0.1.0.dist-info/RECORD,,

pyxrocketapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyxrocketapi-0.1.0.dist-info/licenses/LICENSE

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

pyxrocketapi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyXRocketAPI