epoint-python-sdk 0.2.0__py3-none-any.whl

epoint_python_sdk-0.2.0.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.5
+Name: epoint-python-sdk
+Version: 0.2.0
+Summary: Typed Python client for the Epoint (epoint.az) payment gateway, sync and async, safe against double charges.
+Project-URL: Homepage, https://theqiyas.cc/projects/epoint-python-sdk/
+Project-URL: Source, https://github.com/qiyascc/epoint-python-sdk
+Project-URL: Author, https://theqiyas.cc
+Project-URL: Issues, https://github.com/qiyascc/epoint-python-sdk/issues
+Project-URL: Changelog, https://github.com/qiyascc/epoint-python-sdk/blob/main/CHANGELOG.md
+Author-email: qiyascc <qiyasturk@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: azerbaijan,azn,checkout,epoint,gateway,payment,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: goodconf>=7.1
+Requires-Dist: httpx<1,>=0.24
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6
+Provides-Extra: dev
+Requires-Dist: goodconf[toml]>=7.1; extra == 'dev'
+Requires-Dist: goodconf[yaml]>=7.1; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Provides-Extra: toml
+Requires-Dist: goodconf[toml]>=7.1; extra == 'toml'
+Provides-Extra: yaml
+Requires-Dist: goodconf[yaml]>=7.1; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# epoint-python-sdk
+
+[![Python](https://img.shields.io/badge/python-3.10%20to%203.13-3776AB?logo=python&logoColor=white)](https://www.python.org)
+[![Epoint](https://img.shields.io/badge/gateway-epoint.az-0B5FFF)](https://epoint.az)
+[![Typed](https://img.shields.io/badge/typing-mypy-2A6DB2)](https://mypy-lang.org)
+[![Async](https://img.shields.io/badge/sync%20%2B%20async-httpx-5A45FF)](https://www.python-httpx.org)
+[![Ruff](https://img.shields.io/badge/lint-ruff-D7FF64?logo=ruff&logoColor=black)](https://docs.astral.sh/ruff)
+[![Apple Pay](https://img.shields.io/badge/Apple%20Pay-supported-000000?logo=applepay&logoColor=white)](#apple-pay-and-google-pay)
+[![Google Pay](https://img.shields.io/badge/Google%20Pay-supported-4285F4?logo=googlepay&logoColor=white)](#apple-pay-and-google-pay)
+[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/qiyascc/epoint-python-sdk/blob/main/LICENSE)
+
+Typed Python client for the [Epoint](https://epoint.az) payment gateway. Sync and async, every endpoint, signed callbacks, and retry rules built so a payment is never sent twice.
+
+```bash
+pip install epoint-python-sdk
+```
+
+## Pay
+
+```python
+from epoint_sdk import Epoint
+
+with Epoint("i000000001", "PRIVATE_KEY", success_url="https://shop.az/ok", error_url="https://shop.az/fail") as ep:
+    checkout = ep.payments.create("19.90", "ORDER-1042", description="Pro plan")
+    redirect(checkout.redirect_url)
+```
+
+## Confirm
+
+```python
+tx = ep.verify_callback(request.POST)
+if tx.paid:
+    fulfil(tx.order_id, tx.amount, tx.transaction)
+```
+
+Never trust the redirect alone. Use the signed callback, or ask the gateway:
+
+```python
+ep.payments.status(checkout.transaction).paid
+```
+
+## Apple Pay and Google Pay
+
+```python
+widget = ep.widgets.create("19.90", "ORDER-1043", "Pro plan")
+```
+
+```html
+<iframe src="{{ widget.widget_url }}" allow="payment" title="Apple Pay / Google Pay"></iframe>
+<script>
+addEventListener("message", (e) => {
+  if (e.origin !== "{{ widget.origin }}") return;
+  fetch("/orders/1043/check/", { method: "POST" });
+});
+</script>
+```
+
+The page needs `Permissions-Policy: payment=(self "https://epoint.az")`. The `postMessage` is a hint only: `WidgetMessage.from_event(data)` reads it, then confirm on the server with `ep.payments.status(widget.transaction)` or the signed callback. Epoint enables token payments per merchant. `ep.widgets.split(...)` is the split variant.
+
+## Safety
+
+| Situation | What the client does |
+| --- | --- |
+| Connection refused, nothing sent | Retries, then `NotSentError` |
+| Timeout, cut connection or 5xx on a call that moves money | No retry, `OutcomeUnknownError` with the `order_id` |
+| Same failure on a read (status, card, lists) | Retries with backoff |
+| 429 | Retries, the gateway did not process it |
+| `status: error` from the gateway | `GatewayError` with `code` and `trace_id` |
+| Declined card on a direct charge | Returns `Transaction` with `failed`, never raises |
+| Amount like `1.005`, `0`, `NaN` or `True` | `InvalidRequestError` before anything is sent |
+| `base_url` over plain http | `ConfigurationError`, except localhost or `allow_insecure_http` |
+| Callback `data` over 64 KB | Rejected before hashing |
+| Callback for another order or amount | `tx.matches(order_id=..., amount=...)` is `False` |
+
+Reuse the same `order_id` when you retry. Epoint refuses a used one, so a double click or a crash can not charge twice. Amounts are `Decimal` end to end, and signatures are compared in constant time.
+
+## Endpoints
+
+| Namespace | Methods |
+| --- | --- |
+| `payments` | `create` `form` `status` `reverse` `hold` `capture` |
+| `cards` | `register` `register_and_pay` `charge` `status` `payout` |
+| `split` | `create` `charge` `register_and_pay` |
+| `installments` | `plans` `create` |
+| `wallets` | `list` `pay` |
+| `widgets` | `create` `split` (Apple Pay, Google Pay) |
+| `invoices` | `create` `update` `get` `list` `send_sms` `send_email` |
+| `transfers` | `create` `status` (B2B) |
+| client | `heartbeat` `verify_callback` `request` |
+
+`AsyncEpoint` has the same methods, awaited.
+
+## Config
+
+Pass values in code, or set `EPOINT_PUBLIC_KEY`, `EPOINT_PRIVATE_KEY`, `EPOINT_SUCCESS_URL`, `EPOINT_ERROR_URL`, `EPOINT_LANGUAGE`, `EPOINT_TIMEOUT`, `EPOINT_MAX_RETRIES`, or put them in `epoint.toml`. Every path is a setting (`EPOINT_ENDPOINTS__PAYMENT=...`) and `base_url` can point at a sandbox such as [epoint-sandbox](https://github.com/martian56/epoint-sandbox). Messages live in `messages.yaml` and can be replaced with `messages.use(...)`.
+
+## Develop
+
+```bash
+pip install -e ".[dev]" && pytest && ruff check . && mypy src
+```
+
+## Links
+
+- Source code: [github.com/qiyascc/epoint-python-sdk](https://github.com/qiyascc/epoint-python-sdk)
+- PyPI: [pypi.org/project/epoint-python-sdk](https://pypi.org/project/epoint-python-sdk/)
+- Project page: [theqiyas.cc/projects/epoint-python-sdk](https://theqiyas.cc/projects/epoint-python-sdk/)
+- Author: [Qiyas Sadıqov](https://theqiyas.cc), more projects at [theqiyas.cc](https://theqiyas.cc)
+
+## License
+
+MIT

epoint_python_sdk-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+epoint_sdk/__init__.py,sha256=WYFCCz55UnbNnEjfKIHHwmKXyNrnJVAcZ0uR-TtLVVU,1437
+epoint_sdk/_core.py,sha256=AuaYPignhuMOFngYyNXGR3alE4GTU6zHVUDqlcX3yAY,8803
+epoint_sdk/_version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+epoint_sdk/callbacks.py,sha256=tAkpr98K_tnsCjQ943I0-aaoSt1ghCfnLgXrRUPXHBY,1021
+epoint_sdk/client.py,sha256=MYDPrbxPT9h7sboDUpsd3T9qKCm9wsbuNykJLWAEi3M,2019
+epoint_sdk/config.py,sha256=18Gcsdk3GGFVmbuKQDGWRDBGWwniNFO1ZHenLxA-pX0,5084
+epoint_sdk/enums.py,sha256=RCCUEeUwTwKhxqxBah64-_fC84YvtcWc6n_17hKDl6A,1185
+epoint_sdk/errors.py,sha256=2Xa9GwYhom4jDlS1XO69neubPlQEWVJbzalnYots30E,1863
+epoint_sdk/messages.py,sha256=GqqTi5PvVlt2G-F6llTb3_gMTlRgVj4DHMUXZQzr7ZY,1601
+epoint_sdk/messages.yaml,sha256=NnpfG5laHqoIn7I_9Ok5Qs-Rp23zuM15wZB48ArCY1I,2419
+epoint_sdk/models.py,sha256=45ElUKtm3HeiYqdfgSifoWEZfQ_PhSqKhBdqBlnSr0Y,9262
+epoint_sdk/money.py,sha256=sgmV7wT0Q_khLGY7pO--LAyJDPMwEdJXspuNsxSG03Y,1443
+epoint_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epoint_sdk/resources.py,sha256=IamTdeJTgjab5A3I8KOyc-S4YXG-RDzOJxC9LBnX9RU,19984
+epoint_sdk/signing.py,sha256=ZHDgS9D5gjFhITB_GSoFq8pHGE43dNdZW8LjYVdT_R0,1552
+epoint_python_sdk-0.2.0.dist-info/METADATA,sha256=eaNaIf7tbmeJ3E7RR0QULF6eJ8i1goxEH34drqFzrIU,6847
+epoint_python_sdk-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+epoint_python_sdk-0.2.0.dist-info/licenses/LICENSE,sha256=ENVL-_Eh4n1SumZuLuTjO2K0OOL_eXh4pkeme35b02I,1064
+epoint_python_sdk-0.2.0.dist-info/RECORD,,

epoint_python_sdk-0.2.0.dist-info/WHEEL

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

epoint_python_sdk-0.2.0.dist-info/licenses/LICENSE

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

epoint_sdk/__init__.py

@@ -0,0 +1,73 @@
+from . import messages, signing
+from ._version import __version__
+from .callbacks import callback_form, verify_callback
+from .client import AsyncEpoint, Epoint
+from .config import Settings, load_settings
+from .enums import CardStatus, Currency, Language, OperationCode, Status
+from .errors import (
+    ConfigurationError,
+    EpointError,
+    GatewayError,
+    HTTPStatusError,
+    InvalidRequestError,
+    NotSentError,
+    OutcomeUnknownError,
+    SignatureError,
+    TransportError,
+)
+from .models import (
+    Callback,
+    Card,
+    CardRegistration,
+    CheckoutForm,
+    InstallmentPlan,
+    Invoice,
+    Redirect,
+    Result,
+    Transaction,
+    Transfer,
+    Wallet,
+    Widget,
+    WidgetMessage,
+    origin_of,
+)
+
+__all__ = [
+    "__version__",
+    "Epoint",
+    "AsyncEpoint",
+    "Settings",
+    "load_settings",
+    "messages",
+    "signing",
+    "verify_callback",
+    "callback_form",
+    "Status",
+    "CardStatus",
+    "Currency",
+    "Language",
+    "OperationCode",
+    "Callback",
+    "Card",
+    "CardRegistration",
+    "CheckoutForm",
+    "InstallmentPlan",
+    "Invoice",
+    "Redirect",
+    "Result",
+    "Transaction",
+    "Transfer",
+    "Wallet",
+    "Widget",
+    "WidgetMessage",
+    "origin_of",
+    "EpointError",
+    "ConfigurationError",
+    "InvalidRequestError",
+    "SignatureError",
+    "TransportError",
+    "NotSentError",
+    "OutcomeUnknownError",
+    "HTTPStatusError",
+    "GatewayError",
+]

epoint_sdk/_core.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Mapping, Optional, TypeVar
+
+import httpx
+
+from . import signing
+from .config import Settings, load_settings
+from .enums import Status
+from .errors import GatewayError, HTTPStatusError, NotSentError, OutcomeUnknownError, TransportError
+from .messages import text
+
+T = TypeVar("T")
+
+NOT_SENT = (httpx.ConnectError, httpx.ConnectTimeout, httpx.PoolTimeout, httpx.UnsupportedProtocol)
+RETRY_STATUSES = frozenset({429, 500, 502, 503, 504})
+
+
+@dataclass
+class Op:
+    endpoint: str
+    payload: Optional[dict[str, Any]] = None
+    parse: Callable[[Any], Any] = lambda body: body
+    safe: bool = False
+    method: str = "POST"
+    signed: bool = True
+    json_body: bool = False
+    path_params: Mapping[str, Any] = field(default_factory=dict)
+    payment_state: bool = False
+    order_id: Optional[str] = None
+
+
+def clean(payload: Mapping[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in payload.items() if value is not None and value != ""}
+
+
+class Outcome:
+    def __init__(self, value: Any = None, error: Optional[Exception] = None, retry: bool = False) -> None:
+        self.value = value
+        self.error = error
+        self.retry = retry
+
+
+class Engine:
+    def __init__(
+        self,
+        public_key: Optional[str] = None,
+        private_key: Optional[str] = None,
+        *,
+        settings: Optional[Settings] = None,
+        config_file: Optional[str] = None,
+        **overrides: Any,
+    ) -> None:
+        if settings is None:
+            settings = load_settings(config_file, public_key=public_key, private_key=private_key, **overrides)
+        elif public_key or private_key or overrides:
+            changes = {k: v for k, v in dict(overrides, public_key=public_key, private_key=private_key).items()
+                       if v is not None}
+            current = settings.model_dump()
+            current["private_key"] = settings.private_key.get_secret_value()
+            settings = load_settings(None, **{**current, **changes})
+        self.settings = settings
+        settings.check_transport()
+        self.public_key, self._private_key = settings.keys()
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(public_key={self.public_key!r}, base_url={self.settings.base_url!r})"
+
+    def _timeout(self) -> httpx.Timeout:
+        return httpx.Timeout(self.settings.timeout, connect=self.settings.connect_timeout)
+
+    def _headers(self) -> dict[str, str]:
+        return {"Accept": "application/json", "User-Agent": self.settings.resolved_user_agent()}
+
+    def sign(self, payload: Mapping[str, Any]) -> dict[str, str]:
+        body = {"public_key": self.public_key, **clean(payload)}
+        data = signing.encode(body)
+        return {"data": data, "signature": signing.sign(self._private_key, data)}
+
+    def _request_args(self, op: Op) -> dict[str, Any]:
+        args: dict[str, Any] = {"headers": self._headers()}
+        if op.method == "POST":
+            body = self.sign(op.payload or {}) if op.signed else clean(op.payload or {})
+            args["json" if op.json_body else "data"] = body
+        return args
+
+    def _wait(self, attempt: int) -> float:
+        base = self.settings.backoff_base
+        return min(self.settings.backoff_cap, base * (2 ** attempt)) + random.uniform(0, base / 2)
+
+    def _on_exception(self, op: Op, exc: Exception, attempt: int) -> Outcome:
+        path = self.settings.url(op.endpoint, **op.path_params)
+        if isinstance(exc, NOT_SENT):
+            if attempt < self.settings.max_retries:
+                return Outcome(retry=True)
+            return Outcome(error=NotSentError(text("error.connect", error=exc), path=path, order_id=op.order_id))
+        if op.safe:
+            if attempt < self.settings.max_retries:
+                return Outcome(retry=True)
+            return Outcome(error=TransportError(text("error.timeout", error=exc), path=path, order_id=op.order_id))
+        return Outcome(error=OutcomeUnknownError(text("error.unknown_outcome", reason=type(exc).__name__), path=path,
+                                                 order_id=op.order_id))
+
+    def _on_response(self, op: Op, response: httpx.Response, attempt: int) -> Outcome:
+        path = self.settings.url(op.endpoint, **op.path_params)
+        status = response.status_code
+        if status in RETRY_STATUSES and (op.safe or status == 429) and attempt < self.settings.max_retries:
+            return Outcome(retry=True)
+        if status >= 500 and not op.safe:
+            return Outcome(error=OutcomeUnknownError(text("error.unknown_outcome", reason=f"HTTP {status}"),
+                                                     status_code=status, path=path, order_id=op.order_id))
+        try:
+            body = response.json()
+        except ValueError:
+            snippet = response.text[:200]
+            if status < 400 and not op.safe:
+                return Outcome(error=OutcomeUnknownError(text("error.body", body=snippet), status_code=status,
+                                                         path=path, order_id=op.order_id))
+            return Outcome(error=HTTPStatusError(text("error.body", body=snippet), status_code=status, body=snippet,
+                                                 path=path))
+        if isinstance(body, dict):
+            refused = Status.of(body.get("status")) is Status.ERROR
+            if refused and not (op.payment_state and body.get("transaction")):
+                message = str(body.get("message") or body.get("detail") or text("error.refused"))
+                code = body.get("code")
+                return Outcome(error=GatewayError(message, code=str(code) if code not in (None, "") else None,
+                                                  trace_id=body.get("trace_id"), status_code=status, payload=body,
+                                                  path=path))
+        if status >= 400:
+            detail = body.get("detail") or body.get("message") if isinstance(body, dict) else None
+            return Outcome(error=HTTPStatusError(str(detail or text("error.status", status=status)), status_code=status,
+                                                 body=body, path=path))
+        return Outcome(value=op.parse(body))
+
+
+class SyncEngine(Engine):
+    def __init__(self, *args: Any, http_client: Optional[httpx.Client] = None, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._owns_http = http_client is None
+        self._http = http_client or httpx.Client(timeout=self._timeout())
+
+    def close(self) -> None:
+        if self._owns_http:
+            self._http.close()
+
+    def __enter__(self: T) -> T:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def _run(self, op: Op) -> Any:
+        url = self.settings.url(op.endpoint, **op.path_params)
+        args = self._request_args(op)
+        attempt = 0
+        while True:
+            try:
+                response = self._http.request(op.method, url, **args)
+            except httpx.HTTPError as exc:
+                outcome = self._on_exception(op, exc, attempt)
+            else:
+                outcome = self._on_response(op, response, attempt)
+            if outcome.retry:
+                time.sleep(self._wait(attempt))
+                attempt += 1
+                continue
+            if outcome.error is not None:
+                raise outcome.error
+            return outcome.value
+
+
+class AsyncEngine(Engine):
+    def __init__(self, *args: Any, http_client: Optional[httpx.AsyncClient] = None, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._owns_http = http_client is None
+        self._http = http_client or httpx.AsyncClient(timeout=self._timeout())
+
+    async def close(self) -> None:
+        if self._owns_http:
+            await self._http.aclose()
+
+    async def __aenter__(self: T) -> T:
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+    async def _run(self, op: Op) -> Any:
+        url = self.settings.url(op.endpoint, **op.path_params)
+        args = self._request_args(op)
+        attempt = 0
+        while True:
+            try:
+                response = await self._http.request(op.method, url, **args)
+            except httpx.HTTPError as exc:
+                outcome = self._on_exception(op, exc, attempt)
+            else:
+                outcome = self._on_response(op, response, attempt)
+            if outcome.retry:
+                await asyncio.sleep(self._wait(attempt))
+                attempt += 1
+                continue
+            if outcome.error is not None:
+                raise outcome.error
+            return outcome.value

epoint_sdk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

epoint_sdk/callbacks.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Union
+
+from . import signing
+from .errors import SignatureError
+from .messages import text
+from .models import Transaction
+
+Form = Mapping[str, Any]
+
+
+def _field(form: Form, key: str) -> str:
+    value = form.get(key)
+    if isinstance(value, (list, tuple)):
+        value = value[0] if value else ""
+    return str(value or "").strip()
+
+
+def verify_callback(private_key: str, data: Union[str, Form], signature: str = "") -> Transaction:
+    raw = data if isinstance(data, str) else _field(data, "data")
+    if not isinstance(data, str):
+        signature = _field(data, "signature")
+    if not raw or not signature:
+        raise SignatureError(text("error.callback_fields"))
+    return Transaction.from_api(signing.verify(private_key, raw, signature))
+
+
+def callback_form(private_key: str, payload: Mapping[str, Any]) -> dict[str, str]:
+    data = signing.encode(dict(payload))
+    return {"data": data, "signature": signing.sign(private_key, data)}

epoint_sdk/client.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, Union
+
+from ._core import AsyncEngine, Op, SyncEngine
+from .callbacks import verify_callback
+from .models import Transaction
+from .resources import Cards, Installments, Invoices, Payments, Split, Transfers, Wallets, Widgets
+
+
+def _alive(body: Any) -> bool:
+    return isinstance(body, Mapping) and str(body.get("status", "")).lower() == "ok"
+
+
+class _Namespaces:
+    _private_key: str
+
+    def _mount(self) -> None:
+        self.payments = Payments(self)
+        self.cards = Cards(self)
+        self.split = Split(self)
+        self.installments = Installments(self)
+        self.wallets = Wallets(self)
+        self.widgets = Widgets(self)
+        self.invoices = Invoices(self)
+        self.transfers = Transfers(self)
+
+    def verify_callback(self, data: Union[str, Mapping[str, Any]], signature: str = "") -> Transaction:
+        return verify_callback(self._private_key, data, signature)
+
+
+class Epoint(SyncEngine, _Namespaces):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._mount()
+
+    def heartbeat(self) -> bool:
+        result: bool = self._run(Op("heartbeat", None, _alive, safe=True, method="GET", signed=False))
+        return result
+
+    def request(self, endpoint: str, payload: Optional[Mapping[str, Any]] = None, *, safe: bool = False) -> Any:
+        return self._run(Op(endpoint, dict(payload or {}), safe=safe))
+
+
+class AsyncEpoint(AsyncEngine, _Namespaces):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._mount()
+
+    async def heartbeat(self) -> bool:
+        result: bool = await self._run(Op("heartbeat", None, _alive, safe=True, method="GET", signed=False))
+        return result
+
+    async def request(self, endpoint: str, payload: Optional[Mapping[str, Any]] = None, *, safe: bool = False) -> Any:
+        return await self._run(Op(endpoint, dict(payload or {}), safe=safe))