plaxswap 0.1.0__tar.gz

plaxswap-0.1.0/LICENSE

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

plaxswap-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: plaxswap
+Version: 0.1.0
+Summary: Official Plaxswap API client: accept crypto payments (hosted checkout, payment links, signed webhooks) and quote crypto swaps.
+Author-email: Plaxswap <support@plaxswap.com>
+License: MIT
+Project-URL: Homepage, https://plaxswap.com
+Project-URL: Documentation, https://plaxswap.com/developers/payments
+Project-URL: API reference, https://plaxswap.com/api/v1/openapi.json
+Project-URL: Source, https://github.com/plaxswap-com/plaxswap-python
+Project-URL: Issues, https://github.com/plaxswap-com/plaxswap-python/issues
+Keywords: plaxswap,crypto payments,crypto payment gateway,payment gateway,bitcoin,usdt,stablecoin,webhooks,crypto swap
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# plaxswap
+
+The official Python client for the [Plaxswap](https://plaxswap.com) API.
+
+- **Accept crypto payments** on your site: create a payment, send the customer to the hosted checkout, and check the signed webhook. Docs: [Crypto payment gateway API](https://plaxswap.com/developers/payments).
+- **Payment links**: ask for an exact amount of one coin; the payer can use any supported coin. See [crypto payment links](https://plaxswap.com/pay).
+- **Swaps**: quote routes from KyberSwap, 0x, LI.FI, Relay and NEAR Intents, best return first, with every fee shown. See the [swap API guide](https://plaxswap.com/developers).
+
+Standard library only. Python 3.8+.
+
+## Install
+
+```bash
+pip install plaxswap
+```
+
+## Accept a payment
+
+```python
+import os
+from plaxswap import Plaxswap
+
+px = Plaxswap(api_key=os.environ["PLAXSWAP_KEY"])  # pxs_test_... or pxs_live_...
+
+payment = px.payments.create(
+    amount="100", currency="USD", receive="usdt-tron",
+    orderId="1042", description="2 x T-shirt", returnUrl="https://shop.example/orders/1042",
+    idempotency_key="order-1042",  # retries return the same payment
+)
+print(payment["checkoutUrl"])  # send the customer here
+```
+
+With a test key nothing real moves. Act out an outcome and get the same webhook a live payment sends:
+
+```python
+px.payments.simulate(payment["id"], "paid")
+```
+
+## Check the webhook (Flask)
+
+```python
+from flask import Flask, request
+from plaxswap import construct_event, WebhookSignatureError
+
+app = Flask(__name__)
+
+@app.post("/plaxswap-webhook")
+def webhook():
+    try:
+        event = construct_event(request.get_data(), request.headers.get("x-px-signature"), os.environ["PLAXSWAP_WEBHOOK_SECRET"])
+    except WebhookSignatureError:
+        return "", 400
+    # Skip events you have seen (event["id"]), then read the payment back before you ship:
+    payment = px.payments.retrieve(event["data"]["id"])
+    if payment["status"] == "paid":
+        pass  # fulfil order payment["orderId"]
+    return "", 200
+```
+
+## Quote a swap
+
+```python
+px = Plaxswap()  # no key needed for quotes
+routes = px.swap.routes("usdt-tron", "btc", "250")["routes"]
+```
+
+## Errors
+
+Every failed call raises `PlaxswapError` with `status`, a stable `code` (for example `invalid_api_key`) and a plain-English `message` that is safe to show.
+
+## Fees
+
+Gateway: the customer pays the 1.5% platform fee at checkout; you pay 0.3% plus the network fee when you withdraw. Swaps: Plaxswap's fee is at most 0.3%, plus the route's own fee. Current figures: [plaxswap.com/fees](https://plaxswap.com/fees).
+
+## Links
+
+- [Plaxswap](https://plaxswap.com)
+- [Payment gateway docs](https://plaxswap.com/developers/payments)
+- [OpenAPI document](https://plaxswap.com/api/v1/openapi.json)
+- [WooCommerce plugin](https://plaxswap.com/integrations/woocommerce)
+- Support: support@plaxswap.com
+
+MIT licence.

plaxswap-0.1.0/README.md

@@ -0,0 +1,83 @@
+# plaxswap
+
+The official Python client for the [Plaxswap](https://plaxswap.com) API.
+
+- **Accept crypto payments** on your site: create a payment, send the customer to the hosted checkout, and check the signed webhook. Docs: [Crypto payment gateway API](https://plaxswap.com/developers/payments).
+- **Payment links**: ask for an exact amount of one coin; the payer can use any supported coin. See [crypto payment links](https://plaxswap.com/pay).
+- **Swaps**: quote routes from KyberSwap, 0x, LI.FI, Relay and NEAR Intents, best return first, with every fee shown. See the [swap API guide](https://plaxswap.com/developers).
+
+Standard library only. Python 3.8+.
+
+## Install
+
+```bash
+pip install plaxswap
+```
+
+## Accept a payment
+
+```python
+import os
+from plaxswap import Plaxswap
+
+px = Plaxswap(api_key=os.environ["PLAXSWAP_KEY"])  # pxs_test_... or pxs_live_...
+
+payment = px.payments.create(
+    amount="100", currency="USD", receive="usdt-tron",
+    orderId="1042", description="2 x T-shirt", returnUrl="https://shop.example/orders/1042",
+    idempotency_key="order-1042",  # retries return the same payment
+)
+print(payment["checkoutUrl"])  # send the customer here
+```
+
+With a test key nothing real moves. Act out an outcome and get the same webhook a live payment sends:
+
+```python
+px.payments.simulate(payment["id"], "paid")
+```
+
+## Check the webhook (Flask)
+
+```python
+from flask import Flask, request
+from plaxswap import construct_event, WebhookSignatureError
+
+app = Flask(__name__)
+
+@app.post("/plaxswap-webhook")
+def webhook():
+    try:
+        event = construct_event(request.get_data(), request.headers.get("x-px-signature"), os.environ["PLAXSWAP_WEBHOOK_SECRET"])
+    except WebhookSignatureError:
+        return "", 400
+    # Skip events you have seen (event["id"]), then read the payment back before you ship:
+    payment = px.payments.retrieve(event["data"]["id"])
+    if payment["status"] == "paid":
+        pass  # fulfil order payment["orderId"]
+    return "", 200
+```
+
+## Quote a swap
+
+```python
+px = Plaxswap()  # no key needed for quotes
+routes = px.swap.routes("usdt-tron", "btc", "250")["routes"]
+```
+
+## Errors
+
+Every failed call raises `PlaxswapError` with `status`, a stable `code` (for example `invalid_api_key`) and a plain-English `message` that is safe to show.
+
+## Fees
+
+Gateway: the customer pays the 1.5% platform fee at checkout; you pay 0.3% plus the network fee when you withdraw. Swaps: Plaxswap's fee is at most 0.3%, plus the route's own fee. Current figures: [plaxswap.com/fees](https://plaxswap.com/fees).
+
+## Links
+
+- [Plaxswap](https://plaxswap.com)
+- [Payment gateway docs](https://plaxswap.com/developers/payments)
+- [OpenAPI document](https://plaxswap.com/api/v1/openapi.json)
+- [WooCommerce plugin](https://plaxswap.com/integrations/woocommerce)
+- Support: support@plaxswap.com
+
+MIT licence.

plaxswap-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "plaxswap"
+version = "0.1.0"
+description = "Official Plaxswap API client: accept crypto payments (hosted checkout, payment links, signed webhooks) and quote crypto swaps."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Plaxswap", email = "support@plaxswap.com" }]
+keywords = ["plaxswap", "crypto payments", "crypto payment gateway", "payment gateway", "bitcoin", "usdt", "stablecoin", "webhooks", "crypto swap"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Office/Business :: Financial",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://plaxswap.com"
+Documentation = "https://plaxswap.com/developers/payments"
+"API reference" = "https://plaxswap.com/api/v1/openapi.json"
+Source = "https://github.com/plaxswap-com/plaxswap-python"
+Issues = "https://github.com/plaxswap-com/plaxswap-python/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

plaxswap-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

plaxswap-0.1.0/src/plaxswap/__init__.py

@@ -0,0 +1,215 @@
+"""Official Python client for the Plaxswap API.
+
+Accept crypto payments (hosted checkout, payment links, signed webhooks) and quote crypto swaps.
+Docs: https://plaxswap.com/developers/payments and https://plaxswap.com/developers
+Standard library only (urllib, hmac, json). Python 3.8+.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Iterable, Optional, Union
+
+__all__ = ["Plaxswap", "PlaxswapError", "WebhookSignatureError", "verify_signature", "construct_event", "sign", "SIGNATURE_HEADER"]
+__version__ = "0.1.0"
+
+DEFAULT_BASE_URL = "https://plaxswap.com"
+SIGNATURE_HEADER = "x-px-signature"
+
+
+class PlaxswapError(Exception):
+    """An API error: HTTP status, the stable code and the plain-English message from the API."""
+
+    def __init__(self, status: int, code: str, message: str, details: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.details = details
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"PlaxswapError(status={self.status}, code={self.code!r}, message={self.message!r})"
+
+
+class Plaxswap:
+    """Client for https://plaxswap.com/api/v1.
+
+    api_key: a merchant key (pxs_test_... or pxs_live_...) for the payment gateway, or a partner key (pxk_...) for swaps.
+    Keep it on your server.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, base_url: str = DEFAULT_BASE_URL, user_ip: Optional[str] = None, timeout: float = 30.0):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.user_ip = user_ip
+        self.timeout = timeout
+        self.payments = _Payments(self)
+        self.payment_links = _PaymentLinks(self)
+        self.gateway = _Gateway(self)
+        self.swap = _Swap(self)
+
+    def meta(self) -> Dict[str, Any]:
+        """Service mode, the caller's country rules and time limits."""
+        return self.request("GET", "/api/v1/meta")
+
+    def coins(self) -> Dict[str, Any]:
+        """Coins, networks and methods."""
+        return self.request("GET", "/api/v1/coins")
+
+    def request(self, method: str, path: str, body: Any = None, query: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None) -> Any:
+        """Low-level call for any endpoint in https://plaxswap.com/api/v1/openapi.json"""
+        url = self.base_url + path
+        q = {k: v for k, v in (query or {}).items() if v is not None}
+        if q:
+            url += "?" + urllib.parse.urlencode(q)
+        h = {"Accept": "application/json", "User-Agent": f"plaxswap-python/{__version__}"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        if self.user_ip:
+            h["x-user-ip"] = self.user_ip
+        h.update(headers or {})
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+            h["Content-Type"] = "application/json"
+        req = urllib.request.Request(url, data=data, method=method, headers=h)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                text = res.read().decode("utf-8")
+                return json.loads(text) if text else None
+        except urllib.error.HTTPError as e:
+            text = e.read().decode("utf-8", "replace")
+            try:
+                err = (json.loads(text) or {}).get("error") or {}
+            except ValueError:
+                err = {}
+            raise PlaxswapError(e.code, err.get("code") or f"http_{e.code}", err.get("message") or text[:200] or str(e), err.get("details")) from None
+        except urllib.error.URLError as e:
+            raise PlaxswapError(0, "network_error", str(e.reason)) from None
+
+
+class _Payments:
+    def __init__(self, c: Plaxswap):
+        self._c = c
+
+    def create(self, idempotency_key: Optional[str] = None, **params: Any) -> Dict[str, Any]:
+        """Ask for a payment; send the payer to payment["checkoutUrl"].
+
+        Example: create(amount="100", currency="USD", receive="usdt-tron", orderId="1042", idempotency_key="order-1042")
+        """
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self._c.request("POST", "/api/v1/payments", body=params, headers=headers)
+
+    def retrieve(self, payment_id: str) -> Dict[str, Any]:
+        return self._c.request("GET", f"/api/v1/payments/{urllib.parse.quote(payment_id, safe='')}")
+
+    def list(self, **query: Any) -> Dict[str, Any]:
+        """Newest first. Filters: status, orderId, createdFrom, createdTo, limit, cursor."""
+        return self._c.request("GET", "/api/v1/payments", query=query)
+
+    def cancel(self, payment_id: str) -> Dict[str, Any]:
+        return self._c.request("POST", f"/api/v1/payments/{urllib.parse.quote(payment_id, safe='')}/cancel", body={})
+
+    def simulate(self, payment_id: str, outcome: str, pay_currency: Optional[str] = None) -> Dict[str, Any]:
+        """Test keys only: act out paid, partially_paid, overpaid, late, expired or failed."""
+        body: Dict[str, Any] = {"outcome": outcome}
+        if pay_currency:
+            body["payCurrency"] = pay_currency
+        return self._c.request("POST", f"/api/v1/payments/{urllib.parse.quote(payment_id, safe='')}/simulate", body=body)
+
+
+class _PaymentLinks:
+    def __init__(self, c: Plaxswap):
+        self._c = c
+
+    def create(self, **params: Any) -> Dict[str, Any]:
+        """Create a "pay me exactly this amount" link. Keep manageToken: it is shown once."""
+        return self._c.request("POST", "/api/v1/payment-links", body=params)
+
+    def retrieve(self, link_id: str) -> Dict[str, Any]:
+        return self._c.request("GET", f"/api/v1/payment-links/{urllib.parse.quote(link_id, safe='')}")
+
+    def coins(self) -> Dict[str, Any]:
+        return self._c.request("GET", "/api/v1/payment-links/coins")
+
+
+class _Gateway:
+    def __init__(self, c: Plaxswap):
+        self._c = c
+
+    def coins(self) -> Dict[str, Any]:
+        """Coins you can receive, and what payers can pay each with. No key needed."""
+        return self._c.request("GET", "/api/v1/gateway/coins")
+
+
+class _Swap:
+    def __init__(self, c: Plaxswap):
+        self._c = c
+
+    def coins(self) -> Dict[str, Any]:
+        return self._c.request("GET", "/api/v1/dex/coins")
+
+    def routes(self, from_: str, to: str, amount: str, **extra: Any) -> Dict[str, Any]:
+        """Routes for a pair and amount, best first. amount is a decimal string in coin units, for example "0.015"."""
+        body = {"from": from_, "to": to, "amount": amount, **extra}
+        return self._c.request("POST", "/api/v1/dex/routes", body=body)
+
+    def build(self, route_id: str) -> Dict[str, Any]:
+        return self._c.request("POST", "/api/v1/dex/build", body={"routeId": route_id})
+
+    def status(self, deposit_address: str) -> Dict[str, Any]:
+        return self._c.request("GET", "/api/v1/dex/status", query={"depositAddress": deposit_address})
+
+
+# ---------------------------------------------------------------- webhooks
+
+class WebhookSignatureError(Exception):
+    pass
+
+
+def _parse(header: Optional[str]):
+    t, v1 = None, []
+    for part in str(header or "").split(","):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k, v = k.strip(), v.strip()
+        if k == "t" and len(v) == 10 and v.isdigit():
+            t = v
+        if k == "v1" and len(v) == 64 and all(ch in "0123456789abcdef" for ch in v):
+            v1.append(v)
+    return t, v1
+
+
+def _b(raw: Union[str, bytes]) -> bytes:
+    return raw.encode("utf-8") if isinstance(raw, str) else raw
+
+
+def sign(raw_body: Union[str, bytes], secret: str, timestamp: Optional[int] = None) -> str:
+    """The header Plaxswap would send for this body (useful in your own tests)."""
+    t = int(timestamp if timestamp is not None else time.time())
+    mac = hmac.new(secret.encode("utf-8"), f"{t}.".encode("utf-8") + _b(raw_body), hashlib.sha256).hexdigest()
+    return f"t={t},v1={mac}"
+
+
+def verify_signature(raw_body: Union[str, bytes], header: Optional[str], secret: str, tolerance: int = 300, now: Optional[float] = None) -> bool:
+    """True when x-px-signature is valid for this exact raw body and was signed within `tolerance` seconds."""
+    t, v1 = _parse(header)
+    if not t or not v1 or not secret:
+        return False
+    if abs((now if now is not None else time.time()) - int(t)) > tolerance:
+        return False
+    expected = hmac.new(secret.encode("utf-8"), f"{t}.".encode("utf-8") + _b(raw_body), hashlib.sha256).hexdigest()
+    return any(hmac.compare_digest(sig, expected) for sig in v1)
+
+
+def construct_event(raw_body: Union[str, bytes], header: Optional[str], secret: str, tolerance: int = 300) -> Dict[str, Any]:
+    """Checks the signature, then parses the event ({"id", "event", "livemode", "createdAt", "data"})."""
+    if not verify_signature(raw_body, header, secret, tolerance):
+        raise WebhookSignatureError("Invalid or expired Plaxswap webhook signature")
+    return json.loads(_b(raw_body).decode("utf-8"))

plaxswap-0.1.0/src/plaxswap.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: plaxswap
+Version: 0.1.0
+Summary: Official Plaxswap API client: accept crypto payments (hosted checkout, payment links, signed webhooks) and quote crypto swaps.
+Author-email: Plaxswap <support@plaxswap.com>
+License: MIT
+Project-URL: Homepage, https://plaxswap.com
+Project-URL: Documentation, https://plaxswap.com/developers/payments
+Project-URL: API reference, https://plaxswap.com/api/v1/openapi.json
+Project-URL: Source, https://github.com/plaxswap-com/plaxswap-python
+Project-URL: Issues, https://github.com/plaxswap-com/plaxswap-python/issues
+Keywords: plaxswap,crypto payments,crypto payment gateway,payment gateway,bitcoin,usdt,stablecoin,webhooks,crypto swap
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# plaxswap
+
+The official Python client for the [Plaxswap](https://plaxswap.com) API.
+
+- **Accept crypto payments** on your site: create a payment, send the customer to the hosted checkout, and check the signed webhook. Docs: [Crypto payment gateway API](https://plaxswap.com/developers/payments).
+- **Payment links**: ask for an exact amount of one coin; the payer can use any supported coin. See [crypto payment links](https://plaxswap.com/pay).
+- **Swaps**: quote routes from KyberSwap, 0x, LI.FI, Relay and NEAR Intents, best return first, with every fee shown. See the [swap API guide](https://plaxswap.com/developers).
+
+Standard library only. Python 3.8+.
+
+## Install
+
+```bash
+pip install plaxswap
+```
+
+## Accept a payment
+
+```python
+import os
+from plaxswap import Plaxswap
+
+px = Plaxswap(api_key=os.environ["PLAXSWAP_KEY"])  # pxs_test_... or pxs_live_...
+
+payment = px.payments.create(
+    amount="100", currency="USD", receive="usdt-tron",
+    orderId="1042", description="2 x T-shirt", returnUrl="https://shop.example/orders/1042",
+    idempotency_key="order-1042",  # retries return the same payment
+)
+print(payment["checkoutUrl"])  # send the customer here
+```
+
+With a test key nothing real moves. Act out an outcome and get the same webhook a live payment sends:
+
+```python
+px.payments.simulate(payment["id"], "paid")
+```
+
+## Check the webhook (Flask)
+
+```python
+from flask import Flask, request
+from plaxswap import construct_event, WebhookSignatureError
+
+app = Flask(__name__)
+
+@app.post("/plaxswap-webhook")
+def webhook():
+    try:
+        event = construct_event(request.get_data(), request.headers.get("x-px-signature"), os.environ["PLAXSWAP_WEBHOOK_SECRET"])
+    except WebhookSignatureError:
+        return "", 400
+    # Skip events you have seen (event["id"]), then read the payment back before you ship:
+    payment = px.payments.retrieve(event["data"]["id"])
+    if payment["status"] == "paid":
+        pass  # fulfil order payment["orderId"]
+    return "", 200
+```
+
+## Quote a swap
+
+```python
+px = Plaxswap()  # no key needed for quotes
+routes = px.swap.routes("usdt-tron", "btc", "250")["routes"]
+```
+
+## Errors
+
+Every failed call raises `PlaxswapError` with `status`, a stable `code` (for example `invalid_api_key`) and a plain-English `message` that is safe to show.
+
+## Fees
+
+Gateway: the customer pays the 1.5% platform fee at checkout; you pay 0.3% plus the network fee when you withdraw. Swaps: Plaxswap's fee is at most 0.3%, plus the route's own fee. Current figures: [plaxswap.com/fees](https://plaxswap.com/fees).
+
+## Links
+
+- [Plaxswap](https://plaxswap.com)
+- [Payment gateway docs](https://plaxswap.com/developers/payments)
+- [OpenAPI document](https://plaxswap.com/api/v1/openapi.json)
+- [WooCommerce plugin](https://plaxswap.com/integrations/woocommerce)
+- Support: support@plaxswap.com
+
+MIT licence.

plaxswap-0.1.0/src/plaxswap.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/plaxswap/__init__.py
+src/plaxswap.egg-info/PKG-INFO
+src/plaxswap.egg-info/SOURCES.txt
+src/plaxswap.egg-info/dependency_links.txt
+src/plaxswap.egg-info/top_level.txt
+tests/test_plaxswap.py

plaxswap-0.1.0/src/plaxswap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

plaxswap-0.1.0/src/plaxswap.egg-info/top_level.txt

@@ -0,0 +1 @@
+plaxswap

plaxswap-0.1.0/tests/test_plaxswap.py

@@ -0,0 +1,60 @@
+import hashlib, hmac, json, unittest
+from unittest import mock
+import plaxswap
+from plaxswap import Plaxswap, PlaxswapError, verify_signature, construct_event, sign
+
+SECRET = "whsec_test_123"
+BODY = '{"id":"evt_3k9q2m7x8c1v5b4n","event":"payment.paid","livemode":false,"data":{"id":"pay_7m2k9q4x8c1v5b3n","object":"payment","status":"paid"}}'
+T = 1794000000
+HEX = hmac.new(SECRET.encode(), f"{T}.{BODY}".encode(), hashlib.sha256).hexdigest()
+
+
+class Webhooks(unittest.TestCase):
+    def test_valid(self): self.assertTrue(verify_signature(BODY, f"t={T},v1={HEX}", SECRET, now=T + 10))
+    def test_bytes_body(self): self.assertTrue(verify_signature(BODY.encode(), f"t={T},v1={HEX}", SECRET, now=T))
+    def test_several_v1(self): self.assertTrue(verify_signature(BODY, f"t={T},v1={'0'*64},v1={HEX}", SECRET, now=T))
+    def test_changed_body(self): self.assertFalse(verify_signature(BODY + " ", f"t={T},v1={HEX}", SECRET, now=T))
+    def test_old(self): self.assertFalse(verify_signature(BODY, f"t={T},v1={HEX}", SECRET, now=T + 301))
+    def test_wrong_secret(self): self.assertFalse(verify_signature(BODY, f"t={T},v1={HEX}", "whsec_other", now=T))
+    def test_missing(self): self.assertFalse(verify_signature(BODY, None, SECRET))
+    def test_sign(self): self.assertEqual(sign(BODY, SECRET, T), f"t={T},v1={HEX}")
+    def test_construct(self):
+        ev = construct_event(BODY, sign(BODY, SECRET), SECRET)
+        self.assertEqual(ev["event"], "payment.paid"); self.assertEqual(ev["data"]["id"], "pay_7m2k9q4x8c1v5b3n")
+    def test_construct_bad(self):
+        with self.assertRaises(plaxswap.WebhookSignatureError): construct_event(BODY, "t=1,v1=x", SECRET)
+
+
+class FakeResp:
+    def __init__(self, body): self.body = body
+    def read(self): return json.dumps(self.body).encode()
+    def __enter__(self): return self
+    def __exit__(self, *a): return False
+
+
+class Client(unittest.TestCase):
+    def test_create_payment(self):
+        seen = {}
+        def fake(req, timeout=None):
+            seen["url"], seen["method"], seen["headers"], seen["body"] = req.full_url, req.get_method(), dict(req.header_items()), json.loads(req.data)
+            return FakeResp({"id": "pay_0000000000000001", "object": "payment", "status": "pending"})
+        with mock.patch("urllib.request.urlopen", fake):
+            p = Plaxswap(api_key="pxs_test_x").payments.create(amount="100", currency="USD", receive="usdt-tron", orderId="1042", idempotency_key="order-1042")
+        self.assertEqual(p["id"], "pay_0000000000000001")
+        self.assertEqual(seen["url"], "https://plaxswap.com/api/v1/payments")
+        self.assertEqual(seen["method"], "POST")
+        self.assertEqual(seen["headers"]["Authorization"], "Bearer pxs_test_x")
+        self.assertEqual(seen["headers"]["Idempotency-key"], "order-1042")
+        self.assertEqual(seen["body"], {"amount": "100", "currency": "USD", "receive": "usdt-tron", "orderId": "1042"})
+
+    def test_error(self):
+        import urllib.error, io
+        def fake(req, timeout=None):
+            raise urllib.error.HTTPError(req.full_url, 401, "Unauthorized", {}, io.BytesIO(b'{"error":{"code":"invalid_api_key","message":"That key is wrong."}}'))
+        with mock.patch("urllib.request.urlopen", fake):
+            with self.assertRaises(PlaxswapError) as cm: Plaxswap(api_key="bad").payments.retrieve("pay_x")
+        self.assertEqual((cm.exception.status, cm.exception.code), (401, "invalid_api_key"))
+
+
+if __name__ == "__main__":
+    unittest.main()