t402 1.4.0__py3-none-any.whl → 1.5.3__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,
@@ -117,12 +120,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",
@@ -226,4 +260,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/wdk/__init__.py

@@ -0,0 +1,140 @@
+"""
+T402 WDK Python Adapter
+
+Provides wallet functionality for T402 payments using Tether WDK-compatible
+seed phrase derivation.
+
+Example:
+    ```python
+    from t402.wdk import WDKSigner, generate_seed_phrase
+
+    # Generate a new seed phrase
+    seed = generate_seed_phrase()
+
+    # Create signer
+    signer = WDKSigner(
+        seed_phrase=seed,
+        chains={"arbitrum": "https://arb1.arbitrum.io/rpc"}
+    )
+    await signer.initialize()
+
+    # Get address
+    address = signer.get_address("evm")
+
+    # Get balances
+    balances = await signer.get_all_balances()
+    ```
+"""
+
+from .signer import (
+    WDKSigner,
+    generate_seed_phrase,
+    validate_seed_phrase,
+    format_token_amount,
+)
+from .types import (
+    # Core types
+    WDKConfig,
+    ChainConfig,
+    NetworkType,
+    # Token types
+    TokenInfo,
+    TokenBalance,
+    ChainBalance,
+    AggregatedBalance,
+    # Payment types
+    PaymentParams,
+    PaymentResult,
+    SignedTypedData,
+    TypedDataDomain,
+    # Bridge types
+    BridgeParams,
+    BridgeResult,
+)
+from .chains import (
+    # Chain configuration
+    DEFAULT_CHAINS,
+    CHAIN_TOKENS,
+    # Token addresses
+    USDT0_ADDRESSES,
+    USDC_ADDRESSES,
+    USDT_LEGACY_ADDRESSES,
+    # Utility functions
+    get_chain_config,
+    get_chain_id,
+    get_network_from_chain,
+    get_chain_from_network,
+    get_usdt0_chains,
+    get_chain_tokens,
+    get_preferred_token,
+    get_token_address,
+    is_testnet,
+)
+from .errors import (
+    # Error classes
+    WDKError,
+    WDKInitializationError,
+    SignerError,
+    SigningError,
+    ChainError,
+    BalanceError,
+    TransactionError,
+    BridgeError,
+    # Error codes
+    WDKErrorCode,
+    # Utilities
+    is_wdk_error,
+)
+
+
+__all__ = [
+    # Signer
+    "WDKSigner",
+    "generate_seed_phrase",
+    "validate_seed_phrase",
+    "format_token_amount",
+    # Core types
+    "WDKConfig",
+    "ChainConfig",
+    "NetworkType",
+    # Token types
+    "TokenInfo",
+    "TokenBalance",
+    "ChainBalance",
+    "AggregatedBalance",
+    # Payment types
+    "PaymentParams",
+    "PaymentResult",
+    "SignedTypedData",
+    "TypedDataDomain",
+    # Bridge types
+    "BridgeParams",
+    "BridgeResult",
+    # Chain configuration
+    "DEFAULT_CHAINS",
+    "CHAIN_TOKENS",
+    "USDT0_ADDRESSES",
+    "USDC_ADDRESSES",
+    "USDT_LEGACY_ADDRESSES",
+    # Chain utilities
+    "get_chain_config",
+    "get_chain_id",
+    "get_network_from_chain",
+    "get_chain_from_network",
+    "get_usdt0_chains",
+    "get_chain_tokens",
+    "get_preferred_token",
+    "get_token_address",
+    "is_testnet",
+    # Error classes
+    "WDKError",
+    "WDKInitializationError",
+    "SignerError",
+    "SigningError",
+    "ChainError",
+    "BalanceError",
+    "TransactionError",
+    "BridgeError",
+    "WDKErrorCode",
+    "is_wdk_error",
+]