t402 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

t402/__init__.py

@@ -1,3 +1,6 @@
+# Package version
+__version__ = "1.5.3"
+
 # Re-export commonly used items for convenience
 from t402.common import (
     parse_money,
@@ -9,6 +12,7 @@ from t402.networks import (
     is_ton_network,
     is_tron_network,
     is_evm_network,
+    is_svm_network,
     get_network_type,
 )
 from t402.types import (
@@ -59,6 +63,24 @@ from t402.tron import (
     format_amount as format_tron_amount,
     is_testnet as is_tron_testnet,
 )
+from t402.svm import (
+    SOLANA_MAINNET,
+    SOLANA_DEVNET,
+    SOLANA_TESTNET,
+    USDC_MAINNET_ADDRESS as SVM_USDC_MAINNET_ADDRESS,
+    USDC_DEVNET_ADDRESS as SVM_USDC_DEVNET_ADDRESS,
+    validate_svm_address,
+    get_usdc_address as get_svm_usdc_address,
+    get_network_config as get_svm_network_config,
+    get_default_asset as get_svm_default_asset,
+    prepare_svm_payment_header,
+    parse_amount as parse_svm_amount,
+    format_amount as format_svm_amount,
+    is_testnet as is_svm_testnet,
+    validate_transaction as validate_svm_transaction,
+    normalize_network as normalize_svm_network,
+    get_rpc_url as get_svm_rpc_url,
+)
 from t402.paywall import (
     get_paywall_html,
     get_paywall_template,
@@ -117,12 +139,43 @@ from t402.bridge import (
     CrossChainPaymentParams,
     CrossChainPaymentResult,
 )
+from t402.wdk import (
+    # Signer
+    WDKSigner,
+    generate_seed_phrase,
+    validate_seed_phrase,
+    # Types
+    WDKConfig,
+    ChainConfig as WDKChainConfig,
+    NetworkType,
+    TokenInfo as WDKTokenInfo,
+    TokenBalance,
+    ChainBalance,
+    AggregatedBalance,
+    PaymentParams,
+    PaymentResult,
+    SignedTypedData,
+    # Chain utilities
+    DEFAULT_CHAINS as WDK_DEFAULT_CHAINS,
+    USDT0_ADDRESSES as WDK_USDT0_ADDRESSES,
+    get_chain_config as get_wdk_chain_config,
+    get_usdt0_chains as get_wdk_usdt0_chains,
+    # Errors
+    WDKError,
+    WDKInitializationError,
+    SignerError,
+    SigningError,
+    BalanceError as WDKBalanceError,
+    WDKErrorCode,
+)
 
 def hello() -> str:
     return "Hello from t402!"
 
 
 __all__ = [
+    # Version
+    "__version__",
     # Core
     "hello",
     "t402_VERSION",
@@ -134,6 +187,7 @@ __all__ = [
     "is_ton_network",
     "is_tron_network",
     "is_evm_network",
+    "is_svm_network",
     "get_network_type",
     # Types
     "PaymentRequirements",
@@ -181,6 +235,23 @@ __all__ = [
     "parse_tron_amount",
     "format_tron_amount",
     "is_tron_testnet",
+    # SVM (Solana) utilities
+    "SOLANA_MAINNET",
+    "SOLANA_DEVNET",
+    "SOLANA_TESTNET",
+    "SVM_USDC_MAINNET_ADDRESS",
+    "SVM_USDC_DEVNET_ADDRESS",
+    "validate_svm_address",
+    "get_svm_usdc_address",
+    "get_svm_network_config",
+    "get_svm_default_asset",
+    "prepare_svm_payment_header",
+    "parse_svm_amount",
+    "format_svm_amount",
+    "is_svm_testnet",
+    "validate_svm_transaction",
+    "normalize_svm_network",
+    "get_svm_rpc_url",
     # Paywall
     "get_paywall_html",
     "get_paywall_template",
@@ -226,4 +297,31 @@ __all__ = [
     "LayerZeroMessageStatus",
     "CrossChainPaymentParams",
     "CrossChainPaymentResult",
+    # WDK - Signer
+    "WDKSigner",
+    "generate_seed_phrase",
+    "validate_seed_phrase",
+    # WDK - Types
+    "WDKConfig",
+    "WDKChainConfig",
+    "NetworkType",
+    "WDKTokenInfo",
+    "TokenBalance",
+    "ChainBalance",
+    "AggregatedBalance",
+    "PaymentParams",
+    "PaymentResult",
+    "SignedTypedData",
+    # WDK - Chain utilities
+    "WDK_DEFAULT_CHAINS",
+    "WDK_USDT0_ADDRESSES",
+    "get_wdk_chain_config",
+    "get_wdk_usdt0_chains",
+    # WDK - Errors
+    "WDKError",
+    "WDKInitializationError",
+    "SignerError",
+    "SigningError",
+    "WDKBalanceError",
+    "WDKErrorCode",
 ]

t402/bridge/client.py

@@ -1,6 +1,5 @@
 """USDT0 Bridge Client for LayerZero OFT transfers."""
 
-from typing import Optional
 
 from .constants import (
     DEFAULT_EXTRA_OPTIONS,

t402/bridge/types.py

@@ -3,7 +3,6 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Callable, Optional, Protocol
-from decimal import Decimal
 
 
 class BridgeStatus(str, Enum):

t402/cli.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+T402 CLI - Command-line interface for the T402 payment protocol.
+
+Usage:
+    t402 verify <payment-payload> [--facilitator URL]
+    t402 settle <payment-payload> [--facilitator URL]
+    t402 supported [--facilitator URL]
+    t402 encode <json-file>
+    t402 decode <base64-string>
+    t402 version
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .encoding import decode_payment, encode_payment
+from .facilitator import FacilitatorClient, FacilitatorConfig
+from .types import PaymentPayload
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the argument parser for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog="t402",
+        description="T402 Payment Protocol CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Verify a payment
+    t402 verify <base64-encoded-payload>
+
+    # Settle a payment
+    t402 settle <base64-encoded-payload>
+
+    # List supported networks and schemes
+    t402 supported
+
+    # Encode a payment payload from JSON
+    t402 encode payment.json
+
+    # Decode a base64 payment payload
+    t402 decode <base64-string>
+        """,
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"t402 {__version__}"
+    )
+    parser.add_argument(
+        "-f",
+        "--facilitator",
+        default="https://facilitator.t402.io",
+        help="Facilitator URL (default: https://facilitator.t402.io)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        choices=["json", "text"],
+        default="text",
+        help="Output format (default: text)",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # verify command
+    verify_parser = subparsers.add_parser("verify", help="Verify a payment payload")
+    verify_parser.add_argument("payload", help="Base64-encoded payment payload")
+
+    # settle command
+    settle_parser = subparsers.add_parser("settle", help="Settle a payment")
+    settle_parser.add_argument("payload", help="Base64-encoded payment payload")
+
+    # supported command
+    subparsers.add_parser("supported", help="List supported networks and schemes")
+
+    # encode command
+    encode_parser = subparsers.add_parser(
+        "encode", help="Encode a payment payload from JSON"
+    )
+    encode_parser.add_argument(
+        "file", type=Path, help="JSON file containing payment payload"
+    )
+
+    # decode command
+    decode_parser = subparsers.add_parser(
+        "decode", help="Decode a base64-encoded payment payload"
+    )
+    decode_parser.add_argument("payload", help="Base64-encoded payment payload")
+
+    # info command
+    info_parser = subparsers.add_parser("info", help="Show information about a network")
+    info_parser.add_argument("network", help="Network identifier (e.g., eip155:1)")
+
+    return parser
+
+
+def output_result(result: Any, output_format: str) -> None:
+    """Output result in the specified format."""
+    if output_format == "json":
+        if hasattr(result, "model_dump"):
+            print(json.dumps(result.model_dump(), indent=2))
+        elif isinstance(result, dict):
+            print(json.dumps(result, indent=2))
+        else:
+            print(json.dumps({"result": str(result)}, indent=2))
+    else:
+        if isinstance(result, dict):
+            for key, value in result.items():
+                print(f"{key}: {value}")
+        else:
+            print(result)
+
+
+async def cmd_verify(args: argparse.Namespace) -> int:
+    """Verify a payment payload."""
+    try:
+        config = FacilitatorConfig(base_url=args.facilitator)
+        client = FacilitatorClient(config)
+
+        # Decode the payload first
+        payload_dict = decode_payment(args.payload)
+        payload = PaymentPayload.model_validate(payload_dict)
+
+        result = await client.verify(payload)
+
+        if args.output == "json":
+            print(json.dumps({"valid": result.valid, "error": result.error}, indent=2))
+        else:
+            if result.valid:
+                print("Payment is VALID")
+            else:
+                print(f"Payment is INVALID: {result.error}")
+
+        return 0 if result.valid else 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+async def cmd_settle(args: argparse.Namespace) -> int:
+    """Settle a payment."""
+    try:
+        config = FacilitatorConfig(base_url=args.facilitator)
+        client = FacilitatorClient(config)
+
+        # Decode the payload first
+        payload_dict = decode_payment(args.payload)
+        payload = PaymentPayload.model_validate(payload_dict)
+
+        result = await client.settle(payload)
+
+        if args.output == "json":
+            print(
+                json.dumps(
+                    {
+                        "success": result.success,
+                        "transaction_hash": result.transaction_hash,
+                        "error": result.error,
+                    },
+                    indent=2,
+                )
+            )
+        else:
+            if result.success:
+                print("Payment settled successfully!")
+                print(f"Transaction hash: {result.transaction_hash}")
+            else:
+                print(f"Settlement failed: {result.error}")
+
+        return 0 if result.success else 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+async def cmd_supported(args: argparse.Namespace) -> int:
+    """List supported networks and schemes."""
+    try:
+        config = FacilitatorConfig(base_url=args.facilitator)
+        client = FacilitatorClient(config)
+
+        result = await client.list_supported()
+
+        if args.output == "json":
+            print(
+                json.dumps(
+                    {
+                        "kinds": [k.model_dump() for k in result.kinds],
+                        "signers": result.signers,
+                        "extensions": result.extensions,
+                    },
+                    indent=2,
+                )
+            )
+        else:
+            print("Supported Payment Kinds:")
+            print("-" * 50)
+            for kind in result.kinds:
+                print(f"  Scheme: {kind.scheme}")
+                print(f"  Network: {kind.network}")
+                if hasattr(kind, "token") and kind.token:
+                    print(f"  Token: {kind.token}")
+                print()
+
+            if result.signers:
+                print("Supported Signers:")
+                for signer in result.signers:
+                    print(f"  - {signer}")
+                print()
+
+            if result.extensions:
+                print("Supported Extensions:")
+                for ext in result.extensions:
+                    print(f"  - {ext}")
+
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def cmd_encode(args: argparse.Namespace) -> int:
+    """Encode a payment payload from JSON."""
+    try:
+        with open(args.file) as f:
+            payload_dict = json.load(f)
+
+        encoded = encode_payment(payload_dict)
+        print(encoded)
+        return 0
+    except FileNotFoundError:
+        print(f"Error: File not found: {args.file}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def cmd_decode(args: argparse.Namespace) -> int:
+    """Decode a base64-encoded payment payload."""
+    try:
+        decoded = decode_payment(args.payload)
+
+        if args.output == "json":
+            print(json.dumps(decoded, indent=2))
+        else:
+            print(json.dumps(decoded, indent=2))
+
+        return 0
+    except Exception as e:
+        print(f"Error: Failed to decode payload: {e}", file=sys.stderr)
+        return 1
+
+
+def cmd_info(args: argparse.Namespace) -> int:
+    """Show information about a network."""
+    from .networks import is_evm_network, is_ton_network, is_tron_network
+
+    network = args.network
+
+    info = {
+        "network": network,
+        "is_evm": is_evm_network(network),
+        "is_ton": is_ton_network(network),
+        "is_tron": is_tron_network(network),
+    }
+
+    # Add chain-specific info
+    if is_evm_network(network):
+        from .chains import EVM_CHAINS
+
+        chain_id = network.split(":")[1] if ":" in network else network
+        if chain_id in EVM_CHAINS:
+            chain = EVM_CHAINS[chain_id]
+            info["chain_name"] = chain.get("name", "Unknown")
+            info["currency"] = chain.get("currency", "Unknown")
+
+    if args.output == "json":
+        print(json.dumps(info, indent=2))
+    else:
+        for key, value in info.items():
+            print(f"{key}: {value}")
+
+    return 0
+
+
+def main() -> int:
+    """Main entry point for the CLI."""
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 0
+
+    # Route to the appropriate command handler
+    if args.command == "verify":
+        return asyncio.run(cmd_verify(args))
+    elif args.command == "settle":
+        return asyncio.run(cmd_settle(args))
+    elif args.command == "supported":
+        return asyncio.run(cmd_supported(args))
+    elif args.command == "encode":
+        return cmd_encode(args)
+    elif args.command == "decode":
+        return cmd_decode(args)
+    elif args.command == "info":
+        return cmd_info(args)
+    else:
+        parser.print_help()
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

t402/erc4337/accounts.py

@@ -6,7 +6,7 @@ including Safe smart account with 4337 module support.
 """
 
 from dataclasses import dataclass
-from typing import Optional, List, Tuple
+from typing import Optional, List
 from abc import ABC, abstractmethod
 from eth_account import Account
 from eth_account.messages import encode_defunct
@@ -95,8 +95,6 @@ class SafeSmartAccount(SmartAccountSigner):
             return self._cached_address
 
         # Calculate counterfactual address via CREATE2
-        init_code = self.get_init_code()
-
         factory_address = bytes.fromhex(SAFE_4337_ADDRESSES["proxy_factory"][2:])
         salt_hash = self._calculate_salt()
         proxy_init_code = self._get_proxy_creation_code()

t402/erc4337/paymasters.py

@@ -6,15 +6,13 @@ gas sponsorship, including Pimlico, Biconomy, and Stackup clients.
 """
 
 import httpx
-from dataclasses import dataclass
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any
 from abc import ABC, abstractmethod
 
 from .types import (
     UserOperation,
     PaymasterData,
     TokenQuote,
-    GasEstimate,
     ENTRYPOINT_V07_ADDRESS,
     PIMLICO_NETWORKS,
     DEFAULT_GAS_LIMITS,

t402/erc4337/types.py

@@ -7,8 +7,7 @@ bundler interactions, and paymaster integration.
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional, List, Union
-from eth_typing import HexStr, Address
+from typing import Optional, List
 
 # EntryPoint addresses (canonical deployments)
 ENTRYPOINT_V07_ADDRESS = "0x0000000071727De22E5E9d8BAf0edAc6f37da032"

t402/fastapi/middleware.py

@@ -108,7 +108,7 @@ def require_payment(
                 mime_type=mime_type,
                 pay_to=pay_to_address,
                 max_timeout_seconds=max_deadline_seconds,
-                # TODO: Rename output_schema to request_structure
+                # Contains both input and output schema (field name kept for backwards compatibility)
                 output_schema={
                     "input": {
                         "type": "http",

t402/flask/middleware.py

@@ -192,7 +192,7 @@ class PaymentMiddleware:
                         mime_type=config["mime_type"],
                         pay_to=config["pay_to_address"],
                         max_timeout_seconds=config["max_deadline_seconds"],
-                        # TODO: Rename output_schema to request_structure
+                        # Contains both input and output schema (field name kept for backwards compatibility)
                         output_schema={
                             "input": {
                                 "type": "http",

t402/mcp/__init__.py

@@ -0,0 +1,109 @@
+"""T402 MCP Server - Model Context Protocol server for AI agent integration.
+
+This module provides an MCP server that enables AI agents to interact with
+blockchain payments using the T402 protocol.
+
+Example:
+    ```python
+    from t402.mcp import T402McpServer, ServerConfig
+
+    config = ServerConfig(demo_mode=True)
+    server = T402McpServer(config)
+    await server.run()
+    ```
+
+Available Tools:
+    - t402/getBalance: Get token balances for a wallet on specific network
+    - t402/getAllBalances: Get balances across all supported networks
+    - t402/pay: Execute stablecoin payments (USDC, USDT, USDT0)
+    - t402/payGasless: ERC-4337 gasless payments
+    - t402/getBridgeFee: Get LayerZero bridge fee quotes
+    - t402/bridge: Bridge USDT0 between chains via LayerZero
+"""
+
+from .server import T402McpServer, run_server
+from .types import (
+    ServerConfig,
+    SupportedNetwork,
+    SupportedToken,
+    Tool,
+    ToolResult,
+    GetBalanceInput,
+    GetAllBalancesInput,
+    PayInput,
+    PayGaslessInput,
+    GetBridgeFeeInput,
+    BridgeInput,
+    BalanceInfo,
+    NetworkBalance,
+    PaymentResult,
+    BridgeFeeResult,
+    BridgeResultData,
+)
+from .constants import (
+    CHAIN_IDS,
+    NATIVE_SYMBOLS,
+    EXPLORER_URLS,
+    DEFAULT_RPC_URLS,
+    USDC_ADDRESSES,
+    USDT_ADDRESSES,
+    USDT0_ADDRESSES,
+    BRIDGEABLE_CHAINS,
+    GASLESS_NETWORKS,
+    ALL_NETWORKS,
+    is_valid_network,
+    is_bridgeable_chain,
+    is_gasless_network,
+    get_token_address,
+    get_explorer_tx_url,
+    get_rpc_url,
+    format_token_amount,
+    parse_token_amount,
+)
+from .tools import get_tool_definitions
+
+__all__ = [
+    # Server
+    "T402McpServer",
+    "run_server",
+    # Config and types
+    "ServerConfig",
+    "SupportedNetwork",
+    "SupportedToken",
+    "Tool",
+    "ToolResult",
+    # Input types
+    "GetBalanceInput",
+    "GetAllBalancesInput",
+    "PayInput",
+    "PayGaslessInput",
+    "GetBridgeFeeInput",
+    "BridgeInput",
+    # Result types
+    "BalanceInfo",
+    "NetworkBalance",
+    "PaymentResult",
+    "BridgeFeeResult",
+    "BridgeResultData",
+    # Constants
+    "CHAIN_IDS",
+    "NATIVE_SYMBOLS",
+    "EXPLORER_URLS",
+    "DEFAULT_RPC_URLS",
+    "USDC_ADDRESSES",
+    "USDT_ADDRESSES",
+    "USDT0_ADDRESSES",
+    "BRIDGEABLE_CHAINS",
+    "GASLESS_NETWORKS",
+    "ALL_NETWORKS",
+    # Functions
+    "is_valid_network",
+    "is_bridgeable_chain",
+    "is_gasless_network",
+    "get_token_address",
+    "get_explorer_tx_url",
+    "get_rpc_url",
+    "format_token_amount",
+    "parse_token_amount",
+    "get_tool_definitions",
+]