t402 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

t402/__init__.py

@@ -1,2 +1,98 @@
+# Re-export commonly used items for convenience
+from t402.common import (
+    parse_money,
+    process_price_to_atomic_amount,
+    find_matching_payment_requirements,
+    t402_VERSION,
+)
+from t402.networks import (
+    is_ton_network,
+    is_evm_network,
+    get_network_type,
+)
+from t402.types import (
+    PaymentRequirements,
+    PaymentPayload,
+    VerifyResponse,
+    SettleResponse,
+    TonAuthorization,
+    TonPaymentPayload,
+)
+from t402.facilitator import FacilitatorClient, FacilitatorConfig
+from t402.exact import (
+    prepare_payment_header,
+    sign_payment_header,
+    encode_payment,
+    decode_payment,
+)
+from t402.ton import (
+    TON_MAINNET,
+    TON_TESTNET,
+    USDT_MAINNET_ADDRESS,
+    USDT_TESTNET_ADDRESS,
+    validate_ton_address,
+    get_usdt_address,
+    get_network_config as get_ton_network_config,
+    get_default_asset as get_ton_default_asset,
+    prepare_ton_payment_header,
+    parse_amount as parse_ton_amount,
+    format_amount as format_ton_amount,
+    validate_boc,
+    is_testnet as is_ton_testnet,
+)
+from t402.paywall import (
+    get_paywall_html,
+    get_paywall_template,
+    is_browser_request,
+)
+
 def hello() -> str:
     return "Hello from t402!"
+
+
+__all__ = [
+    # Core
+    "hello",
+    "t402_VERSION",
+    # Common utilities
+    "parse_money",
+    "process_price_to_atomic_amount",
+    "find_matching_payment_requirements",
+    # Network utilities
+    "is_ton_network",
+    "is_evm_network",
+    "get_network_type",
+    # Types
+    "PaymentRequirements",
+    "PaymentPayload",
+    "VerifyResponse",
+    "SettleResponse",
+    "TonAuthorization",
+    "TonPaymentPayload",
+    # Facilitator
+    "FacilitatorClient",
+    "FacilitatorConfig",
+    # EVM payment
+    "prepare_payment_header",
+    "sign_payment_header",
+    "encode_payment",
+    "decode_payment",
+    # TON utilities
+    "TON_MAINNET",
+    "TON_TESTNET",
+    "USDT_MAINNET_ADDRESS",
+    "USDT_TESTNET_ADDRESS",
+    "validate_ton_address",
+    "get_usdt_address",
+    "get_ton_network_config",
+    "get_ton_default_asset",
+    "prepare_ton_payment_header",
+    "parse_ton_amount",
+    "format_ton_amount",
+    "validate_boc",
+    "is_ton_testnet",
+    # Paywall
+    "get_paywall_html",
+    "get_paywall_template",
+    "is_browser_request",
+]

t402/common.py

@@ -8,6 +8,7 @@ from t402.chains import (
     get_token_version,
     get_default_token_address,
 )
+from t402.networks import is_ton_network
 from t402.types import Price, TokenAmount, PaymentRequirements, PaymentPayload
 
 
@@ -22,8 +23,14 @@ def parse_money(amount: str | int, address: str, network: str) -> int:
             amount = amount[1:]
         decimal_amount = Decimal(amount)
 
-        chain_id = get_chain_id(network)
-        decimals = get_token_decimals(chain_id, address)
+        # Handle TON networks differently
+        if is_ton_network(network):
+            from t402.ton import DEFAULT_DECIMALS
+            decimals = DEFAULT_DECIMALS  # USDT on TON uses 6 decimals
+        else:
+            chain_id = get_chain_id(network)
+            decimals = get_token_decimals(chain_id, address)
+
         decimal_amount = decimal_amount * Decimal(10**decimals)
         return int(decimal_amount)
     return amount
@@ -39,19 +46,42 @@ def process_price_to_atomic_amount(
         network: Network identifier
 
     Returns:
-        Tuple of (max_amount_required, asset_address, eip712_domain)
+        Tuple of (max_amount_required, asset_address, extra_info)
+        For EVM: extra_info contains EIP-712 domain (name, version)
+        For TON: extra_info contains Jetton metadata (name, symbol)
 
     Raises:
         ValueError: If price format is invalid
     """
     if isinstance(price, (str, int)):
-        # Money type - convert USD to USDC atomic units
+        # Money type - convert USD to atomic units
         try:
             if isinstance(price, str) and price.startswith("$"):
                 price = price[1:]
             amount = Decimal(str(price))
 
-            # Get USDC address for the network
+            # Handle TON networks
+            if is_ton_network(network):
+                from t402.ton import (
+                    get_usdt_address,
+                    get_default_asset,
+                    DEFAULT_DECIMALS,
+                )
+
+                asset_address = get_usdt_address(network)
+                decimals = DEFAULT_DECIMALS
+                atomic_amount = int(amount * Decimal(10**decimals))
+
+                # For TON, return Jetton metadata instead of EIP-712 domain
+                asset_info = get_default_asset(network)
+                extra_info = {
+                    "name": asset_info["name"] if asset_info else "Tether USD",
+                    "symbol": asset_info["symbol"] if asset_info else "USDT",
+                }
+
+                return str(atomic_amount), asset_address, extra_info
+
+            # Handle EVM networks
             chain_id = get_chain_id(network)
             asset_address = get_usdc_address(chain_id)
             decimals = get_token_decimals(chain_id, asset_address)

t402/fastapi/middleware.py

@@ -1,7 +1,7 @@
 import base64
 import json
 import logging
-from typing import Any, Callable, Optional, get_args, cast
+from typing import Any, Callable, Optional, cast
 
 from fastapi import Request
 from fastapi.responses import JSONResponse, HTMLResponse
@@ -14,6 +14,7 @@ from t402.common import (
 )
 from t402.encoding import safe_base64_decode
 from t402.facilitator import FacilitatorClient, FacilitatorConfig
+from t402.networks import get_all_supported_networks, SupportedNetworks
 from t402.path import path_is_match
 from t402.paywall import is_browser_request, get_paywall_html
 from t402.types import (
@@ -22,7 +23,6 @@ from t402.types import (
     Price,
     t402PaymentRequiredResponse,
     PaywallConfig,
-    SupportedNetworks,
     HTTPInputSchema,
 )
 
@@ -73,7 +73,7 @@ def require_payment(
     """
 
     # Validate network is supported
-    supported_networks = get_args(SupportedNetworks)
+    supported_networks = get_all_supported_networks()
     if network not in supported_networks:
         raise ValueError(
             f"Unsupported network: {network}. Must be one of: {supported_networks}"

t402/flask/middleware.py

@@ -1,15 +1,15 @@
 import base64
 import json
-from typing import Any, Dict, Optional, Union, get_args, cast
+from typing import Any, Dict, Optional, Union, cast
 from flask import Flask, request, g
 from t402.path import path_is_match
+from t402.networks import get_all_supported_networks, SupportedNetworks
 from t402.types import (
     Price,
     PaymentPayload,
     PaymentRequirements,
     t402PaymentRequiredResponse,
     PaywallConfig,
-    SupportedNetworks,
     HTTPInputSchema,
 )
 from t402.common import (
@@ -148,7 +148,7 @@ class PaymentMiddleware:
         """Create a WSGI middleware function for the given configuration."""
 
         # Validate network is supported
-        supported_networks = get_args(SupportedNetworks)
+        supported_networks = get_all_supported_networks()
         if config["network"] not in supported_networks:
             raise ValueError(
                 f"Unsupported network: {config['network']}. Must be one of: {supported_networks}"

t402/networks.py

@@ -1,7 +1,21 @@
-from typing import Literal
+from typing import Literal, Union, get_args
 
 
-SupportedNetworks = Literal["base", "base-sepolia", "avalanche-fuji", "avalanche"]
+# EVM Networks
+EVMNetworks = Literal["base", "base-sepolia", "avalanche-fuji", "avalanche"]
+
+# TON Networks (CAIP-2 format)
+TONNetworks = Literal["ton:mainnet", "ton:testnet"]
+
+# All supported networks
+SupportedNetworks = Union[EVMNetworks, TONNetworks]
+
+
+def get_all_supported_networks() -> tuple[str, ...]:
+    """Get all supported network identifiers as a flat tuple of strings."""
+    evm = get_args(EVMNetworks)
+    ton = get_args(TONNetworks)
+    return evm + ton
 
 EVM_NETWORK_TO_CHAIN_ID = {
     "base-sepolia": 84532,
@@ -9,3 +23,36 @@ EVM_NETWORK_TO_CHAIN_ID = {
     "avalanche-fuji": 43113,
     "avalanche": 43114,
 }
+
+# TON Network configurations
+TON_NETWORKS = {
+    "ton:mainnet": {
+        "name": "TON Mainnet",
+        "endpoint": "https://toncenter.com/api/v2/jsonRPC",
+        "is_testnet": False,
+    },
+    "ton:testnet": {
+        "name": "TON Testnet",
+        "endpoint": "https://testnet.toncenter.com/api/v2/jsonRPC",
+        "is_testnet": True,
+    },
+}
+
+
+def is_ton_network(network: str) -> bool:
+    """Check if a network is a TON network."""
+    return network.startswith("ton:")
+
+
+def is_evm_network(network: str) -> bool:
+    """Check if a network is an EVM network."""
+    return network in EVM_NETWORK_TO_CHAIN_ID
+
+
+def get_network_type(network: str) -> str:
+    """Get the network type (ton, evm, or unknown)."""
+    if is_ton_network(network):
+        return "ton"
+    if is_evm_network(network):
+        return "evm"
+    return "unknown"

t402/paywall.py

@@ -5,12 +5,15 @@ from t402.types import PaymentRequirements, PaywallConfig
 from t402.common import t402_VERSION
 from t402.evm_paywall_template import EVM_PAYWALL_TEMPLATE
 from t402.svm_paywall_template import SVM_PAYWALL_TEMPLATE
+from t402.ton_paywall_template import TON_PAYWALL_TEMPLATE
 
 
 def get_paywall_template(network: str) -> str:
     """Get the appropriate paywall template for the given network."""
     if network.startswith("solana:"):
         return SVM_PAYWALL_TEMPLATE
+    if network.startswith("ton:"):
+        return TON_PAYWALL_TEMPLATE
     return EVM_PAYWALL_TEMPLATE
 
 

t402/ton.py

@@ -0,0 +1,474 @@
+"""
+TON blockchain support for t402 protocol.
+
+This module provides types and utilities for TON (The Open Network) payments
+using USDT Jetton transfers.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+import base64
+from typing import Any, Dict, Optional, List
+from typing_extensions import TypedDict
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic.alias_generators import to_camel
+
+
+# Constants
+SCHEME_EXACT = "exact"
+DEFAULT_DECIMALS = 6
+
+# CAIP-2 network identifiers
+TON_MAINNET = "ton:mainnet"
+TON_TESTNET = "ton:testnet"
+
+# Jetton transfer operation codes (TEP-74)
+JETTON_TRANSFER_OP = 0x0F8A7EA5
+JETTON_INTERNAL_TRANSFER_OP = 0x178D4519
+JETTON_TRANSFER_NOTIFICATION_OP = 0x7362D09C
+JETTON_BURN_OP = 0x595F07BC
+
+# Gas defaults (in nanoTON)
+DEFAULT_JETTON_TRANSFER_TON = 100_000_000  # 0.1 TON
+DEFAULT_FORWARD_TON = 1  # Minimal forward
+MIN_JETTON_TRANSFER_TON = 50_000_000  # 0.05 TON minimum
+MAX_JETTON_TRANSFER_TON = 500_000_000  # 0.5 TON maximum
+
+# Validity and timing
+DEFAULT_VALIDITY_DURATION = 3600  # 1 hour in seconds
+MIN_VALIDITY_BUFFER = 30  # 30 seconds minimum validity
+
+# USDT Jetton master addresses
+USDT_MAINNET_ADDRESS = "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs"
+USDT_TESTNET_ADDRESS = "kQBqSpvo4S87mX9tTc4FX3Sfqf4uSp3Tx-Fz4RBUfTRWBx"
+
+# Address regex patterns
+TON_FRIENDLY_ADDRESS_REGEX = re.compile(r"^[A-Za-z0-9_-]{46,48}$")
+TON_RAW_ADDRESS_REGEX = re.compile(r"^-?[0-9]:[a-fA-F0-9]{64}$")
+
+
+class JettonConfig(TypedDict):
+    """Configuration for a Jetton token."""
+    master_address: str
+    symbol: str
+    name: str
+    decimals: int
+
+
+class NetworkConfig(TypedDict):
+    """Configuration for a TON network."""
+    name: str
+    endpoint: str
+    is_testnet: bool
+    default_asset: JettonConfig
+    supported_assets: Dict[str, JettonConfig]
+
+
+# Network configurations
+NETWORK_CONFIGS: Dict[str, NetworkConfig] = {
+    TON_MAINNET: {
+        "name": "TON Mainnet",
+        "endpoint": "https://toncenter.com/api/v2/jsonRPC",
+        "is_testnet": False,
+        "default_asset": {
+            "master_address": USDT_MAINNET_ADDRESS,
+            "symbol": "USDT",
+            "name": "Tether USD",
+            "decimals": DEFAULT_DECIMALS,
+        },
+        "supported_assets": {
+            "USDT": {
+                "master_address": USDT_MAINNET_ADDRESS,
+                "symbol": "USDT",
+                "name": "Tether USD",
+                "decimals": DEFAULT_DECIMALS,
+            },
+        },
+    },
+    TON_TESTNET: {
+        "name": "TON Testnet",
+        "endpoint": "https://testnet.toncenter.com/api/v2/jsonRPC",
+        "is_testnet": True,
+        "default_asset": {
+            "master_address": USDT_TESTNET_ADDRESS,
+            "symbol": "USDT",
+            "name": "Tether USD (Testnet)",
+            "decimals": DEFAULT_DECIMALS,
+        },
+        "supported_assets": {
+            "USDT": {
+                "master_address": USDT_TESTNET_ADDRESS,
+                "symbol": "USDT",
+                "name": "Tether USD (Testnet)",
+                "decimals": DEFAULT_DECIMALS,
+            },
+        },
+    },
+}
+
+
+class TonAuthorization(BaseModel):
+    """TON transfer authorization metadata."""
+
+    from_: str = Field(alias="from")
+    to: str
+    jetton_master: str = Field(alias="jettonMaster")
+    jetton_amount: str = Field(alias="jettonAmount")
+    ton_amount: str = Field(alias="tonAmount")
+    valid_until: int = Field(alias="validUntil")
+    seqno: int
+    query_id: str = Field(alias="queryId")
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    @field_validator("jetton_amount", "ton_amount")
+    def validate_amount(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError("amount must be an integer encoded as a string")
+        return v
+
+
+class TonPaymentPayload(BaseModel):
+    """TON payment payload containing signed BOC and authorization."""
+
+    signed_boc: str = Field(alias="signedBoc")
+    authorization: TonAuthorization
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
+class TonVerifyMessageResult(BaseModel):
+    """Result of TON message verification."""
+
+    valid: bool
+    reason: Optional[str] = None
+    transfer: Optional[Dict[str, Any]] = None
+
+
+class TonTransactionConfirmation(BaseModel):
+    """TON transaction confirmation result."""
+
+    success: bool
+    lt: Optional[str] = None
+    hash: Optional[str] = None
+    error: Optional[str] = None
+
+
+def validate_ton_address(address: str) -> bool:
+    """
+    Validate a TON address.
+
+    Supports both friendly format (base64url, 48 chars) and
+    raw format (workchain:hash).
+
+    Args:
+        address: The address to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    if not address:
+        return False
+
+    # Check friendly format (base64url, 46-48 chars)
+    if TON_FRIENDLY_ADDRESS_REGEX.match(address):
+        return True
+
+    # Check raw format (workchain:hash)
+    if TON_RAW_ADDRESS_REGEX.match(address):
+        return True
+
+    return False
+
+
+def addresses_equal(addr1: str, addr2: str) -> bool:
+    """
+    Compare two TON addresses for equality.
+
+    Args:
+        addr1: First address
+        addr2: Second address
+
+    Returns:
+        True if addresses are equal (case-insensitive)
+    """
+    return addr1.lower() == addr2.lower()
+
+
+def is_valid_network(network: str) -> bool:
+    """
+    Check if a network is a supported TON network.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        True if supported
+    """
+    return network in NETWORK_CONFIGS
+
+
+def get_network_config(network: str) -> Optional[NetworkConfig]:
+    """
+    Get configuration for a TON network.
+
+    Args:
+        network: Network identifier (e.g., "ton:mainnet")
+
+    Returns:
+        NetworkConfig or None if not found
+    """
+    return NETWORK_CONFIGS.get(network)
+
+
+def get_default_asset(network: str) -> Optional[JettonConfig]:
+    """
+    Get the default asset (USDT) for a network.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        JettonConfig or None if network not found
+    """
+    config = get_network_config(network)
+    if config:
+        return config["default_asset"]
+    return None
+
+
+def get_asset_info(network: str, asset_symbol_or_address: str) -> Optional[JettonConfig]:
+    """
+    Get asset information by symbol or address.
+
+    Args:
+        network: Network identifier
+        asset_symbol_or_address: Asset symbol (e.g., "USDT") or master address
+
+    Returns:
+        JettonConfig or None if not found
+    """
+    config = get_network_config(network)
+    if not config:
+        return None
+
+    # Check if it's a valid address
+    if validate_ton_address(asset_symbol_or_address):
+        # Check default asset
+        if addresses_equal(
+            asset_symbol_or_address, config["default_asset"]["master_address"]
+        ):
+            return config["default_asset"]
+
+        # Check supported assets by address
+        for asset in config["supported_assets"].values():
+            if addresses_equal(asset_symbol_or_address, asset["master_address"]):
+                return asset
+
+        # Unknown token
+        return {
+            "master_address": asset_symbol_or_address,
+            "symbol": "UNKNOWN",
+            "name": "Unknown Jetton",
+            "decimals": 9,
+        }
+
+    # Look up by symbol
+    symbol = asset_symbol_or_address.upper()
+    if symbol in config["supported_assets"]:
+        return config["supported_assets"][symbol]
+
+    # Default to network's default asset
+    return config["default_asset"]
+
+
+def parse_amount(amount: str, decimals: int) -> int:
+    """
+    Parse a decimal string amount to token smallest units.
+
+    Args:
+        amount: Decimal string (e.g., "1.50")
+        decimals: Token decimals
+
+    Returns:
+        Amount in smallest units
+
+    Raises:
+        ValueError: If amount format is invalid
+    """
+    amount = amount.strip()
+    parts = amount.split(".")
+
+    if len(parts) > 2:
+        raise ValueError(f"Invalid amount format: {amount}")
+
+    int_part = int(parts[0])
+
+    dec_part = 0
+    if len(parts) == 2 and parts[1]:
+        dec_str = parts[1]
+        if len(dec_str) > decimals:
+            dec_str = dec_str[:decimals]
+        else:
+            dec_str = dec_str + "0" * (decimals - len(dec_str))
+        dec_part = int(dec_str)
+
+    multiplier = 10**decimals
+    return int_part * multiplier + dec_part
+
+
+def format_amount(amount: int, decimals: int) -> str:
+    """
+    Format an amount in smallest units to a decimal string.
+
+    Args:
+        amount: Amount in smallest units
+        decimals: Token decimals
+
+    Returns:
+        Decimal string representation
+    """
+    if amount == 0:
+        return "0"
+
+    divisor = 10**decimals
+    quotient = amount // divisor
+    remainder = amount % divisor
+
+    if remainder == 0:
+        return str(quotient)
+
+    dec_str = str(remainder).zfill(decimals).rstrip("0")
+    return f"{quotient}.{dec_str}"
+
+
+def validate_boc(boc_base64: str) -> bool:
+    """
+    Validate that a string is a valid base64-encoded BOC.
+
+    Args:
+        boc_base64: Base64 encoded BOC string
+
+    Returns:
+        True if valid, False otherwise
+    """
+    if not boc_base64:
+        return False
+
+    try:
+        base64.b64decode(boc_base64)
+        return True
+    except Exception:
+        return False
+
+
+def is_testnet(network: str) -> bool:
+    """
+    Check if a network is a testnet.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        True if testnet
+    """
+    return network == TON_TESTNET
+
+
+def prepare_ton_payment_header(
+    sender_address: str,
+    t402_version: int,
+    network: str,
+    pay_to: str,
+    asset: str,
+    amount: str,
+    max_timeout_seconds: int = DEFAULT_VALIDITY_DURATION,
+) -> Dict[str, Any]:
+    """
+    Prepare an unsigned TON payment header.
+
+    Args:
+        sender_address: Sender's TON address
+        t402_version: Protocol version
+        network: Network identifier
+        pay_to: Recipient address
+        asset: Jetton master address
+        amount: Amount in smallest units
+        max_timeout_seconds: Maximum timeout in seconds
+
+    Returns:
+        Unsigned payment header dictionary
+    """
+    now = int(time.time())
+    valid_until = now + max_timeout_seconds
+    seqno = 0  # Will be filled by client
+    query_id = str(now * 1000000)  # Unique query ID
+
+    return {
+        "t402Version": t402_version,
+        "scheme": SCHEME_EXACT,
+        "network": network,
+        "payload": {
+            "signedBoc": None,  # Will be filled after signing
+            "authorization": {
+                "from": sender_address,
+                "to": pay_to,
+                "jettonMaster": asset,
+                "jettonAmount": amount,
+                "tonAmount": str(DEFAULT_JETTON_TRANSFER_TON),
+                "validUntil": valid_until,
+                "seqno": seqno,
+                "queryId": query_id,
+            },
+        },
+    }
+
+
+def get_usdt_address(network: str) -> str:
+    """
+    Get the USDT Jetton master address for a network.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        USDT master address
+
+    Raises:
+        ValueError: If network is not supported
+    """
+    if network == TON_MAINNET:
+        return USDT_MAINNET_ADDRESS
+    elif network == TON_TESTNET:
+        return USDT_TESTNET_ADDRESS
+    else:
+        raise ValueError(f"Unsupported TON network: {network}")
+
+
+def get_known_jettons(network: str) -> List[JettonConfig]:
+    """
+    Get list of known Jettons for a network.
+
+    Args:
+        network: Network identifier
+
+    Returns:
+        List of JettonConfig
+    """
+    config = get_network_config(network)
+    if not config:
+        return []
+    return list(config["supported_assets"].values())

t402/ton_paywall_template.py

@@ -0,0 +1,193 @@
+# THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+# TON Paywall Template - A simple placeholder template for TON payments
+# In production, this would be a full React-based paywall like the EVM/SVM templates
+
+TON_PAYWALL_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Payment Required - TON</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            min-height: 100vh;
+            background-color: #f9fafb;
+            font-family: Inter, system-ui, -apple-system, sans-serif;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .container {
+            max-width: 32rem;
+            margin: 2rem;
+            padding: 2rem;
+            background-color: white;
+            border-radius: 0.75rem;
+            box-shadow: 0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -1px rgba(0,0,0,0.06);
+            text-align: center;
+        }
+        .logo {
+            width: 64px;
+            height: 64px;
+            margin: 0 auto 1rem;
+        }
+        .title {
+            font-size: 1.5rem;
+            font-weight: 700;
+            color: #111827;
+            margin-bottom: 0.5rem;
+        }
+        .subtitle {
+            color: #6b7280;
+            margin-bottom: 1.5rem;
+        }
+        .payment-details {
+            background-color: #f3f4f6;
+            padding: 1rem;
+            border-radius: 0.5rem;
+            margin-bottom: 1.5rem;
+        }
+        .payment-row {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 0.5rem;
+        }
+        .payment-row:last-child { margin-bottom: 0; }
+        .payment-label { color: #6b7280; }
+        .payment-value { font-weight: 600; color: #111827; }
+        .button {
+            width: 100%;
+            padding: 0.75rem 1rem;
+            border-radius: 0.5rem;
+            font-weight: 600;
+            border: none;
+            cursor: pointer;
+            background-color: #0098EA;
+            color: white;
+            font-size: 1rem;
+            transition: background-color 0.15s;
+        }
+        .button:hover { background-color: #0088D4; }
+        .button:disabled {
+            background-color: #9ca3af;
+            cursor: not-allowed;
+        }
+        .ton-logo {
+            fill: #0098EA;
+        }
+        .status {
+            margin-top: 1rem;
+            font-size: 0.875rem;
+            color: #6b7280;
+        }
+        .error {
+            color: #dc2626;
+            background-color: #fef2f2;
+            padding: 0.75rem;
+            border-radius: 0.5rem;
+            margin-bottom: 1rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <svg class="logo" viewBox="0 0 56 56" fill="none" xmlns="http://www.w3.org/2000/svg">
+            <path d="M28 56C43.464 56 56 43.464 56 28C56 12.536 43.464 0 28 0C12.536 0 0 12.536 0 28C0 43.464 12.536 56 28 56Z" fill="#0098EA"/>
+            <path d="M37.5603 15.6277H18.4386C14.9228 15.6277 12.6944 19.4202 14.4632 22.4861L26.2644 42.9409C27.0345 44.2765 28.9644 44.2765 29.7345 42.9409L41.5765 22.4861C43.3045 19.4202 41.0761 15.6277 37.5603 15.6277ZM26.2211 36.5583L23.6856 31.0379L17.4565 19.7027C17.0579 18.9891 17.5607 18.0868 18.4386 18.0868H26.2211V36.5583ZM38.5765 19.6635L32.3474 31.0379L29.7711 36.5583V18.0868H37.5603C38.4382 18.0868 38.941 18.9891 38.5765 19.6635Z" fill="white"/>
+        </svg>
+        <h1 class="title">Payment Required</h1>
+        <p class="subtitle">This resource requires a TON payment to access.</p>
+
+        <div id="error-container"></div>
+
+        <div class="payment-details">
+            <div class="payment-row">
+                <span class="payment-label">Amount</span>
+                <span class="payment-value" id="amount">Loading...</span>
+            </div>
+            <div class="payment-row">
+                <span class="payment-label">Token</span>
+                <span class="payment-value">USDT</span>
+            </div>
+            <div class="payment-row">
+                <span class="payment-label">Network</span>
+                <span class="payment-value" id="network">TON</span>
+            </div>
+        </div>
+
+        <button class="button" id="connect-btn" onclick="connectWallet()">
+            Connect TON Wallet
+        </button>
+
+        <p class="status" id="status"></p>
+    </div>
+
+    <script>
+        // Initialize from window.t402 config
+        document.addEventListener('DOMContentLoaded', function() {
+            if (window.t402) {
+                const config = window.t402;
+
+                // Display amount
+                if (config.amount) {
+                    document.getElementById('amount').textContent = '$' + config.amount.toFixed(2) + ' USDT';
+                }
+
+                // Display network
+                if (config.paymentRequirements && config.paymentRequirements[0]) {
+                    const network = config.paymentRequirements[0].network;
+                    document.getElementById('network').textContent =
+                        network === 'ton:testnet' ? 'TON Testnet' : 'TON Mainnet';
+                }
+
+                // Display error if any
+                if (config.error) {
+                    const errorContainer = document.getElementById('error-container');
+                    errorContainer.innerHTML = '<div class="error">' + config.error + '</div>';
+                }
+            }
+        });
+
+        async function connectWallet() {
+            const btn = document.getElementById('connect-btn');
+            const status = document.getElementById('status');
+
+            btn.disabled = true;
+            btn.textContent = 'Connecting...';
+            status.textContent = '';
+
+            try {
+                // Check for TON wallet providers
+                if (typeof window.tonkeeper !== 'undefined') {
+                    status.textContent = 'Tonkeeper detected. Please approve the connection.';
+                    // Tonkeeper integration would go here
+                } else if (typeof window.ton !== 'undefined') {
+                    status.textContent = 'TON wallet detected. Please approve the connection.';
+                    // Generic TON wallet integration would go here
+                } else {
+                    status.textContent = 'No TON wallet detected. Please install Tonkeeper or another TON wallet.';
+                    btn.textContent = 'Install Wallet';
+                    btn.onclick = function() {
+                        window.open('https://tonkeeper.com/', '_blank');
+                    };
+                    btn.disabled = false;
+                    return;
+                }
+
+                // In a full implementation, this would:
+                // 1. Connect to the wallet
+                // 2. Build the Jetton transfer message
+                // 3. Sign the message
+                // 4. Create the payment payload
+                // 5. Retry the original request with the payment header
+
+            } catch (error) {
+                status.textContent = 'Error: ' + error.message;
+                btn.disabled = false;
+                btn.textContent = 'Connect TON Wallet';
+            }
+        }
+    </script>
+</body>
+</html>"""

t402/types.py

@@ -164,6 +164,46 @@ class EIP3009Authorization(BaseModel):
         return v
 
 
+class TonAuthorization(BaseModel):
+    """TON Jetton transfer authorization metadata."""
+
+    from_: str = Field(alias="from")
+    to: str
+    jetton_master: str = Field(alias="jettonMaster")
+    jetton_amount: str = Field(alias="jettonAmount")
+    ton_amount: str = Field(alias="tonAmount")
+    valid_until: int = Field(alias="validUntil")
+    seqno: int
+    query_id: str = Field(alias="queryId")
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    @field_validator("jetton_amount", "ton_amount")
+    def validate_amount(cls, v):
+        try:
+            int(v)
+        except ValueError:
+            raise ValueError("amount must be an integer encoded as a string")
+        return v
+
+
+class TonPaymentPayload(BaseModel):
+    """TON payment payload containing signed BOC and authorization."""
+
+    signed_boc: str = Field(alias="signedBoc")
+    authorization: TonAuthorization
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+
 class VerifyResponse(BaseModel):
     is_valid: bool = Field(alias="isValid")
     invalid_reason: Optional[str] = Field(None, alias="invalidReason")
@@ -191,7 +231,7 @@ class SettleResponse(BaseModel):
 
 
 # Union of payloads for each scheme
-SchemePayloads = ExactPaymentPayload
+SchemePayloads = Union[ExactPaymentPayload, TonPaymentPayload]
 
 
 class PaymentPayload(BaseModel):

{t402-1.0.0.dist-info → t402-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t402
-Version: 1.0.0
+Version: 1.1.0
 Summary: t402: An internet native payments protocol
 Author-email: T402 Team <dev@t402.io>
 License: Apache-2.0
@@ -25,6 +25,9 @@ Python package for the t402 payments protocol.
 
 ```bash
 pip install t402
+
+# or with uv
+uv add t402
 ```
 
 ## Overview

{t402-1.0.0.dist-info → t402-1.1.0.dist-info}/RECORD

@@ -1,24 +1,26 @@
-t402/__init__.py,sha256=03t8aR8QJjUbmLDgBWyjMRnxwiOtQsDE0i0uV2v3zw0,50
+t402/__init__.py,sha256=UCMjld6jAiYAeUqwxDa-SQFaE7w_AICzBTjpEzZuFBY,2250
 t402/chains.py,sha256=Hyn3bfubNpiWE1fqkyJulkonzMu3lncSt-_RCgagdro,2832
-t402/common.py,sha256=rSKXLzDBck_fYhH67VHd9DYoNYH9Ftw-VFRmNSXwQy8,3569
+t402/common.py,sha256=7wy6GL3XRv07KDqVxqpfMTVtMsSaz27anlQJzhqHCNs,4775
 t402/encoding.py,sha256=n-D5CevbJI7y0O_9OASOinB1vigYOOSU9RsWWSixMTk,633
 t402/evm_paywall_template.py,sha256=VJp3bntjRmz5ocWFCtzeB9842ds1Kd8as8rP48GhaDI,1928580
 t402/exact.py,sha256=ZC2CqwBYKv5WzhTpNWtcUPeAItDvatyrMNV47nYumE8,4448
 t402/facilitator.py,sha256=yfrWC5cdvaO1ZRQ5Y-2PMfTddsdahO-3MoKlvo3Xkbg,4792
-t402/networks.py,sha256=W8b4Q8fPdSDNhrnmIZDL5fVYYMZM69eM0_YrDIEnoNI,241
+t402/networks.py,sha256=Qq0dbPcTOrM9kkxm-ARbQGF7j21nWNytkxdyjb8iZF8,1491
 t402/path.py,sha256=G3oxm12FS1OsxXK_BPopS4bVCFrei5MOMnQAvDbgZsY,1311
-t402/paywall.py,sha256=CtEQz6hlwQLGFJt0iztpJDuIQ6jqveId-1ZWuMqIpZ8,3989
+t402/paywall.py,sha256=lSpGlDBC4slPU5rw7aDq5iBrBJXxLHRe3lgddFMKZ-Q,4119
 t402/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 t402/svm_paywall_template.py,sha256=pmueO0Qgcwl-uyci8lVI1eiery2vggHGl_b1tnxcB_E,827953
-t402/types.py,sha256=0sDiro29HcBjDBX9B1LYlM1sJV9PfHoUvmUuderwQm4,7027
+t402/ton.py,sha256=ggh_6nvZ55c-iYe6bNVejPJIWoFRSf85-DQmsvu-auI,11919
+t402/ton_paywall_template.py,sha256=kRddMyZk51dDd1b4-r_MlSGCc-DLRHskIxA-LN9l9vw,7343
+t402/types.py,sha256=EjvOHPUCtTKwwd57sQMmBSzcSegGOg81xS7u4AsWSrw,8153
 t402/clients/__init__.py,sha256=AuVY9soEliECRQJhcSor4CeB8Z09aSptRSo79mHPNdQ,433
 t402/clients/base.py,sha256=Ha6ivbmE62LoRFMfSMzDv3dwA9V3Qr5TD5w5zft5EW0,6448
 t402/clients/httpx.py,sha256=v7q6ZJPCz_SIqRYbTDPbbMsCNnt1oax5uKvCDUsvaX0,4650
 t402/clients/requests.py,sha256=T4nrrXxQQ02kE7mpcDS0co4OqtrxUg7jZPVztk-mgXc,4934
 t402/fastapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-t402/fastapi/middleware.py,sha256=wzLOx-c3TgE5X5oW8IZ4AF7v4XdIDPyKEtsx_D4nutE,8598
+t402/fastapi/middleware.py,sha256=Lxt7hOGEMg9wkAnakbb3wtNSv9r6KTk6_HVG1d4buIs,8638
 t402/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-t402/flask/middleware.py,sha256=eRzbFIjjjFpfIv6vjqYAeUtLO8O7qRx86XOEt7lEkPk,14070
-t402-1.0.0.dist-info/METADATA,sha256=2DuGnNicK35AX6s7KjX37BCkLDAJibx0loKpm-0UekY,6469
-t402-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-t402-1.0.0.dist-info/RECORD,,
+t402/flask/middleware.py,sha256=7xh7p7SceJHDgZK5s-hVT8lbdsIaO0CaSpPtqnKpp-4,14110
+t402-1.1.0.dist-info/METADATA,sha256=mW403K3Fv8uyz2GoJOgI6ySpoHD5nLRHI5AVNXSbsQY,6495
+t402-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+t402-1.1.0.dist-info/RECORD,,