dominusnode 2.0.0__tar.gz

dominusnode-2.0.0/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [2.0.0] - 2026-11-06
+
+Breaking: rewritten for the v2 relay-network contract (`sdks/SDK_SURFACE.md`, reference `sdks/node` 2.0.0).
+
+### Added
+- 15 resources and 71 methods, the same in `DominusNodeClient` and `AsyncDominusNodeClient`: `network`, `nodes` (with PoW and attestation registration), `credits` (µUSD convert and withdraw), `payout_wallet`, `payouts`, `sessions.report` and `wallet_auth.sign_in`.
+- EIP-191 signer callbacks. The SDK rebuilds the node-attestation, payout-wallet and withdrawal messages itself and refuses to sign a server message that differs (`ProtocolError`).
+- `proxy.build_username`/`build_url` with `country-XX` (OFAC refused), `class-…`, `session-…`, `wallet-<uuid>` and `allowhttp-1`.
+- `proxy.fetch` for GET/HEAD through the gateway, with an SSRF guard (private IPs in every spelling, local names) and a DNS-rebinding check.
+- `Secret` wrapper for one-time credentials, `ProtocolError` and `ProxyError`, error `code` and `details`.
+- Credential scrubbing now also covers `dn_node_`/`dn_proxy_` keys and JWTs.
+
+### Changed
+- Redirects are refused and API responses are capped at 10 MB, by Content-Length and by the bytes actually read.
+- 429 is retried once, waiting min(Retry-After, 10 s) ±10 % with a 100 ms floor. 401 triggers one JWT refresh, shared by concurrent callers.
+- `/v1` agent routes send the raw API key.
+- `disconnect()` clears the API key and both tokens. The token manager keeps its refresh callback.
+- Amounts must be integers. Floats, NaN, Infinity and bools are rejected.
+
+### Removed
+- Plans, slots and waitlist, admin, Stripe and PayPal top-ups, email/password login and registration, human MFA, `connect_with_credentials`, `complete_mfa`, `proxy.get_status`, the legacy `dc-`/`residential-`/`auto-` username prefixes, `state-`/`city-`/`asn-` targeting, and all hardcoded prices.
+- The `respx` dev dependency. Tests use `httpx.MockTransport`.
+
+## [1.0.0] - 2026-02-19
+
+### Added
+- Initial release of the Dominus Node SDK for Python.
+- Async client (`AsyncDominusNodeClient`) built on `httpx` for asyncio-based usage.
+- Sync client (`DominusNodeClient`) for synchronous usage with identical API surface.
+- Both clients support context manager protocol (`with` / `async with`) for automatic cleanup.
+- Requires Python 3.9+.
+- Authentication via API key (`connect_with_key`), email/password with MFA support (`connect_with_credentials`, `complete_mfa`), and pre-authenticated JWT tokens (`connect_with_tokens`).
+- `AuthResource` / `AsyncAuthResource` for registration, login, MFA setup/verification, password reset, email verification, and account profile management.
+- `WalletResource` / `AsyncWalletResource` for balance retrieval, transaction history, Stripe checkout session creation, and crypto invoice creation supporting 11 currencies (BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK).
+- `UsageResource` / `AsyncUsageResource` for usage summaries, daily breakdown, top hosts, and CSV export.
+- `KeysResource` / `AsyncKeysResource` for creating, listing, and revoking API keys.
+- `PlansResource` / `AsyncPlansResource` for listing available plans, retrieving the current plan, and changing plans.
+- `ProxyResource` / `AsyncProxyResource` for building proxy URLs with geo-targeting (country, state, city, ASN, session ID) and proxy health/status monitoring.
+- `SessionsResource` / `AsyncSessionsResource` for listing active proxy sessions.
+- `AgenticWalletResource` / `AsyncAgenticWalletResource` for creating, funding, listing, querying transactions, freezing, unfreezing, and deleting agentic sub-wallets.
+- `TeamsResource` / `AsyncTeamsResource` with 18 methods for team CRUD, shared wallet management, member management (add, remove, update role), invite management (create, list, cancel, accept), team API key creation and revocation, and team usage and transaction queries.
+- `SlotsResource` / `AsyncSlotsResource` for checking alpha slot availability, joining the waitlist, and checking waitlist position.
+- `AdminResource` / `AsyncAdminResource` for admin-only operations including user management, system stats, revenue reporting, and provider statistics.
+- `TokenManager` / `AsyncTokenManager` with automatic JWT access token refresh using rotating refresh tokens (15-minute access / 7-day refresh).
+- Rate limit handling with exponential backoff, jitter (plus/minus 10%), 10-second max wait cap, and 100ms minimum wait.
+- Typed error hierarchy: `DominusNodeError`, `AuthenticationError`, `AuthorizationError`, `ValidationError`, `NotFoundError`, `ConflictError`, `RateLimitError`, `InsufficientBalanceError`, `ProxyError`, `NetworkError`, `ServerError`.
+- Credential safety: automatic zeroization on `disconnect()`, disabled auto-redirects, 10MB response size limit.
+- `SyncHttpClient` / `AsyncHttpClient` with configurable base URL and automatic `Authorization` header injection.
+- Full type annotations throughout using Python typing module.
+
+[1.0.0]: https://github.com/Dominus-Node/dominusnode-python/releases/tag/v1.0.0

dominusnode-2.0.0/LICENSE

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

dominusnode-2.0.0/MANIFEST.in

@@ -0,0 +1,8 @@
+# sdist contents: package source, metadata and docs only (see scripts/release/check-artifacts.mjs)
+include README.md
+include CHANGELOG.md
+include LICENSE
+prune tests
+exclude conftest.py
+prune examples
+global-exclude *.py[cod] __pycache__ *.map .env .env.* *.log

dominusnode-2.0.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: dominusnode
+Version: 2.0.0
+Summary: Official DominusNode SDK for Python: AI-agent relay network (proxy, nodes, credits, payouts)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/0xcircuitbreaker/DomiNode/tree/master/sdks/python
+Project-URL: Repository, https://github.com/0xcircuitbreaker/DomiNode
+Project-URL: Issues, https://github.com/0xcircuitbreaker/DomiNode/issues
+Project-URL: Changelog, https://github.com/0xcircuitbreaker/DomiNode/blob/master/sdks/python/CHANGELOG.md
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Dynamic: license-file
+
+# dominusnode — DominusNode Python SDK (v2)
+
+Python client for the DominusNode AI-agent relay network: proxy through relay nodes,
+register your own nodes, earn credits and withdraw payouts. It implements
+[`sdks/SDK_SURFACE.md`](../SDK_SURFACE.md) (15 resources, 71 methods), with the Node SDK as
+the reference implementation.
+
+- Sync `DominusNodeClient` and asyncio `AsyncDominusNodeClient` with the same methods
+- One dependency (`httpx`), no crypto dependency: you sign through a callback
+- Python 3.9+, type hints, PEP 561
+
+```bash
+pip install dominusnode
+```
+
+Defaults: API `https://api.dominusnode.daedalusdevelopmentgroup.com`, relay gateway `proxy.dominusnode.daedalusdevelopmentgroup.com` (HTTP proxy :8080, SOCKS5 :1080). Both can be overridden in the client configuration.
+
+## Quick start
+
+```python
+import os
+from dominusnode import DominusNodeClient
+
+with DominusNodeClient() as dn:
+    dn.connect_with_key(os.environ["DOMINUSNODE_API_KEY"])  # dn_live_... / dn_test_...
+
+    print(dn.network.pricing())       # live per-GB prices (µUSD); the SDK hardcodes no prices
+    res = dn.proxy.fetch("https://example.com", country="US", ip_class="residential")
+    print(res.status, res.text()[:200])
+```
+
+Async:
+
+```python
+from dominusnode import AsyncDominusNodeClient
+
+async with AsyncDominusNodeClient() as dn:
+    await dn.connect_with_key(key)
+    stats = await dn.network.stats()
+```
+
+## Proxy
+
+Routing flags go in the proxy **username**, the API key in the **password**:
+
+```python
+dn.proxy.build_username(country="DE", session_id="abc123")  # "country-DE-session-abc123"
+url = dn.proxy.build_url(country="US", ip_class="dc")        # http://country-US-class-dc:<key>@proxy.dominusnode.daedalusdevelopmentgroup.com:8080
+```
+
+`build_url` returns a URL that **contains your API key: do not log it.**
+
+Flags: `country` (ISO-2; OFAC countries CU IR KP RU SY are refused), `ip_class`
+(`residential`/`dc`/`mobile`), `session_id` (sticky, 1-64 alphanumerics),
+`agentic_wallet_id` (UUID, spend from an agentic wallet), `allow_http` (`allowhttp-1`).
+With no flags the username is `relay`.
+
+`proxy.fetch(url, ...)` sends GET or HEAD only. Before it opens a connection it checks the
+URL: http(s) only, ports 80/443, no userinfo, no local or private hosts, including
+decimal/hex/octal IPv4 forms and IPv6 forms that embed IPv4. It then resolves the hostname
+and refuses it if *any* address is private (DNS-rebinding check). https goes through a
+CONNECT tunnel with full TLS verification; `http://` needs `allow_http=True`. Redirects are
+returned as they are, not followed, and the body is capped at 10 MB (`truncated=True` when
+cut).
+
+## Signers (EIP-191)
+
+Node registration, withdrawals, payout-wallet changes and wallet sign-in need a signature from
+your wallet. Pass any object with an `address` and a `sign_message(message) -> "0x…"` method that
+performs `personal_sign`:
+
+```python
+from eth_account import Account
+from eth_account.messages import encode_defunct
+
+acct = Account.from_key(private_key)
+
+class Signer:
+    address = acct.address
+    def sign_message(self, message: str) -> str:
+        sig = acct.sign_message(encode_defunct(text=message)).signature.hex()
+        return sig if sig.startswith("0x") else "0x" + sig
+```
+
+With `AsyncDominusNodeClient`, `sign_message` may be `async def`.
+
+The SDK never signs a server string without checking it. For every signed flow it builds the
+expected message itself and compares it byte for byte with the server's. If they differ, it
+raises `ProtocolError` and the signer is never called.
+
+```python
+node = dn.nodes.register(signer, node_pubkey=ed25519_pub_hex, max_streams=8)
+node_key = node["nodeKey"].reveal()       # Secret, shown once
+
+dn.payout_wallet.set("0xYourPayoutAddress", signer)               # first set
+dn.payout_wallet.set("0xNew...", signer, old_wallet_signer=old)   # change: old wallet co-signs
+
+r = dn.credits.withdraw(5_000_000, signer)   # µUSD (int or digit string, never float); $5
+r["idempotencyKey"]                          # reuse it to retry safely
+```
+
+## Money
+
+- Server money values are `{"musd": "<integer µUSD>", "usd": "<6 decimals>"}`; 1 USD = 1,000,000 µUSD.
+- µUSD inputs accept an `int` or a digit string and are sent as decimal strings. Floats, NaN and Infinity are rejected.
+- `*_cents` inputs are integers with `0 < x <= 2,147,483,647`, checked before any request is sent.
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `auth` | `verify_key`, `refresh`, `logout`, `me` |
+| `wallet_auth` | `challenge`, `verify`, `sign_in`, `link` |
+| `keys` | `create`, `list`, `revoke` |
+| `wallet` | `get_balance`, `get_transactions`, `get_forecast`, `top_up_crypto`, `get_crypto_status` |
+| `agentic_wallets` | `create`, `list`, `get`, `fund`, `update_wallet_policy`, `transactions`, `freeze`, `unfreeze`, `delete` |
+| `teams` | 18 methods: team CRUD, wallet, members, invites, keys (`create_key` … `revoke_key`) |
+| `usage` | `get`, `get_daily`, `get_top_hosts`, `export_csv` (`from_`/`to` -> `since`/`until`) |
+| `sessions` | `get_active` (id, startedAt and status only; never IPs), `report` |
+| `x402` | `get_info` |
+| `network` | `policy`, `pricing`, `stats` |
+| `nodes` | `register_challenge`, `register`, `list`, `revoke`, `update_caps`, `tier` |
+| `credits` | `balance`, `transactions`, `convert`, `withdraw` |
+| `payout_wallet` | `get`, `set` |
+| `payouts` | `list` |
+| `proxy` | `build_username`, `build_url`, `fetch`, `get_health`, `get_config` |
+
+Client members: `connect_with_key(api_key)` (returns `{"mfaRequired": bool, "userId"?}`),
+`disconnect()` and `is_connected`. Results are the server's JSON as dicts with camelCase keys.
+
+Not in the SDK: plans, slots, admin, Stripe and PayPal top-ups, email/password and human MFA.
+Use the dashboard for those.
+
+## Errors
+
+`DominusNodeError` (`message`, `status_code`, `code`, `details`) and its subclasses:
+`ValidationError` (HTTP 400, and client-side checks with `code="INVALID_ARGUMENT"`),
+`AuthenticationError`, `InsufficientBalanceError`, `AuthorizationError`, `NotFoundError`,
+`ConflictError`, `RateLimitError` (`retry_after_seconds`), `ServerError`, `NetworkError`,
+`ProtocolError`, `ProxyError`. Error messages are scrubbed of `dn_live_`/`dn_test_`/`dn_node_`/
+`dn_proxy_` keys and JWTs.
+
+## Security behaviour
+
+- Redirects are never followed. API responses are capped at 10 MB.
+- On 429 the SDK retries once, waiting `min(Retry-After, 10 s)` ±10 % (at least 100 ms).
+- On 401 it refreshes the JWT once. `/v1` routes send the raw API key and are not refreshed.
+- `Secret` (new API keys, team keys, node keys) prints and serialises as `[REDACTED]`. Use `json.dumps(obj, default=dominusnode.json_default)`.
+- `disconnect()` logs out (best effort), then clears the API key and both tokens.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+`tests/fixtures/signed_messages.json` holds the three signed messages as produced by the Node
+SDK builders. `tests/test_signers.py` checks the Python builders against it byte for byte.

dominusnode-2.0.0/README.md

@@ -0,0 +1,159 @@
+# dominusnode — DominusNode Python SDK (v2)
+
+Python client for the DominusNode AI-agent relay network: proxy through relay nodes,
+register your own nodes, earn credits and withdraw payouts. It implements
+[`sdks/SDK_SURFACE.md`](../SDK_SURFACE.md) (15 resources, 71 methods), with the Node SDK as
+the reference implementation.
+
+- Sync `DominusNodeClient` and asyncio `AsyncDominusNodeClient` with the same methods
+- One dependency (`httpx`), no crypto dependency: you sign through a callback
+- Python 3.9+, type hints, PEP 561
+
+```bash
+pip install dominusnode
+```
+
+Defaults: API `https://api.dominusnode.daedalusdevelopmentgroup.com`, relay gateway `proxy.dominusnode.daedalusdevelopmentgroup.com` (HTTP proxy :8080, SOCKS5 :1080). Both can be overridden in the client configuration.
+
+## Quick start
+
+```python
+import os
+from dominusnode import DominusNodeClient
+
+with DominusNodeClient() as dn:
+    dn.connect_with_key(os.environ["DOMINUSNODE_API_KEY"])  # dn_live_... / dn_test_...
+
+    print(dn.network.pricing())       # live per-GB prices (µUSD); the SDK hardcodes no prices
+    res = dn.proxy.fetch("https://example.com", country="US", ip_class="residential")
+    print(res.status, res.text()[:200])
+```
+
+Async:
+
+```python
+from dominusnode import AsyncDominusNodeClient
+
+async with AsyncDominusNodeClient() as dn:
+    await dn.connect_with_key(key)
+    stats = await dn.network.stats()
+```
+
+## Proxy
+
+Routing flags go in the proxy **username**, the API key in the **password**:
+
+```python
+dn.proxy.build_username(country="DE", session_id="abc123")  # "country-DE-session-abc123"
+url = dn.proxy.build_url(country="US", ip_class="dc")        # http://country-US-class-dc:<key>@proxy.dominusnode.daedalusdevelopmentgroup.com:8080
+```
+
+`build_url` returns a URL that **contains your API key: do not log it.**
+
+Flags: `country` (ISO-2; OFAC countries CU IR KP RU SY are refused), `ip_class`
+(`residential`/`dc`/`mobile`), `session_id` (sticky, 1-64 alphanumerics),
+`agentic_wallet_id` (UUID, spend from an agentic wallet), `allow_http` (`allowhttp-1`).
+With no flags the username is `relay`.
+
+`proxy.fetch(url, ...)` sends GET or HEAD only. Before it opens a connection it checks the
+URL: http(s) only, ports 80/443, no userinfo, no local or private hosts, including
+decimal/hex/octal IPv4 forms and IPv6 forms that embed IPv4. It then resolves the hostname
+and refuses it if *any* address is private (DNS-rebinding check). https goes through a
+CONNECT tunnel with full TLS verification; `http://` needs `allow_http=True`. Redirects are
+returned as they are, not followed, and the body is capped at 10 MB (`truncated=True` when
+cut).
+
+## Signers (EIP-191)
+
+Node registration, withdrawals, payout-wallet changes and wallet sign-in need a signature from
+your wallet. Pass any object with an `address` and a `sign_message(message) -> "0x…"` method that
+performs `personal_sign`:
+
+```python
+from eth_account import Account
+from eth_account.messages import encode_defunct
+
+acct = Account.from_key(private_key)
+
+class Signer:
+    address = acct.address
+    def sign_message(self, message: str) -> str:
+        sig = acct.sign_message(encode_defunct(text=message)).signature.hex()
+        return sig if sig.startswith("0x") else "0x" + sig
+```
+
+With `AsyncDominusNodeClient`, `sign_message` may be `async def`.
+
+The SDK never signs a server string without checking it. For every signed flow it builds the
+expected message itself and compares it byte for byte with the server's. If they differ, it
+raises `ProtocolError` and the signer is never called.
+
+```python
+node = dn.nodes.register(signer, node_pubkey=ed25519_pub_hex, max_streams=8)
+node_key = node["nodeKey"].reveal()       # Secret, shown once
+
+dn.payout_wallet.set("0xYourPayoutAddress", signer)               # first set
+dn.payout_wallet.set("0xNew...", signer, old_wallet_signer=old)   # change: old wallet co-signs
+
+r = dn.credits.withdraw(5_000_000, signer)   # µUSD (int or digit string, never float); $5
+r["idempotencyKey"]                          # reuse it to retry safely
+```
+
+## Money
+
+- Server money values are `{"musd": "<integer µUSD>", "usd": "<6 decimals>"}`; 1 USD = 1,000,000 µUSD.
+- µUSD inputs accept an `int` or a digit string and are sent as decimal strings. Floats, NaN and Infinity are rejected.
+- `*_cents` inputs are integers with `0 < x <= 2,147,483,647`, checked before any request is sent.
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `auth` | `verify_key`, `refresh`, `logout`, `me` |
+| `wallet_auth` | `challenge`, `verify`, `sign_in`, `link` |
+| `keys` | `create`, `list`, `revoke` |
+| `wallet` | `get_balance`, `get_transactions`, `get_forecast`, `top_up_crypto`, `get_crypto_status` |
+| `agentic_wallets` | `create`, `list`, `get`, `fund`, `update_wallet_policy`, `transactions`, `freeze`, `unfreeze`, `delete` |
+| `teams` | 18 methods: team CRUD, wallet, members, invites, keys (`create_key` … `revoke_key`) |
+| `usage` | `get`, `get_daily`, `get_top_hosts`, `export_csv` (`from_`/`to` -> `since`/`until`) |
+| `sessions` | `get_active` (id, startedAt and status only; never IPs), `report` |
+| `x402` | `get_info` |
+| `network` | `policy`, `pricing`, `stats` |
+| `nodes` | `register_challenge`, `register`, `list`, `revoke`, `update_caps`, `tier` |
+| `credits` | `balance`, `transactions`, `convert`, `withdraw` |
+| `payout_wallet` | `get`, `set` |
+| `payouts` | `list` |
+| `proxy` | `build_username`, `build_url`, `fetch`, `get_health`, `get_config` |
+
+Client members: `connect_with_key(api_key)` (returns `{"mfaRequired": bool, "userId"?}`),
+`disconnect()` and `is_connected`. Results are the server's JSON as dicts with camelCase keys.
+
+Not in the SDK: plans, slots, admin, Stripe and PayPal top-ups, email/password and human MFA.
+Use the dashboard for those.
+
+## Errors
+
+`DominusNodeError` (`message`, `status_code`, `code`, `details`) and its subclasses:
+`ValidationError` (HTTP 400, and client-side checks with `code="INVALID_ARGUMENT"`),
+`AuthenticationError`, `InsufficientBalanceError`, `AuthorizationError`, `NotFoundError`,
+`ConflictError`, `RateLimitError` (`retry_after_seconds`), `ServerError`, `NetworkError`,
+`ProtocolError`, `ProxyError`. Error messages are scrubbed of `dn_live_`/`dn_test_`/`dn_node_`/
+`dn_proxy_` keys and JWTs.
+
+## Security behaviour
+
+- Redirects are never followed. API responses are capped at 10 MB.
+- On 429 the SDK retries once, waiting `min(Retry-After, 10 s)` ±10 % (at least 100 ms).
+- On 401 it refreshes the JWT once. `/v1` routes send the raw API key and are not refreshed.
+- `Secret` (new API keys, team keys, node keys) prints and serialises as `[REDACTED]`. Use `json.dumps(obj, default=dominusnode.json_default)`.
+- `disconnect()` logs out (best effort), then clears the API key and both tokens.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest
+```
+
+`tests/fixtures/signed_messages.json` holds the three signed messages as produced by the Node
+SDK builders. `tests/test_signers.py` checks the Python builders against it byte for byte.

dominusnode-2.0.0/dominusnode/__init__.py

@@ -0,0 +1,45 @@
+"""Official DominusNode SDK for Python: AI-agent relay network (proxy, nodes, credits, payouts)."""
+
+from .client import AsyncDominusNodeClient, DominusNodeClient
+from .constants import (
+    DEFAULT_BASE_URL,
+    DEFAULT_HTTP_PROXY_PORT,
+    DEFAULT_PROXY_HOST,
+    DEFAULT_SOCKS5_PROXY_PORT,
+    MAX_AMOUNT_CENTS,
+    MAX_RESPONSE_BYTES,
+    SDK_VERSION,
+    USER_AGENT,
+)
+from .errors import (
+    AuthenticationError,
+    AuthorizationError,
+    ConflictError,
+    DominusNodeError,
+    InsufficientBalanceError,
+    NetworkError,
+    NotFoundError,
+    ProtocolError,
+    ProxyError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+    scrub_credentials,
+)
+from .messages import build_attestation_message, build_payout_wallet_message, build_withdraw_message
+from .proxy_fetch import GatewayTls, ProxyFetchResponse, build_proxy_username
+from .secret import Secret, json_default
+from .signer import Signer
+from .ssrf import is_private_ip, validate_target_url
+
+__version__ = SDK_VERSION
+
+__all__ = [
+    "DominusNodeClient", "AsyncDominusNodeClient", "Signer", "Secret", "json_default",
+    "build_proxy_username", "ProxyFetchResponse", "GatewayTls", "is_private_ip", "validate_target_url",
+    "build_attestation_message", "build_payout_wallet_message", "build_withdraw_message",
+    "DominusNodeError", "AuthenticationError", "AuthorizationError", "RateLimitError", "InsufficientBalanceError",
+    "ValidationError", "NotFoundError", "ConflictError", "ServerError", "NetworkError", "ProtocolError", "ProxyError",
+    "scrub_credentials", "SDK_VERSION", "USER_AGENT", "DEFAULT_BASE_URL", "DEFAULT_PROXY_HOST",
+    "DEFAULT_HTTP_PROXY_PORT", "DEFAULT_SOCKS5_PROXY_PORT", "MAX_RESPONSE_BYTES", "MAX_AMOUNT_CENTS", "__version__",
+]

dominusnode-2.0.0/dominusnode/_ops.py

@@ -0,0 +1,122 @@
+"""Sans-I/O core shared by the sync and async clients (internal).
+
+Each resource method is written once as a generator that yields operations
+(an API ``Request``, a ``Sign`` call or a blocking ``Call``) and receives their
+results. ``drive_sync`` / ``drive_async`` execute those operations, so the sync
+and async clients expose identical behaviour from a single implementation.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import inspect
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Generator, Tuple, Type, TypeVar
+
+from .errors import ProtocolError
+from .http_client import AsyncHttpClient, Request, SyncHttpClient
+
+Op = Any
+Gen = Generator[Op, Any, Any]
+
+
+@dataclass
+class Sign:
+    signer: Any
+    message: str
+
+
+@dataclass
+class Call:
+    """Blocking work (PoW, socket I/O). Sync: called inline. Async: run in a worker thread."""
+
+    fn: Callable[..., Any]
+    args: Tuple[Any, ...] = ()
+
+
+def _exec_sync(http: SyncHttpClient, op: Op) -> Any:
+    if isinstance(op, Request):
+        return http.request(op)
+    if isinstance(op, Sign):
+        result = op.signer.sign_message(op.message)
+        if inspect.isawaitable(result):
+            if hasattr(result, "close"):
+                result.close()
+            raise ProtocolError("sign_message returned an awaitable; use AsyncDominusNodeClient for async signers")
+        return result
+    if isinstance(op, Call):
+        return op.fn(*op.args)
+    raise TypeError(f"unknown op {op!r}")
+
+
+async def _exec_async(http: AsyncHttpClient, op: Op) -> Any:
+    if isinstance(op, Request):
+        return await http.request(op)
+    if isinstance(op, Sign):
+        result = op.signer.sign_message(op.message)
+        if inspect.isawaitable(result):
+            result = await result
+        return result
+    if isinstance(op, Call):
+        return await asyncio.to_thread(op.fn, *op.args)
+    raise TypeError(f"unknown op {op!r}")
+
+
+def drive_sync(http: SyncHttpClient, gen: Gen) -> Any:
+    value: Any = None
+    exc: Any = None
+    while True:
+        try:
+            op = gen.throw(exc) if exc is not None else gen.send(value)
+        except StopIteration as stop:
+            return stop.value
+        try:
+            value, exc = _exec_sync(http, op), None
+        except Exception as e:  # noqa: BLE001 - delivered into the generator
+            value, exc = None, e
+
+
+async def drive_async(http: AsyncHttpClient, gen: Gen) -> Any:
+    value: Any = None
+    exc: Any = None
+    while True:
+        try:
+            op = gen.throw(exc) if exc is not None else gen.send(value)
+        except StopIteration as stop:
+            return stop.value
+        try:
+            value, exc = await _exec_async(http, op), None
+        except Exception as e:  # noqa: BLE001
+            value, exc = None, e
+
+
+T = TypeVar("T")
+
+
+def _sync_method(fn: Callable[..., Gen]) -> Callable[..., Any]:
+    @functools.wraps(fn)
+    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+        return drive_sync(self._http, fn(self, *args, **kwargs))
+
+    return wrapper
+
+
+def _async_method(fn: Callable[..., Gen]) -> Callable[..., Any]:
+    @functools.wraps(fn)
+    async def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+        return await drive_async(self._http, fn(self, *args, **kwargs))
+
+    return wrapper
+
+
+def make_variants(core: Type[T]) -> Tuple[Type[T], Type[T]]:
+    """Build (SyncResource, AsyncResource) subclasses: every public generator method becomes a plain/async method."""
+    name = core.__name__.lstrip("_")
+    sync_ns: Dict[str, Any] = {"__doc__": core.__doc__, "__module__": core.__module__}
+    async_ns: Dict[str, Any] = {"__doc__": core.__doc__, "__module__": core.__module__}
+    for attr, value in vars(core).items():
+        if not attr.startswith("_") and inspect.isgeneratorfunction(value):
+            sync_ns[attr] = _sync_method(value)
+            async_ns[attr] = _async_method(value)
+    return type(name, (core,), sync_ns), type("Async" + name, (core,), async_ns)  # type: ignore[return-value]