dominusnode 1.1.1__tar.gz → 1.3.0__tar.gz

{dominusnode-1.1.1 → dominusnode-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominusnode
-Version: 1.1.1
+Version: 1.3.0
 Summary: Official Dominus Node SDK for Python
 License: MIT
 Requires-Python: >=3.9

{dominusnode-1.1.1 → dominusnode-1.3.0}/README.md

@@ -394,18 +394,18 @@ with DominusNodeClient(base_url="https://api.dominusnode.com") as client:
         print(f"API error: {e}")
 ```
 
-| Error Class | HTTP Status | When |
-|-------------|-------------|------|
-| `AuthenticationError` | 401 | Invalid credentials, expired token |
-| `AuthorizationError` | 403 | Insufficient permissions (e.g., non-admin) |
-| `InsufficientBalanceError` | 402 | Wallet balance too low |
-| `RateLimitError` | 429 | Too many requests |
-| `ValidationError` | 400 | Invalid input |
-| `NotFoundError` | 404 | Resource not found |
-| `ConflictError` | 409 | Duplicate resource |
-| `ServerError` | 500+ | Server-side error |
-| `NetworkError` | -- | Connection failure, timeout |
-| `ProxyError` | -- | Proxy URL building error |
+| Error Class                | HTTP Status | When                                       |
+| -------------------------- | ----------- | ------------------------------------------ |
+| `AuthenticationError`      | 401         | Invalid credentials, expired token         |
+| `AuthorizationError`       | 403         | Insufficient permissions (e.g., non-admin) |
+| `InsufficientBalanceError` | 402         | Wallet balance too low                     |
+| `RateLimitError`           | 429         | Too many requests                          |
+| `ValidationError`          | 400         | Invalid input                              |
+| `NotFoundError`            | 404         | Resource not found                         |
+| `ConflictError`            | 409         | Duplicate resource                         |
+| `ServerError`              | 500+        | Server-side error                          |
+| `NetworkError`             | --          | Connection failure, timeout                |
+| `ProxyError`               | --          | Proxy URL building error                   |
 
 ## Configuration
 

{dominusnode-1.1.1 → dominusnode-1.3.0}/dominusnode/__init__.py

@@ -34,7 +34,19 @@ from .errors import (
     ServerError,
     ValidationError,
 )
-from .x402 import X402Info, X402Facilitator, X402Pricing
+from .x402 import (
+    X402Info,
+    X402Facilitator,
+    X402PaymentHeaders,
+    X402Pricing,
+    X402_PROTOCOL_VERSION,
+    X402_HEADER_PAYMENT_SIGNATURE,
+    X402_HEADER_PAYMENT_SIGNATURE_LEGACY,
+    X402_HEADER_PAYMENT_RESPONSE,
+    X402_HEADER_PAYMENT_RESPONSE_LEGACY,
+    X402_HEADER_PAYMENT_REQUIRED,
+)
+from .mpp import MppResource, AsyncMppResource, build_proxy_headers, build_session_headers
 from .wallet_auth import WalletChallenge, WalletVerifyResult, WalletLinkResult
 from .types import (
     ActiveSession,
@@ -141,11 +153,23 @@ __all__ = [
     # x402
     "X402Info",
     "X402Facilitator",
+    "X402PaymentHeaders",
     "X402Pricing",
+    "X402_PROTOCOL_VERSION",
+    "X402_HEADER_PAYMENT_SIGNATURE",
+    "X402_HEADER_PAYMENT_SIGNATURE_LEGACY",
+    "X402_HEADER_PAYMENT_RESPONSE",
+    "X402_HEADER_PAYMENT_RESPONSE_LEGACY",
+    "X402_HEADER_PAYMENT_REQUIRED",
     # Wallet Auth
     "WalletChallenge",
     "WalletVerifyResult",
     "WalletLinkResult",
+    # MPP
+    "MppResource",
+    "AsyncMppResource",
+    "build_proxy_headers",
+    "build_session_headers",
     # Constants
     "SDK_VERSION",
 ]

{dominusnode-1.1.1 → dominusnode-1.3.0}/dominusnode/client.py

@@ -40,6 +40,7 @@ from .constants import (
 )
 from .http_client import AsyncHttpClient, SyncHttpClient
 from .keys import AsyncKeysResource, KeysResource
+from .mpp import AsyncMppResource, MppResource
 from .plans import AsyncPlansResource, PlansResource
 from .proxy import AsyncProxyResource, ProxyResource
 from .sessions import AsyncSessionsResource, SessionsResource
@@ -130,6 +131,7 @@ class DominusNodeClient:
         self._teams = TeamsRes(self._http)
         self._x402 = X402Resource(self._http)
         self._wallet_auth = WalletAuthResource(self._http, self._token_manager)
+        self._mpp = MppResource(self._http)
 
         # Auto-connect if credentials provided.
         # On failure, clear credentials to prevent retention in a partial object.
@@ -210,6 +212,11 @@ class DominusNodeClient:
         """Wallet-based authentication (EIP-191 signed messages)."""
         return self._wallet_auth
 
+    @property
+    def mpp(self) -> MppResource:
+        """MPP (Micropayment Protocol) operations."""
+        return self._mpp
+
     # ── Connection methods ───────────────────────────────────────────
 
     def connect_with_key(self, api_key: str) -> LoginResult:
@@ -341,6 +348,7 @@ class AsyncDominusNodeClient:
         self._teams = AsyncTeamsRes(self._http)
         self._x402 = AsyncX402Resource(self._http)
         self._wallet_auth = AsyncWalletAuthResource(self._http, self._token_manager)
+        self._mpp = AsyncMppResource(self._http)
 
     # ── Resource properties ──────────────────────────────────────────
 
@@ -399,6 +407,11 @@ class AsyncDominusNodeClient:
         """Wallet-based authentication (EIP-191 signed messages)."""
         return self._wallet_auth
 
+    @property
+    def mpp(self) -> AsyncMppResource:
+        """MPP (Micropayment Protocol) operations."""
+        return self._mpp
+
     # ── Connection methods ───────────────────────────────────────────
 
     async def connect_with_key(self, api_key: str) -> LoginResult:

dominusnode-1.3.0/dominusnode/mpp.py

@@ -0,0 +1,303 @@
+"""MPP (Micropayment Protocol) resource -- info, top-ups, payment sessions, and keyless proxy access.
+
+MPP allows AI agents to use the proxy WITHOUT any API key -- just pay per request.
+Call ``get_challenge()`` to obtain a credential, then use ``build_proxy_headers()``
+to construct the headers needed for keyless proxy access.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any, Dict
+
+# IETF MPP auth scheme names
+MPP_AUTH_SCHEME = "Payment"
+MPP_AUTH_SCHEME_LEGACY = "MPP"
+from urllib.parse import quote
+
+from .http_client import AsyncHttpClient, SyncHttpClient
+from .wallet import _validate_amount_cents
+
+
+def _validate_finite_int(value: int, name: str) -> None:
+    """Validate that *value* is a finite integer (guards against NaN/Infinity via float coercion)."""
+    if not isinstance(value, int):
+        raise ValueError(f"{name} must be an integer")
+    # Python int can't be NaN/Inf, but guard against float passed as int subclass
+    as_float = float(value)
+    if math.isnan(as_float) or math.isinf(as_float):
+        raise ValueError(f"{name} must be a finite number")
+
+
+def build_proxy_headers(credential: Dict[str, Any]) -> Dict[str, str]:
+    """Build proxy Authorization header for keyless MPP access.
+
+    Returns headers that should be set on the HTTP CONNECT / proxy request
+    to route through the proxy without an API key.
+
+    Args:
+        credential: The credential dict from ``get_challenge()`` (or a manually
+            constructed dict with at least ``challengeId``, ``nonce``, ``poolType``).
+
+    Returns:
+        Headers dict with ``Authorization: MPP <json>``.
+    """
+    return {
+        "Authorization": MPP_AUTH_SCHEME + " " + json.dumps(credential, separators=(",", ":")),
+    }
+
+
+def build_session_headers(session_token: str) -> Dict[str, str]:
+    """Build proxy session token header for ongoing MPP sessions.
+
+    After opening a session, use the session token for subsequent requests
+    within the same session.
+
+    Args:
+        session_token: The session token from an active MPP session.
+
+    Returns:
+        Headers dict with ``MPP-SESSION-TOKEN``.
+    """
+    if not session_token or not isinstance(session_token, str):
+        raise ValueError("session_token must be a non-empty string")
+    return {
+        "MPP-SESSION-TOKEN": session_token,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Sync
+# ──────────────────────────────────────────────────────────────────────
+
+
+class MppResource:
+    """Synchronous MPP (Micropayment Protocol) operations.
+
+    MPP enables keyless proxy access for AI agents: call ``get_challenge()`` to
+    obtain a credential, then use ``build_proxy_headers()`` to construct the proxy
+    Authorization header -- no API key needed.
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def get_info(self) -> dict:
+        """Get MPP protocol information.
+
+        This endpoint does not require authentication.
+
+        Returns:
+            Server response dict with MPP capabilities and configuration.
+        """
+        data = self._http.get("/api/mpp/info", requires_auth=False)
+        return data
+
+    def get_challenge(self, pool_type: str) -> dict:
+        """Request an MPP challenge for keyless proxy access.
+
+        This endpoint does not require authentication. The returned credential
+        can be used with ``build_proxy_headers()`` to access the proxy without
+        an API key.
+
+        Args:
+            pool_type: Proxy pool type -- ``"dc"`` (datacenter, $3/GB) or
+                ``"residential"`` ($5/GB).
+
+        Returns:
+            Server response dict with ``challengeId``, ``nonce``, ``expiresAt``,
+            ``poolType``, and ``credential``.
+        """
+        if pool_type not in ("dc", "residential"):
+            raise ValueError("pool_type must be 'dc' or 'residential'")
+        data = self._http.post(
+            "/api/mpp/challenge",
+            json={"poolType": pool_type},
+            requires_auth=False,
+        )
+        return data
+
+    def top_up(self, amount_cents: int, method: str) -> dict:
+        """Top up the MPP balance.
+
+        Requires authentication (wallet credit needs a user account).
+
+        Args:
+            amount_cents: Amount in cents (must be positive, <= 2,147,483,647).
+            method: Payment method identifier (e.g. "stripe", "paypal", "crypto").
+
+        Returns:
+            Server response dict with top-up confirmation details.
+        """
+        _validate_finite_int(amount_cents, "amount_cents")
+        _validate_amount_cents(amount_cents, "amount_cents")
+        data = self._http.post("/api/mpp/topup", json={
+            "amountCents": amount_cents,
+            "method": method,
+        })
+        return data
+
+    def open_session(self, max_deposit_cents: int, method: str, pool_type: str) -> dict:
+        """Open a new MPP payment session (payment channel).
+
+        This endpoint does not require authentication -- anonymous agents can
+        open sessions by providing a payment method and deposit.
+
+        Args:
+            max_deposit_cents: Maximum deposit in cents (must be positive, <= 2,147,483,647).
+            method: Payment method identifier.
+            pool_type: Proxy pool type (e.g. "dc", "residential").
+
+        Returns:
+            Server response dict with session/channel details.
+        """
+        _validate_finite_int(max_deposit_cents, "max_deposit_cents")
+        _validate_amount_cents(max_deposit_cents, "max_deposit_cents")
+        data = self._http.post("/api/mpp/session/open", json={
+            "maxDepositCents": max_deposit_cents,
+            "method": method,
+            "poolType": pool_type,
+        }, requires_auth=False)
+        return data
+
+    def close_session(self, channel_id: str) -> dict:
+        """Close an existing MPP payment session.
+
+        Args:
+            channel_id: The payment channel identifier.
+
+        Returns:
+            Server response dict with closure confirmation and final settlement.
+        """
+        data = self._http.post("/api/mpp/session/close", json={
+            "channelId": channel_id,
+        })
+        return data
+
+    def get_session(self, channel_id: str) -> dict:
+        """Get details of an MPP payment session.
+
+        Args:
+            channel_id: The payment channel identifier (URL-encoded automatically).
+
+        Returns:
+            Server response dict with session state and usage details.
+        """
+        data = self._http.get(f"/api/mpp/session/{quote(channel_id, safe='')}")
+        return data
+
+    # Convenience re-exports as static methods for discoverability
+    build_proxy_headers = staticmethod(build_proxy_headers)
+    build_session_headers = staticmethod(build_session_headers)
+
+    def __repr__(self) -> str:
+        return "MppResource()"
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Async
+# ──────────────────────────────────────────────────────────────────────
+
+
+class AsyncMppResource:
+    """Asynchronous MPP (Micropayment Protocol) operations.
+
+    MPP enables keyless proxy access for AI agents: call ``get_challenge()`` to
+    obtain a credential, then use ``build_proxy_headers()`` to construct the proxy
+    Authorization header -- no API key needed.
+    """
+
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def get_info(self) -> dict:
+        """Get MPP protocol information.
+
+        This endpoint does not require authentication.
+        """
+        data = await self._http.get("/api/mpp/info", requires_auth=False)
+        return data
+
+    async def get_challenge(self, pool_type: str) -> dict:
+        """Request an MPP challenge for keyless proxy access.
+
+        This endpoint does not require authentication. The returned credential
+        can be used with ``build_proxy_headers()`` to access the proxy without
+        an API key.
+
+        Args:
+            pool_type: Proxy pool type -- ``"dc"`` or ``"residential"``.
+        """
+        if pool_type not in ("dc", "residential"):
+            raise ValueError("pool_type must be 'dc' or 'residential'")
+        data = await self._http.post(
+            "/api/mpp/challenge",
+            json={"poolType": pool_type},
+            requires_auth=False,
+        )
+        return data
+
+    async def top_up(self, amount_cents: int, method: str) -> dict:
+        """Top up the MPP balance.
+
+        Requires authentication (wallet credit needs a user account).
+
+        Args:
+            amount_cents: Amount in cents (must be positive, <= 2,147,483,647).
+            method: Payment method identifier (e.g. "stripe", "paypal", "crypto").
+        """
+        _validate_finite_int(amount_cents, "amount_cents")
+        _validate_amount_cents(amount_cents, "amount_cents")
+        data = await self._http.post("/api/mpp/topup", json={
+            "amountCents": amount_cents,
+            "method": method,
+        })
+        return data
+
+    async def open_session(self, max_deposit_cents: int, method: str, pool_type: str) -> dict:
+        """Open a new MPP payment session (payment channel).
+
+        This endpoint does not require authentication -- anonymous agents can
+        open sessions by providing a payment method and deposit.
+
+        Args:
+            max_deposit_cents: Maximum deposit in cents (must be positive, <= 2,147,483,647).
+            method: Payment method identifier.
+            pool_type: Proxy pool type (e.g. "dc", "residential").
+        """
+        _validate_finite_int(max_deposit_cents, "max_deposit_cents")
+        _validate_amount_cents(max_deposit_cents, "max_deposit_cents")
+        data = await self._http.post("/api/mpp/session/open", json={
+            "maxDepositCents": max_deposit_cents,
+            "method": method,
+            "poolType": pool_type,
+        }, requires_auth=False)
+        return data
+
+    async def close_session(self, channel_id: str) -> dict:
+        """Close an existing MPP payment session.
+
+        Args:
+            channel_id: The payment channel identifier.
+        """
+        data = await self._http.post("/api/mpp/session/close", json={
+            "channelId": channel_id,
+        })
+        return data
+
+    async def get_session(self, channel_id: str) -> dict:
+        """Get details of an MPP payment session.
+
+        Args:
+            channel_id: The payment channel identifier (URL-encoded automatically).
+        """
+        data = await self._http.get(f"/api/mpp/session/{quote(channel_id, safe='')}")
+        return data
+
+    # Convenience re-exports as static methods for discoverability
+    build_proxy_headers = staticmethod(build_proxy_headers)
+    build_session_headers = staticmethod(build_session_headers)
+
+    def __repr__(self) -> str:
+        return "AsyncMppResource()"

dominusnode-1.3.0/dominusnode/x402.py

@@ -0,0 +1,138 @@
+"""x402 V2 (HTTP 402 Payment Required) protocol information resource.
+
+V2 changes from V1:
+- Protocol version "2" (was "1")
+- CAIP-2 network IDs (e.g. "eip155:8453" instead of "base")
+- Payment header: PAYMENT-SIGNATURE (was X-PAYMENT)
+- Response header: PAYMENT-RESPONSE (was X-PAYMENT-RESPONSE)
+- Requirements header: PAYMENT-REQUIRED
+- New token: EURC (in addition to USDC)
+- New scheme: permit2 (in addition to exact)
+- Additional facilitator chains: Ethereum (eip155:1), Optimism (eip155:10),
+  Arbitrum (eip155:42161), and Solana
+"""
+
+from __future__ import annotations
+
+from typing import List
+from dataclasses import dataclass, field
+
+from .http_client import AsyncHttpClient, SyncHttpClient
+
+# x402 V2 protocol version.
+X402_PROTOCOL_VERSION = "2"
+
+# x402 V2 header constants.
+# V2 renamed the payment headers.  Servers should accept both old and new
+# for backward compatibility during the transition period.
+X402_HEADER_PAYMENT_SIGNATURE = "PAYMENT-SIGNATURE"
+X402_HEADER_PAYMENT_SIGNATURE_LEGACY = "X-PAYMENT"
+X402_HEADER_PAYMENT_RESPONSE = "PAYMENT-RESPONSE"
+X402_HEADER_PAYMENT_RESPONSE_LEGACY = "X-PAYMENT-RESPONSE"
+X402_HEADER_PAYMENT_REQUIRED = "PAYMENT-REQUIRED"
+
+
+@dataclass(frozen=True)
+class X402Facilitator:
+    address: str
+    chain: str
+    """Human-readable network name (e.g. "base", "ethereum")."""
+    network: str
+    """CAIP-2 network identifier (e.g. "eip155:8453"). Added in V2."""
+    network_id: str = ""
+
+
+@dataclass(frozen=True)
+class X402Pricing:
+    per_request_cents: int
+    per_gb_cents: int
+    currency: str
+
+
+@dataclass(frozen=True)
+class X402PaymentHeaders:
+    """Header names used by the current protocol version."""
+    request: str = X402_HEADER_PAYMENT_SIGNATURE
+    response: str = X402_HEADER_PAYMENT_RESPONSE
+    required: str = X402_HEADER_PAYMENT_REQUIRED
+
+
+@dataclass(frozen=True)
+class X402Info:
+    supported: bool
+    enabled: bool
+    protocol: str
+    """Protocol version -- "2" for x402 V2."""
+    version: str
+    facilitators: List[X402Facilitator]
+    pricing: X402Pricing
+    """Supported token symbols (e.g. ["USDC", "EURC"])."""
+    currencies: List[str]
+    """Supported payment schemes (e.g. ["exact", "permit2"])."""
+    schemes: List[str] = field(default_factory=list)
+    wallet_type: str = ""
+    agentic_wallets: bool = False
+    """Header names used by this protocol version."""
+    payment_headers: X402PaymentHeaders = field(default_factory=X402PaymentHeaders)
+
+
+def _parse_x402_info(data: dict) -> X402Info:
+    """Parse x402 info response into typed dataclass."""
+    facilitators = [
+        X402Facilitator(
+            address=f["address"],
+            chain=f["chain"],
+            network=f["network"],
+            network_id=f.get("networkId", ""),
+        )
+        for f in data.get("facilitators", [])
+    ]
+    pricing_data = data.get("pricing", {})
+    pricing = X402Pricing(
+        per_request_cents=pricing_data.get("perRequestCents", 0),
+        per_gb_cents=pricing_data.get("perGbCents", 0),
+        currency=pricing_data.get("currency", ""),
+    )
+    headers_data = data.get("paymentHeaders", {})
+    payment_headers = X402PaymentHeaders(
+        request=headers_data.get("request", X402_HEADER_PAYMENT_SIGNATURE),
+        response=headers_data.get("response", X402_HEADER_PAYMENT_RESPONSE),
+        required=headers_data.get("required", X402_HEADER_PAYMENT_REQUIRED),
+    )
+    return X402Info(
+        supported=data.get("supported", False),
+        enabled=data.get("enabled", False),
+        protocol=data.get("protocol", ""),
+        version=data.get("version", ""),
+        facilitators=facilitators,
+        pricing=pricing,
+        currencies=data.get("currencies", []),
+        schemes=data.get("schemes", []),
+        wallet_type=data.get("walletType", ""),
+        agentic_wallets=data.get("agenticWallets", False),
+        payment_headers=payment_headers,
+    )
+
+
+class X402Resource:
+    """Synchronous x402 V2 protocol information operations."""
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def get_info(self) -> X402Info:
+        """Get x402 V2 protocol information (no auth required)."""
+        data = self._http.get("/api/x402/info", requires_auth=False)
+        return _parse_x402_info(data)
+
+
+class AsyncX402Resource:
+    """Asynchronous x402 V2 protocol information operations."""
+
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def get_info(self) -> X402Info:
+        """Get x402 V2 protocol information (no auth required)."""
+        data = await self._http.get("/api/x402/info", requires_auth=False)
+        return _parse_x402_info(data)

{dominusnode-1.1.1 → dominusnode-1.3.0}/dominusnode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominusnode
-Version: 1.1.1
+Version: 1.3.0
 Summary: Official Dominus Node SDK for Python
 License: MIT
 Requires-Python: >=3.9

{dominusnode-1.1.1 → dominusnode-1.3.0}/dominusnode.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ dominusnode/constants.py
 dominusnode/errors.py
 dominusnode/http_client.py
 dominusnode/keys.py
+dominusnode/mpp.py
 dominusnode/plans.py
 dominusnode/proxy.py
 dominusnode/py.typed

{dominusnode-1.1.1 → dominusnode-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominusnode"
-version = "1.1.1"
+version = "1.3.0"
 description = "Official Dominus Node SDK for Python"
 requires-python = ">=3.9"
 license = {text = "MIT"}

dominusnode-1.1.1/dominusnode/x402.py

@@ -1,88 +0,0 @@
-"""x402 (HTTP 402 Payment Required) protocol information resource."""
-
-from __future__ import annotations
-
-from typing import List
-from dataclasses import dataclass, field
-
-from .http_client import AsyncHttpClient, SyncHttpClient
-
-
-@dataclass(frozen=True)
-class X402Facilitator:
-    address: str
-    chain: str
-    network: str
-
-
-@dataclass(frozen=True)
-class X402Pricing:
-    per_request_cents: int
-    per_gb_cents: int
-    currency: str
-
-
-@dataclass(frozen=True)
-class X402Info:
-    supported: bool
-    enabled: bool
-    protocol: str
-    version: str
-    facilitators: List[X402Facilitator]
-    pricing: X402Pricing
-    currencies: List[str]
-    wallet_type: str
-    agentic_wallets: bool
-
-
-def _parse_x402_info(data: dict) -> X402Info:
-    """Parse x402 info response into typed dataclass."""
-    facilitators = [
-        X402Facilitator(
-            address=f["address"],
-            chain=f["chain"],
-            network=f["network"],
-        )
-        for f in data.get("facilitators", [])
-    ]
-    pricing_data = data.get("pricing", {})
-    pricing = X402Pricing(
-        per_request_cents=pricing_data.get("perRequestCents", 0),
-        per_gb_cents=pricing_data.get("perGbCents", 0),
-        currency=pricing_data.get("currency", ""),
-    )
-    return X402Info(
-        supported=data.get("supported", False),
-        enabled=data.get("enabled", False),
-        protocol=data.get("protocol", ""),
-        version=data.get("version", ""),
-        facilitators=facilitators,
-        pricing=pricing,
-        currencies=data.get("currencies", []),
-        wallet_type=data.get("walletType", ""),
-        agentic_wallets=data.get("agenticWallets", False),
-    )
-
-
-class X402Resource:
-    """Synchronous x402 protocol information operations."""
-
-    def __init__(self, http: SyncHttpClient) -> None:
-        self._http = http
-
-    def get_info(self) -> X402Info:
-        """Get x402 protocol information (no auth required)."""
-        data = self._http.get("/api/x402/info", requires_auth=False)
-        return _parse_x402_info(data)
-
-
-class AsyncX402Resource:
-    """Asynchronous x402 protocol information operations."""
-
-    def __init__(self, http: AsyncHttpClient) -> None:
-        self._http = http
-
-    async def get_info(self) -> X402Info:
-        """Get x402 protocol information (no auth required)."""
-        data = await self._http.get("/api/x402/info", requires_auth=False)
-        return _parse_x402_info(data)