uvd-x402-sdk 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

uvd_x402_sdk/__init__.py

@@ -2,8 +2,11 @@
 uvd-x402-sdk: Python SDK for x402 payments via Ultravioleta DAO facilitator.
 
 This SDK enables developers to easily integrate x402 cryptocurrency payments
-into their Python applications with support for 14 blockchain networks across
-4 network types (EVM, SVM, NEAR, Stellar).
+into their Python applications with support for 16 blockchain networks across
+5 network types (EVM, SVM, NEAR, Stellar, Algorand).
+
+The SDK automatically handles facilitator configuration - users don't need to
+configure fee payer addresses or other facilitator details manually.
 
 Supports both x402 v1 and v2 protocols:
 - v1: network as string ("base", "solana")
@@ -29,15 +32,16 @@ Example usage:
     def protected_endpoint():
         return {"message": "Payment verified!"}
 
-Supported Networks (14 total):
+Supported Networks (16 total):
 - EVM (10): Base, Ethereum, Polygon, Arbitrum, Optimism, Avalanche, Celo,
            HyperEVM, Unichain, Monad
 - SVM (2): Solana, Fogo
 - NEAR (1): NEAR Protocol
 - Stellar (1): Stellar
+- Algorand (2): Algorand mainnet, Algorand testnet
 """
 
-__version__ = "0.3.4"
+__version__ = "0.5.0"
 __author__ = "Ultravioleta DAO"
 
 from uvd_x402_sdk.client import X402Client
@@ -109,6 +113,28 @@ from uvd_x402_sdk.response import (
     payment_required_response_v2,
     Payment402BuilderV2,
 )
+from uvd_x402_sdk.facilitator import (
+    # Facilitator URL and constants
+    DEFAULT_FACILITATOR_URL,
+    get_facilitator_url,
+    # Fee payer addresses by chain
+    ALGORAND_FEE_PAYER_MAINNET,
+    ALGORAND_FEE_PAYER_TESTNET,
+    SOLANA_FEE_PAYER_MAINNET,
+    SOLANA_FEE_PAYER_DEVNET,
+    FOGO_FEE_PAYER_MAINNET,
+    FOGO_FEE_PAYER_TESTNET,
+    NEAR_FEE_PAYER_MAINNET,
+    NEAR_FEE_PAYER_TESTNET,
+    STELLAR_FEE_PAYER_MAINNET,
+    STELLAR_FEE_PAYER_TESTNET,
+    # Helper functions
+    get_fee_payer,
+    get_facilitator_address,
+    requires_fee_payer,
+    get_all_fee_payers,
+    build_payment_info,
+)
 
 __all__ = [
     # Version
@@ -182,4 +208,22 @@ __all__ = [
     "create_402_headers_v2",
     "payment_required_response_v2",
     "Payment402BuilderV2",
+    # Facilitator constants and helpers
+    "DEFAULT_FACILITATOR_URL",
+    "get_facilitator_url",
+    "ALGORAND_FEE_PAYER_MAINNET",
+    "ALGORAND_FEE_PAYER_TESTNET",
+    "SOLANA_FEE_PAYER_MAINNET",
+    "SOLANA_FEE_PAYER_DEVNET",
+    "FOGO_FEE_PAYER_MAINNET",
+    "FOGO_FEE_PAYER_TESTNET",
+    "NEAR_FEE_PAYER_MAINNET",
+    "NEAR_FEE_PAYER_TESTNET",
+    "STELLAR_FEE_PAYER_MAINNET",
+    "STELLAR_FEE_PAYER_TESTNET",
+    "get_fee_payer",
+    "get_facilitator_address",
+    "requires_fee_payer",
+    "get_all_fee_payers",
+    "build_payment_info",
 ]

uvd_x402_sdk/facilitator.py

@@ -0,0 +1,384 @@
+"""
+Facilitator configuration and constants.
+
+This module provides:
+- Default facilitator URL
+- Fee payer addresses for all supported non-EVM networks
+- Helper functions to get the appropriate facilitator address for any network
+
+Users of this SDK should NOT need to configure facilitator details manually.
+All addresses are embedded as constants, extracted from the official facilitator.
+
+Facilitator URL: https://facilitator.ultravioletadao.xyz
+"""
+
+from typing import Dict, Optional
+
+from uvd_x402_sdk.networks.base import (
+    NetworkType,
+    get_network,
+    is_caip2_format,
+    normalize_network,
+)
+
+
+# =============================================================================
+# Facilitator URL
+# =============================================================================
+
+DEFAULT_FACILITATOR_URL = "https://facilitator.ultravioletadao.xyz"
+
+# Alternative facilitator URLs (for future use)
+FACILITATOR_URLS = {
+    "production": "https://facilitator.ultravioletadao.xyz",
+}
+
+
+# =============================================================================
+# Fee Payer Addresses (Non-EVM chains require fee payer for gasless payments)
+# =============================================================================
+
+# Algorand fee payer addresses
+ALGORAND_FEE_PAYER_MAINNET = "KIMS5H6QLCUDL65L5UBTOXDPWLMTS7N3AAC3I6B2NCONEI5QIVK7LH2C2I"
+ALGORAND_FEE_PAYER_TESTNET = "5DPPDQNYUPCTXRZWRYSF3WPYU6RKAUR25F3YG4EKXQRHV5AUAI62H5GXL4"
+
+# Solana fee payer addresses (also used for Fogo mainnet)
+SOLANA_FEE_PAYER_MAINNET = "F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq"
+SOLANA_FEE_PAYER_DEVNET = "6xNPewUdKRbEZDReQdpyfNUdgNg8QRc8Mt263T5GZSRv"
+
+# Fogo (SVM) fee payer addresses
+FOGO_FEE_PAYER_MAINNET = "F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq"
+FOGO_FEE_PAYER_TESTNET = "6xNPewUdKRbEZDReQdpyfNUdgNg8QRc8Mt263T5GZSRv"
+
+# NEAR fee payer addresses (account IDs)
+NEAR_FEE_PAYER_MAINNET = "uvd-facilitator.near"
+NEAR_FEE_PAYER_TESTNET = "uvd-facilitator.testnet"
+
+# Stellar fee payer addresses (public keys)
+STELLAR_FEE_PAYER_MAINNET = "GCHPGXJT2WFFRFCA5TV4G4E3PMMXLNIDUH27PKDYA4QJ2XGYZWGFZNHB"
+STELLAR_FEE_PAYER_TESTNET = "GBBFZMLUJEZVI32EN4XA2KPP445XIBTMTRBLYWFIL556RDTHS2OWFQ2Z"
+
+
+# =============================================================================
+# Network to Fee Payer Mapping
+# =============================================================================
+
+# Maps network names to their fee payer addresses
+# EVM networks don't have fee payers (they use EIP-3009 transferWithAuthorization)
+_FEE_PAYER_BY_NETWORK: Dict[str, str] = {
+    # Algorand
+    "algorand": ALGORAND_FEE_PAYER_MAINNET,
+    "algorand-mainnet": ALGORAND_FEE_PAYER_MAINNET,
+    "algorand-testnet": ALGORAND_FEE_PAYER_TESTNET,
+    # Solana
+    "solana": SOLANA_FEE_PAYER_MAINNET,
+    "solana-mainnet": SOLANA_FEE_PAYER_MAINNET,
+    "solana-devnet": SOLANA_FEE_PAYER_DEVNET,
+    # Fogo (SVM)
+    "fogo": FOGO_FEE_PAYER_MAINNET,
+    "fogo-mainnet": FOGO_FEE_PAYER_MAINNET,
+    "fogo-testnet": FOGO_FEE_PAYER_TESTNET,
+    # NEAR
+    "near": NEAR_FEE_PAYER_MAINNET,
+    "near-mainnet": NEAR_FEE_PAYER_MAINNET,
+    "near-testnet": NEAR_FEE_PAYER_TESTNET,
+    # Stellar
+    "stellar": STELLAR_FEE_PAYER_MAINNET,
+    "stellar-mainnet": STELLAR_FEE_PAYER_MAINNET,
+    "stellar-testnet": STELLAR_FEE_PAYER_TESTNET,
+}
+
+# CAIP-2 format mappings (x402 v2)
+_FEE_PAYER_BY_CAIP2: Dict[str, str] = {
+    # Algorand
+    "algorand:mainnet": ALGORAND_FEE_PAYER_MAINNET,
+    "algorand:testnet": ALGORAND_FEE_PAYER_TESTNET,
+    # Solana
+    "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": SOLANA_FEE_PAYER_MAINNET,
+    "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": SOLANA_FEE_PAYER_DEVNET,
+    # Fogo (SVM)
+    "fogo:mainnet": FOGO_FEE_PAYER_MAINNET,
+    "fogo:testnet": FOGO_FEE_PAYER_TESTNET,
+    # NEAR
+    "near:mainnet": NEAR_FEE_PAYER_MAINNET,
+    "near:testnet": NEAR_FEE_PAYER_TESTNET,
+    # Stellar
+    "stellar:pubnet": STELLAR_FEE_PAYER_MAINNET,
+    "stellar:testnet": STELLAR_FEE_PAYER_TESTNET,
+}
+
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+
+def get_fee_payer(network: str) -> Optional[str]:
+    """
+    Get the fee payer address for a network.
+
+    Fee payers are only needed for non-EVM chains (Algorand, Solana, NEAR, Stellar).
+    EVM chains use EIP-3009 transferWithAuthorization which is gasless by design.
+
+    Args:
+        network: Network identifier (v1 name or CAIP-2 format)
+                Examples: "algorand", "algorand-mainnet", "algorand:mainnet"
+
+    Returns:
+        Fee payer address if applicable, None for EVM chains
+
+    Example:
+        >>> get_fee_payer("algorand")
+        'KIMS5H6QLCUDL65L5UBTOXDPWLMTS7N3AAC3I6B2NCONEI5QIVK7LH2C2I'
+        >>> get_fee_payer("solana")
+        'F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq'
+        >>> get_fee_payer("base")  # EVM chain
+        None
+    """
+    # Check CAIP-2 format first
+    if is_caip2_format(network):
+        return _FEE_PAYER_BY_CAIP2.get(network)
+
+    # Check v1 network name
+    network_lower = network.lower()
+    return _FEE_PAYER_BY_NETWORK.get(network_lower)
+
+
+def get_facilitator_address(network: str) -> Optional[str]:
+    """
+    Alias for get_fee_payer() for backward compatibility.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        Facilitator/fee payer address if applicable
+    """
+    return get_fee_payer(network)
+
+
+def requires_fee_payer(network: str) -> bool:
+    """
+    Check if a network requires a fee payer address.
+
+    Args:
+        network: Network identifier (v1 name or CAIP-2 format)
+
+    Returns:
+        True if network requires fee payer (non-EVM), False otherwise
+
+    Example:
+        >>> requires_fee_payer("algorand")
+        True
+        >>> requires_fee_payer("base")
+        False
+    """
+    # Try to get network config
+    try:
+        normalized = normalize_network(network)
+        net_config = get_network(normalized)
+        if net_config:
+            return net_config.network_type != NetworkType.EVM
+    except ValueError:
+        pass
+
+    # Fall back to checking if we have a fee payer registered
+    return get_fee_payer(network) is not None
+
+
+def get_network_type_from_fee_payer(address: str) -> Optional[NetworkType]:
+    """
+    Determine network type from a fee payer address format.
+
+    Args:
+        address: Fee payer address
+
+    Returns:
+        NetworkType if recognizable, None otherwise
+
+    Example:
+        >>> get_network_type_from_fee_payer("KIMS5H6QLCUDL65L5UBTOXDPWLMTS7N3AAC3I6B2NCONEI5QIVK7LH2C2I")
+        NetworkType.ALGORAND
+        >>> get_network_type_from_fee_payer("F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq")
+        NetworkType.SVM
+    """
+    if not address:
+        return None
+
+    # Algorand: 58 characters, base32 (A-Z2-7)
+    if len(address) == 58 and address.isalnum():
+        import re
+        if re.match(r'^[A-Z2-7]+$', address):
+            return NetworkType.ALGORAND
+
+    # Solana/Fogo: 32-44 characters, base58
+    if 32 <= len(address) <= 44:
+        # Base58 uses alphanumeric chars except 0, O, I, l
+        import re
+        if re.match(r'^[A-HJ-NP-Za-km-z1-9]+$', address):
+            return NetworkType.SVM
+
+    # NEAR: ends with .near or .testnet
+    if address.endswith('.near') or address.endswith('.testnet'):
+        return NetworkType.NEAR
+
+    # Stellar: starts with G, 56 characters
+    if len(address) == 56 and address.startswith('G'):
+        return NetworkType.STELLAR
+
+    return None
+
+
+def validate_fee_payer_for_network(network: str, address: str) -> bool:
+    """
+    Validate that a fee payer address format matches the network type.
+
+    Args:
+        network: Network identifier
+        address: Fee payer address to validate
+
+    Returns:
+        True if address format is valid for network
+
+    Example:
+        >>> validate_fee_payer_for_network("algorand", "KIMS5H6...")
+        True
+        >>> validate_fee_payer_for_network("algorand", "F742C4V...")  # Solana address
+        False
+    """
+    try:
+        normalized = normalize_network(network)
+        net_config = get_network(normalized)
+        if not net_config:
+            return False
+
+        detected_type = get_network_type_from_fee_payer(address)
+        if detected_type is None:
+            return False
+
+        # SVM includes both SOLANA and SVM types
+        if net_config.network_type in (NetworkType.SVM, NetworkType.SOLANA):
+            return detected_type == NetworkType.SVM
+
+        return net_config.network_type == detected_type
+    except ValueError:
+        return False
+
+
+def get_all_fee_payers() -> Dict[str, str]:
+    """
+    Get all registered fee payer addresses.
+
+    Returns:
+        Dictionary mapping network names to fee payer addresses
+
+    Example:
+        >>> payers = get_all_fee_payers()
+        >>> for network, address in payers.items():
+        ...     print(f"{network}: {address}")
+    """
+    return dict(_FEE_PAYER_BY_NETWORK)
+
+
+def get_facilitator_url() -> str:
+    """
+    Get the default facilitator URL.
+
+    Returns:
+        Facilitator API URL
+
+    Example:
+        >>> url = get_facilitator_url()
+        >>> print(url)
+        'https://facilitator.ultravioletadao.xyz'
+    """
+    return DEFAULT_FACILITATOR_URL
+
+
+# =============================================================================
+# Payment Info Builder
+# =============================================================================
+
+
+def build_payment_info(
+    network: str,
+    pay_to: str,
+    max_amount_required: str,
+    description: str = "",
+    resource: str = "",
+    asset: Optional[str] = None,
+    token_type: str = "usdc",
+    extra: Optional[Dict] = None,
+) -> Dict:
+    """
+    Build a payment info dict with all facilitator details pre-configured.
+
+    This function automatically includes the correct fee payer address for
+    non-EVM networks, so SDK users don't need to configure this manually.
+
+    Args:
+        network: Network identifier (e.g., "algorand", "solana", "base")
+        pay_to: Recipient address
+        max_amount_required: Maximum amount in token units (string)
+        description: Optional payment description
+        resource: Optional resource being purchased
+        asset: Optional token address (defaults to USDC for network)
+        token_type: Token type (default "usdc")
+        extra: Additional extra fields to include
+
+    Returns:
+        Payment info dictionary ready for 402 response
+
+    Example:
+        >>> info = build_payment_info(
+        ...     network="algorand",
+        ...     pay_to="MERCHANT_ADDRESS...",
+        ...     max_amount_required="1000000",
+        ...     description="API access"
+        ... )
+        >>> # info includes facilitator fee payer automatically
+    """
+    # Get network config for defaults
+    try:
+        normalized = normalize_network(network)
+        net_config = get_network(normalized)
+    except ValueError:
+        net_config = None
+
+    # Build base payment info
+    payment_info: Dict = {
+        "network": network,
+        "payTo": pay_to,
+        "maxAmountRequired": max_amount_required,
+    }
+
+    if description:
+        payment_info["description"] = description
+    if resource:
+        payment_info["resource"] = resource
+
+    # Set asset (token address)
+    if asset:
+        payment_info["asset"] = asset
+    elif net_config:
+        payment_info["asset"] = net_config.usdc_address
+
+    # Build extra field
+    payment_extra: Dict = {}
+
+    # Add token type info
+    payment_extra["token"] = token_type
+
+    # Add fee payer for non-EVM networks
+    fee_payer = get_fee_payer(network)
+    if fee_payer:
+        payment_extra["feePayer"] = fee_payer
+
+    # Merge user-provided extra
+    if extra:
+        payment_extra.update(extra)
+
+    if payment_extra:
+        payment_info["extra"] = payment_extra
+
+    return payment_info

uvd_x402_sdk/networks/algorand.py

@@ -1,33 +1,51 @@
 """
-Algorand network configurations.
+Algorand network configurations for x402 payments.
 
 This module supports Algorand blockchain networks:
-- Algorand mainnet
-- Algorand testnet
+- Algorand mainnet (network: "algorand-mainnet" or "algorand")
+- Algorand testnet (network: "algorand-testnet")
 
 Algorand uses ASA (Algorand Standard Assets) for USDC:
 - Mainnet USDC ASA ID: 31566704
 - Testnet USDC ASA ID: 10458941
 
-Payment Flow:
-1. User creates a signed ASA transfer transaction via Pera Wallet
-2. Transaction transfers USDC from user to recipient
-3. Facilitator submits the pre-signed transaction on-chain
-4. User pays ZERO transaction fees (facilitator covers fees)
-
-Transaction Structure:
-- ASA TransferAsset transaction
-- Signed by user wallet (Pera Wallet)
-- Facilitator submits the signed transaction
+Payment Flow (GoPlausible x402-avm Atomic Group Spec):
+1. Client creates an ATOMIC GROUP of TWO transactions:
+   - Transaction 0 (fee tx): Zero-amount payment FROM facilitator TO facilitator
+     This transaction pays fees for both txns. Client creates this UNSIGNED.
+   - Transaction 1 (payment tx): ASA transfer FROM client TO merchant
+     Client SIGNS this transaction.
+2. Both transactions share a GROUP ID computed by Algorand SDK.
+3. Fee pooling: Transaction 0's fee covers Transaction 1's fee (gasless).
+4. Facilitator completes: Signs transaction 0 and submits the atomic group.
+
+Payload Format:
+{
+    "x402Version": 1,
+    "scheme": "exact",
+    "network": "algorand-mainnet",
+    "payload": {
+        "paymentIndex": 1,
+        "paymentGroup": [
+            "<base64-msgpack-UNSIGNED-fee-tx>",
+            "<base64-msgpack-SIGNED-asa-transfer>"
+        ]
+    }
+}
 
 Address Format:
 - Algorand addresses are 58 characters, base32 encoded
 - Example: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ
+
+Dependencies:
+- algosdk (optional): Required for building atomic groups
+  Install with: pip install py-algorand-sdk
 """
 
 import base64
 import re
-from typing import Any, Dict, Optional
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
 
 from uvd_x402_sdk.networks.base import (
     NetworkConfig,
@@ -35,6 +53,20 @@ from uvd_x402_sdk.networks.base import (
     register_network,
 )
 
+# Algorand fee payer addresses are defined in uvd_x402_sdk.facilitator
+# Import here for convenience
+try:
+    from uvd_x402_sdk.facilitator import (
+        ALGORAND_FEE_PAYER_MAINNET,
+        ALGORAND_FEE_PAYER_TESTNET,
+        get_fee_payer,
+    )
+except ImportError:
+    # Fallback if facilitator module not loaded yet
+    ALGORAND_FEE_PAYER_MAINNET = "KIMS5H6QLCUDL65L5UBTOXDPWLMTS7N3AAC3I6B2NCONEI5QIVK7LH2C2I"
+    ALGORAND_FEE_PAYER_TESTNET = "5DPPDQNYUPCTXRZWRYSF3WPYU6RKAUR25F3YG4EKXQRHV5AUAI62H5GXL4"
+    get_fee_payer = None  # type: ignore
+
 
 # =============================================================================
 # Algorand Networks Configuration
@@ -63,6 +95,8 @@ ALGORAND = NetworkConfig(
         "genesis_id": "mainnet-v1.0",
         # Genesis hash (for CAIP-2)
         "genesis_hash": "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
+        # x402 network name (facilitator expects this format)
+        "x402_network": "algorand-mainnet",
     },
 )
 
@@ -89,6 +123,8 @@ ALGORAND_TESTNET = NetworkConfig(
         "genesis_id": "testnet-v1.0",
         # Genesis hash
         "genesis_hash": "SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=",
+        # x402 network name (facilitator expects this format)
+        "x402_network": "algorand-testnet",
     },
 )
 
@@ -97,6 +133,34 @@ register_network(ALGORAND)
 register_network(ALGORAND_TESTNET)
 
 
+# =============================================================================
+# Algorand Payment Payload (x402-avm Atomic Group Spec)
+# =============================================================================
+
+
+@dataclass
+class AlgorandPaymentPayload:
+    """
+    Algorand payment payload for x402 atomic group format.
+
+    Attributes:
+        payment_index: Index of the payment transaction in the group (typically 1)
+        payment_group: List of base64-encoded msgpack transactions
+                      [0] = unsigned fee transaction
+                      [1] = signed ASA transfer transaction
+    """
+
+    payment_index: int
+    payment_group: List[str]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "paymentIndex": self.payment_index,
+            "paymentGroup": self.payment_group,
+        }
+
+
 # =============================================================================
 # Algorand-specific utilities
 # =============================================================================
@@ -162,59 +226,99 @@ def is_valid_algorand_address(address: str) -> bool:
 
 def validate_algorand_payload(payload: Dict[str, Any]) -> bool:
     """
-    Validate an Algorand payment payload structure.
+    Validate an Algorand payment payload structure (x402-avm atomic group format).
 
     The payload must contain:
-    - from: Sender's Algorand address
-    - to: Recipient's Algorand address
-    - amount: Amount in base units (microUSDC)
-    - assetId: ASA ID for USDC
-    - signedTxn: Base64-encoded signed transaction
+    - paymentIndex: Index of the payment transaction (typically 1)
+    - paymentGroup: List of base64-encoded msgpack transactions
+      - [0]: Unsigned fee transaction (facilitator -> facilitator)
+      - [1]: Signed ASA transfer (client -> merchant)
 
     Args:
-        payload: Payload dictionary from x402 payment
+        payload: Payload dictionary from x402 payment (the inner "payload" field)
 
     Returns:
         True if valid, raises ValueError if invalid
+
+    Example:
+        >>> payload = {
+        ...     "paymentIndex": 1,
+        ...     "paymentGroup": [
+        ...         "base64-unsigned-fee-tx...",
+        ...         "base64-signed-payment-tx..."
+        ...     ]
+        ... }
+        >>> validate_algorand_payload(payload)
+        True
     """
-    required_fields = ["from", "to", "amount", "assetId", "signedTxn"]
+    # Check required fields
+    if "paymentIndex" not in payload:
+        raise ValueError("Algorand payload missing 'paymentIndex' field")
+    if "paymentGroup" not in payload:
+        raise ValueError("Algorand payload missing 'paymentGroup' field")
+
+    # Validate paymentIndex
+    payment_index = payload["paymentIndex"]
+    if not isinstance(payment_index, int) or payment_index < 0:
+        raise ValueError(f"paymentIndex must be a non-negative integer: {payment_index}")
+
+    # Validate paymentGroup
+    payment_group = payload["paymentGroup"]
+    if not isinstance(payment_group, list):
+        raise ValueError("paymentGroup must be a list")
+
+    if len(payment_group) < 2:
+        raise ValueError(
+            f"paymentGroup must contain at least 2 transactions, got {len(payment_group)}"
+        )
+
+    if payment_index >= len(payment_group):
+        raise ValueError(
+            f"paymentIndex ({payment_index}) out of range for paymentGroup "
+            f"(length {len(payment_group)})"
+        )
+
+    # Validate each transaction in the group is valid base64
+    for i, txn_b64 in enumerate(payment_group):
+        if not isinstance(txn_b64, str):
+            raise ValueError(f"paymentGroup[{i}] must be a string")
+
+        try:
+            txn_bytes = base64.b64decode(txn_b64)
+            if len(txn_bytes) < 50:
+                raise ValueError(
+                    f"paymentGroup[{i}] transaction too short: {len(txn_bytes)} bytes"
+                )
+        except Exception as e:
+            raise ValueError(
+                f"paymentGroup[{i}] is not valid base64: {e}"
+            ) from e
 
-    for field in required_fields:
-        if field not in payload:
-            raise ValueError(f"Algorand payload missing '{field}' field")
+    return True
 
-    # Validate addresses
-    if not is_valid_algorand_address(payload["from"]):
-        raise ValueError(f"Invalid 'from' address: {payload['from']}")
-    if not is_valid_algorand_address(payload["to"]):
-        raise ValueError(f"Invalid 'to' address: {payload['to']}")
 
-    # Validate amount
-    try:
-        amount = int(payload["amount"])
-        if amount <= 0:
-            raise ValueError(f"Amount must be positive: {amount}")
-    except (ValueError, TypeError) as e:
-        raise ValueError(f"Invalid amount: {payload['amount']}") from e
+def get_x402_network_name(network_name: str) -> str:
+    """
+    Get the x402 network name for an Algorand network.
 
-    # Validate assetId
-    try:
-        asset_id = int(payload["assetId"])
-        if asset_id <= 0:
-            raise ValueError(f"Asset ID must be positive: {asset_id}")
-    except (ValueError, TypeError) as e:
-        raise ValueError(f"Invalid assetId: {payload['assetId']}") from e
+    The facilitator expects "algorand-mainnet" or "algorand-testnet".
 
-    # Validate signedTxn is valid base64
-    try:
-        signed_txn = payload["signedTxn"]
-        tx_bytes = base64.b64decode(signed_txn)
-        if len(tx_bytes) < 50:
-            raise ValueError(f"Signed transaction too short: {len(tx_bytes)} bytes")
-    except Exception as e:
-        raise ValueError(f"Invalid signedTxn (not valid base64): {e}") from e
+    Args:
+        network_name: SDK network name ('algorand' or 'algorand-testnet')
 
-    return True
+    Returns:
+        x402 network name ('algorand-mainnet' or 'algorand-testnet')
+    """
+    from uvd_x402_sdk.networks.base import get_network
+
+    network = get_network(network_name)
+    if not network:
+        # Default mapping
+        if network_name == "algorand":
+            return "algorand-mainnet"
+        return network_name
+
+    return network.extra_config.get("x402_network", network_name)
 
 
 def get_explorer_tx_url(network_name: str, tx_id: str) -> Optional[str]:
@@ -285,3 +389,209 @@ def get_usdc_asa_id(network_name: str) -> Optional[int]:
         return int(network.usdc_address)
     except (ValueError, TypeError):
         return None
+
+
+# =============================================================================
+# Atomic Group Builder (requires algosdk)
+# =============================================================================
+
+
+def build_atomic_group(
+    sender_address: str,
+    recipient_address: str,
+    amount: int,
+    asset_id: int,
+    facilitator_address: str,
+    sign_transaction: Callable,
+    algod_client: Optional[Any] = None,
+    suggested_params: Optional[Any] = None,
+) -> AlgorandPaymentPayload:
+    """
+    Build an Algorand atomic group for x402 payment.
+
+    This creates the two-transaction atomic group required by the facilitator:
+    - Transaction 0: Unsigned fee payment (facilitator -> facilitator, 0 amount)
+    - Transaction 1: Signed ASA transfer (sender -> recipient)
+
+    Requires: pip install py-algorand-sdk
+
+    Args:
+        sender_address: Client's Algorand address
+        recipient_address: Merchant's Algorand address (from payTo)
+        amount: Amount in micro-units (1 USDC = 1,000,000)
+        asset_id: USDC ASA ID (31566704 mainnet, 10458941 testnet)
+        facilitator_address: Facilitator address (from extra.feePayer)
+        sign_transaction: Function that signs a transaction.
+                         Signature: (transaction) -> SignedTransaction
+                         Can use algosdk's transaction.sign(private_key)
+        algod_client: Optional AlgodClient for getting suggested params.
+                     If not provided, suggested_params must be given.
+        suggested_params: Optional SuggestedParams. If not provided,
+                         algod_client.suggested_params() is called.
+
+    Returns:
+        AlgorandPaymentPayload with paymentIndex and paymentGroup
+
+    Raises:
+        ImportError: If algosdk is not installed
+        ValueError: If neither algod_client nor suggested_params provided
+
+    Example:
+        >>> from algosdk import transaction
+        >>> from algosdk.v2client import algod
+        >>>
+        >>> client = algod.AlgodClient("", "https://mainnet-api.algonode.cloud")
+        >>> payload = build_atomic_group(
+        ...     sender_address="SENDER...",
+        ...     recipient_address="MERCHANT...",
+        ...     amount=1000000,  # 1 USDC
+        ...     asset_id=31566704,
+        ...     facilitator_address="FACILITATOR...",
+        ...     sign_transaction=lambda txn: txn.sign(private_key),
+        ...     algod_client=client,
+        ... )
+    """
+    try:
+        from algosdk import encoding, transaction
+    except ImportError as e:
+        raise ImportError(
+            "algosdk is required for building atomic groups. "
+            "Install with: pip install py-algorand-sdk"
+        ) from e
+
+    # Get suggested params
+    if suggested_params is None:
+        if algod_client is None:
+            raise ValueError(
+                "Either algod_client or suggested_params must be provided"
+            )
+        suggested_params = algod_client.suggested_params()
+
+    # Transaction 0: Fee payment (facilitator -> facilitator, 0 amount)
+    # This transaction pays fees for both txns in the group
+    fee_txn = transaction.PaymentTxn(
+        sender=facilitator_address,
+        receiver=facilitator_address,  # self-transfer
+        amt=0,
+        sp=suggested_params,
+    )
+    # Cover both transactions (1000 microAlgos each = 2000 total)
+    fee_txn.fee = 2000
+
+    # Transaction 1: ASA transfer (client -> merchant)
+    payment_txn = transaction.AssetTransferTxn(
+        sender=sender_address,
+        receiver=recipient_address,
+        amt=amount,
+        index=asset_id,
+        sp=suggested_params,
+    )
+    # Fee paid by transaction 0
+    payment_txn.fee = 0
+
+    # Assign group ID to both transactions
+    group_id = transaction.calculate_group_id([fee_txn, payment_txn])
+    fee_txn.group = group_id
+    payment_txn.group = group_id
+
+    # Encode fee transaction (UNSIGNED - facilitator will sign)
+    unsigned_fee_txn_bytes = encoding.msgpack_encode(fee_txn)
+    unsigned_fee_txn_base64 = base64.b64encode(unsigned_fee_txn_bytes).decode("utf-8")
+
+    # Sign and encode payment transaction
+    signed_payment_txn = sign_transaction(payment_txn)
+    signed_payment_txn_bytes = encoding.msgpack_encode(signed_payment_txn)
+    signed_payment_txn_base64 = base64.b64encode(signed_payment_txn_bytes).decode("utf-8")
+
+    return AlgorandPaymentPayload(
+        payment_index=1,  # Index of the payment transaction
+        payment_group=[
+            unsigned_fee_txn_base64,   # Transaction 0: unsigned fee tx
+            signed_payment_txn_base64,  # Transaction 1: signed payment tx
+        ],
+    )
+
+
+def create_private_key_signer(private_key: str) -> Callable:
+    """
+    Create a transaction signer from a private key.
+
+    Args:
+        private_key: Algorand private key (base64 encoded)
+
+    Returns:
+        Function that signs transactions
+
+    Example:
+        >>> signer = create_private_key_signer(my_private_key)
+        >>> payload = build_atomic_group(..., sign_transaction=signer)
+    """
+    def sign(txn: Any) -> Any:
+        return txn.sign(private_key)
+    return sign
+
+
+def build_x402_payment_request(
+    payload: AlgorandPaymentPayload,
+    network: str = "algorand-mainnet",
+    scheme: str = "exact",
+    version: int = 1,
+) -> Dict[str, Any]:
+    """
+    Build a complete x402 payment request for Algorand.
+
+    Args:
+        payload: AlgorandPaymentPayload from build_atomic_group()
+        network: Network name ("algorand-mainnet" or "algorand-testnet")
+        scheme: Payment scheme (default "exact")
+        version: x402 version (default 1)
+
+    Returns:
+        Complete x402 payment request dictionary
+
+    Example:
+        >>> payload = build_atomic_group(...)
+        >>> request = build_x402_payment_request(payload)
+        >>> # Send as X-PAYMENT header (base64 encoded JSON)
+        >>> import json, base64
+        >>> header = base64.b64encode(json.dumps(request).encode()).decode()
+    """
+    return {
+        "x402Version": version,
+        "scheme": scheme,
+        "network": network,
+        "payload": payload.to_dict(),
+    }
+
+
+def get_algorand_fee_payer(network_name: str = "algorand") -> str:
+    """
+    Get the fee payer address for an Algorand network.
+
+    The fee payer is the facilitator address that pays transaction fees
+    for the atomic group. This address is used to construct Transaction 0
+    (the fee payment transaction).
+
+    Args:
+        network_name: Network name ('algorand' or 'algorand-testnet')
+
+    Returns:
+        Fee payer address for the specified network
+
+    Example:
+        >>> get_algorand_fee_payer("algorand")
+        'KIMS5H6QLCUDL65L5UBTOXDPWLMTS7N3AAC3I6B2NCONEI5QIVK7LH2C2I'
+        >>> get_algorand_fee_payer("algorand-testnet")
+        '5DPPDQNYUPCTXRZWRYSF3WPYU6RKAUR25F3YG4EKXQRHV5AUAI62H5GXL4'
+    """
+    # Use facilitator module if available
+    if get_fee_payer is not None:
+        fee_payer = get_fee_payer(network_name)
+        if fee_payer:
+            return fee_payer
+
+    # Fallback to direct lookup
+    network_lower = network_name.lower()
+    if "testnet" in network_lower:
+        return ALGORAND_FEE_PAYER_TESTNET
+    return ALGORAND_FEE_PAYER_MAINNET

uvd_x402_sdk/networks/near.py

@@ -32,6 +32,20 @@ from uvd_x402_sdk.networks.base import (
     register_network,
 )
 
+# NEAR fee payer addresses are defined in uvd_x402_sdk.facilitator
+# Import here for convenience
+try:
+    from uvd_x402_sdk.facilitator import (
+        NEAR_FEE_PAYER_MAINNET,
+        NEAR_FEE_PAYER_TESTNET,
+        get_fee_payer,
+    )
+except ImportError:
+    # Fallback if facilitator module not loaded yet
+    NEAR_FEE_PAYER_MAINNET = "uvd-facilitator.near"
+    NEAR_FEE_PAYER_TESTNET = "uvd-facilitator.testnet"
+    get_fee_payer = None  # type: ignore
+
 # NEP-366 hash prefix: (2^30 + 366) = 1073742190
 NEP366_PREFIX = ((2**30) + 366).to_bytes(4, 'little')
 
@@ -395,3 +409,35 @@ def is_valid_near_account_id(account_id: str) -> bool:
 
     allowed = set('abcdefghijklmnopqrstuvwxyz0123456789_-.')
     return all(c in allowed for c in account_id)
+
+
+def get_near_fee_payer(network_name: str = "near") -> str:
+    """
+    Get the fee payer account ID for a NEAR network.
+
+    The fee payer is the facilitator account that pays gas fees.
+    This account wraps the SignedDelegateAction and submits it.
+
+    Args:
+        network_name: Network name ('near' or 'near-testnet')
+
+    Returns:
+        Fee payer account ID for the specified network
+
+    Example:
+        >>> get_near_fee_payer("near")
+        'uvd-facilitator.near'
+        >>> get_near_fee_payer("near-testnet")
+        'uvd-facilitator.testnet'
+    """
+    # Use facilitator module if available
+    if get_fee_payer is not None:
+        fee_payer = get_fee_payer(network_name)
+        if fee_payer:
+            return fee_payer
+
+    # Fallback to direct lookup
+    network_lower = network_name.lower()
+    if "testnet" in network_lower:
+        return NEAR_FEE_PAYER_TESTNET
+    return NEAR_FEE_PAYER_MAINNET

uvd_x402_sdk/networks/solana.py

@@ -38,6 +38,24 @@ from uvd_x402_sdk.networks.base import (
     register_network,
 )
 
+# SVM fee payer addresses are defined in uvd_x402_sdk.facilitator
+# Import here for convenience
+try:
+    from uvd_x402_sdk.facilitator import (
+        SOLANA_FEE_PAYER_MAINNET,
+        SOLANA_FEE_PAYER_DEVNET,
+        FOGO_FEE_PAYER_MAINNET,
+        FOGO_FEE_PAYER_TESTNET,
+        get_fee_payer,
+    )
+except ImportError:
+    # Fallback if facilitator module not loaded yet
+    SOLANA_FEE_PAYER_MAINNET = "F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq"
+    SOLANA_FEE_PAYER_DEVNET = "6xNPewUdKRbEZDReQdpyfNUdgNg8QRc8Mt263T5GZSRv"
+    FOGO_FEE_PAYER_MAINNET = "F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq"
+    FOGO_FEE_PAYER_TESTNET = "6xNPewUdKRbEZDReQdpyfNUdgNg8QRc8Mt263T5GZSRv"
+    get_fee_payer = None  # type: ignore
+
 
 # =============================================================================
 # SVM Networks Configuration
@@ -351,3 +369,43 @@ def is_token_2022(token_type: str) -> bool:
         True if token uses Token2022, False for standard SPL
     """
     return token_type.lower() in TOKEN_2022_TOKENS
+
+
+def get_svm_fee_payer(network_name: str = "solana") -> str:
+    """
+    Get the fee payer address for an SVM network.
+
+    The fee payer is the facilitator address that pays transaction fees.
+    This address should be used as the fee payer in VersionedTransaction.
+
+    Args:
+        network_name: Network name ('solana', 'solana-devnet', 'fogo', 'fogo-testnet')
+
+    Returns:
+        Fee payer address for the specified network
+
+    Example:
+        >>> get_svm_fee_payer("solana")
+        'F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq'
+        >>> get_svm_fee_payer("solana-devnet")
+        '6xNPewUdKRbEZDReQdpyfNUdgNg8QRc8Mt263T5GZSRv'
+    """
+    # Use facilitator module if available
+    if get_fee_payer is not None:
+        fee_payer = get_fee_payer(network_name)
+        if fee_payer:
+            return fee_payer
+
+    # Fallback to direct lookup
+    network_lower = network_name.lower()
+    if "fogo" in network_lower:
+        if "testnet" in network_lower:
+            return FOGO_FEE_PAYER_TESTNET
+        return FOGO_FEE_PAYER_MAINNET
+    elif "devnet" in network_lower:
+        return SOLANA_FEE_PAYER_DEVNET
+    return SOLANA_FEE_PAYER_MAINNET
+
+
+# Alias for backward compatibility
+get_solana_fee_payer = get_svm_fee_payer

uvd_x402_sdk/networks/stellar.py

@@ -19,6 +19,20 @@ from uvd_x402_sdk.networks.base import (
     register_network,
 )
 
+# Stellar fee payer addresses are defined in uvd_x402_sdk.facilitator
+# Import here for convenience
+try:
+    from uvd_x402_sdk.facilitator import (
+        STELLAR_FEE_PAYER_MAINNET,
+        STELLAR_FEE_PAYER_TESTNET,
+        get_fee_payer,
+    )
+except ImportError:
+    # Fallback if facilitator module not loaded yet
+    STELLAR_FEE_PAYER_MAINNET = "GCHPGXJT2WFFRFCA5TV4G4E3PMMXLNIDUH27PKDYA4QJ2XGYZWGFZNHB"
+    STELLAR_FEE_PAYER_TESTNET = "GBBFZMLUJEZVI32EN4XA2KPP445XIBTMTRBLYWFIL556RDTHS2OWFQ2Z"
+    get_fee_payer = None  # type: ignore
+
 # Stellar Mainnet
 STELLAR = NetworkConfig(
     name="stellar",
@@ -127,3 +141,35 @@ def calculate_expiration_ledger(current_ledger: int, validity_ledgers: int = 60)
         Expiration ledger number
     """
     return current_ledger + validity_ledgers
+
+
+def get_stellar_fee_payer(network_name: str = "stellar") -> str:
+    """
+    Get the fee payer address for a Stellar network.
+
+    The fee payer is the facilitator address that pays XLM transaction fees.
+    This address wraps the SorobanAuthorizationEntry in a fee-bump transaction.
+
+    Args:
+        network_name: Network name ('stellar' or 'stellar-testnet')
+
+    Returns:
+        Fee payer public key (G... address) for the specified network
+
+    Example:
+        >>> get_stellar_fee_payer("stellar")
+        'GCHPGXJT2WFFRFCA5TV4G4E3PMMXLNIDUH27PKDYA4QJ2XGYZWGFZNHB'
+        >>> get_stellar_fee_payer("stellar-testnet")
+        'GBBFZMLUJEZVI32EN4XA2KPP445XIBTMTRBLYWFIL556RDTHS2OWFQ2Z'
+    """
+    # Use facilitator module if available
+    if get_fee_payer is not None:
+        fee_payer = get_fee_payer(network_name)
+        if fee_payer:
+            return fee_payer
+
+    # Fallback to direct lookup
+    network_lower = network_name.lower()
+    if "testnet" in network_lower:
+        return STELLAR_FEE_PAYER_TESTNET
+    return STELLAR_FEE_PAYER_MAINNET

{uvd_x402_sdk-0.4.1.dist-info → uvd_x402_sdk-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: uvd-x402-sdk
-Version: 0.4.1
+Version: 0.5.0
 Summary: Python SDK for x402 payments - gasless crypto payments across 16 blockchains with multi-stablecoin support (USDC, EURC, AUSD, PYUSD, USDT)
 Author-email: Ultravioleta DAO <dev@ultravioletadao.xyz>
 Project-URL: Homepage, https://github.com/UltravioletaDAO/uvd-x402-sdk-python
@@ -24,8 +24,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: pydantic>=2.0.0
+Provides-Extra: algorand
+Requires-Dist: py-algorand-sdk>=2.0.0; extra == "algorand"
 Provides-Extra: all
-Requires-Dist: uvd-x402-sdk[aws,django,fastapi,flask,web3]; extra == "all"
+Requires-Dist: uvd-x402-sdk[algorand,aws,django,fastapi,flask,web3]; extra == "all"
 Provides-Extra: aws
 Requires-Dist: boto3>=1.26.0; extra == "aws"
 Provides-Extra: dev

{uvd_x402_sdk-0.4.1.dist-info → uvd_x402_sdk-0.5.0.dist-info}/RECORD

@@ -1,8 +1,9 @@
-uvd_x402_sdk/__init__.py,sha256=9nsWXd6hA-22hXr8NM_JioVWzJbFu3wIllmKe9O8DW0,4901
+uvd_x402_sdk/__init__.py,sha256=S_oA8b99W7CP6_RPtOlc7ZotYLvdTZJM9Sqc2s3O6zo,6261
 uvd_x402_sdk/client.py,sha256=QbK22DtC3HmvvCezphQ-UsYX468vKrIN-M_wF4pv9cM,18389
 uvd_x402_sdk/config.py,sha256=BNGnX2RwZ_ELIcSKU7RkwTUcln4LMFZdCwG1ptASKN8,8644
 uvd_x402_sdk/decorators.py,sha256=XJ7V4554hsa-AVDrizF1oKmeTysg5zlkQRcaeGBI73E,9767
 uvd_x402_sdk/exceptions.py,sha256=kzYNHFn41dSOZ5HaBDrbf4tdwJYQs1YcU9YybTrGZxo,6527
+uvd_x402_sdk/facilitator.py,sha256=kX--Uk6BYlDCalKD-2LpPOgEi-t26C-sjcxgalphJp8,11859
 uvd_x402_sdk/models.py,sha256=nfA8Ak0pyIveiNpstjqxnQ6-aPQ8TRJzJq2LJwlJc-E,14282
 uvd_x402_sdk/response.py,sha256=4wxH4kWg1F8pokKEbN1kDvDF55cQxmQUN88HTxXht8g,13608
 uvd_x402_sdk/integrations/__init__.py,sha256=Hq1Y0YIMYWBAtmbOLXDC40KQuCrbSpQVjAqEsbjH56s,1912
@@ -11,14 +12,14 @@ uvd_x402_sdk/integrations/fastapi_integration.py,sha256=j5h1IJwFLBBoWov7ANLCFaxe
 uvd_x402_sdk/integrations/flask_integration.py,sha256=0iQKO5-WRxE76Pv-1jEl4lYhjCLmq_R-jxR5g9xIcKw,8825
 uvd_x402_sdk/integrations/lambda_integration.py,sha256=nRf4o3nS6Syx-d5P0kEhz66y7jb_S4w-mwaIazgiA9c,10184
 uvd_x402_sdk/networks/__init__.py,sha256=LKl_TljVoCDb27YB4X_VbQN8XKbdwWFAsCwgiqQtlgo,2092
-uvd_x402_sdk/networks/algorand.py,sha256=ACaVMyXItRX3M29GPwwMMxECMjNXx3FlYARNBeAztH4,8601
+uvd_x402_sdk/networks/algorand.py,sha256=_eQfR8xguvTloJBR7_yGbWjC2KgmPux44pXeDVM7b0w,19458
 uvd_x402_sdk/networks/base.py,sha256=gOPWfqasGbgtg9w2uG5pWnfjdOEain92L2egnDSBguc,14863
 uvd_x402_sdk/networks/evm.py,sha256=4IbeaMH2I1c9DYCijghys0qYNeL2Nl92IMKLwq-b0Zg,10065
-uvd_x402_sdk/networks/near.py,sha256=sxbxT1NqjcENh8ysFLDpAx5DGizf1EI0YjwgviLfqcY,11608
-uvd_x402_sdk/networks/solana.py,sha256=-snAeE3OxJU_kaGb_z4NOU6k0SGAD4DBPhJcPbgrdgo,11675
-uvd_x402_sdk/networks/stellar.py,sha256=c-6re-dVc2-6gJ5rL4krUTaFsPz5vkactOJD-0wowBA,3534
-uvd_x402_sdk-0.4.1.dist-info/LICENSE,sha256=OcLzB_iSgMbvk7b0dlyvleY_IbL2WUaPxvn1CHw2uAc,1073
-uvd_x402_sdk-0.4.1.dist-info/METADATA,sha256=3cD7Kz9_fONGwbZVUBMOxXqglRmC_wikuBH8OWpIT24,29618
-uvd_x402_sdk-0.4.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-uvd_x402_sdk-0.4.1.dist-info/top_level.txt,sha256=Exyjj_Kl7CDAGFMi72lT9oFPOYiRNZb3l8tr906mMmc,13
-uvd_x402_sdk-0.4.1.dist-info/RECORD,,
+uvd_x402_sdk/networks/near.py,sha256=HMMWJr-Jckj3YQTbSXkavlJWZB7ZV8OQX0bq8DuVxIg,12990
+uvd_x402_sdk/networks/solana.py,sha256=GVUeh0O2W6f8Vbgoom2UQSGI8joZV68Pnpzhh87Bnqg,13640
+uvd_x402_sdk/networks/stellar.py,sha256=ZuF-crx41N9MxSsgf2kAy88fsM-xvDyXY_D2ND6M71Y,5142
+uvd_x402_sdk-0.5.0.dist-info/LICENSE,sha256=OcLzB_iSgMbvk7b0dlyvleY_IbL2WUaPxvn1CHw2uAc,1073
+uvd_x402_sdk-0.5.0.dist-info/METADATA,sha256=2BkT_uVVDdWwuAnmjgS61pNXJWKP1e2wjWGf9R8VAEw,29711
+uvd_x402_sdk-0.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+uvd_x402_sdk-0.5.0.dist-info/top_level.txt,sha256=Exyjj_Kl7CDAGFMi72lT9oFPOYiRNZb3l8tr906mMmc,13
+uvd_x402_sdk-0.5.0.dist-info/RECORD,,