t402 1.0.0__tar.gz

t402-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+.env
+node_modules/
+dist/
+.turbo/
+.next/
+proxy
+.env
+__pycache__/
+**/.DS_Store
+e2e/facilitators/external-proxies/*
+!e2e/facilitators/external-proxies/README.md

t402-1.0.0/.python-version

@@ -0,0 +1 @@
+3.10

t402-1.0.0/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: t402
+Version: 1.0.0
+Summary: t402: An internet native payments protocol
+Author-email: T402 Team <dev@t402.io>
+License: Apache-2.0
+Keywords: crypto,payments,sdk,t402,tether,usdt,web3
+Requires-Python: >=3.10
+Requires-Dist: eth-account>=0.13.7
+Requires-Dist: eth-typing>=4.0.0
+Requires-Dist: eth-utils>=3.0.0
+Requires-Dist: fastapi[standard]>=0.115.12
+Requires-Dist: flask>=3.0.0
+Requires-Dist: pydantic-settings>=2.2.1
+Requires-Dist: pydantic>=2.10.3
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: web3>=6.0.0
+Description-Content-Type: text/markdown
+
+# t402 Python
+
+Python package for the t402 payments protocol.
+
+## Installation
+
+```bash
+pip install t402
+```
+
+## Overview
+
+The t402 package provides the core building blocks for implementing the t402 Payment Protocol in Python. It's designed to be used by:
+
+- FastAPI middleware for accepting payments
+- Flask middleware for accepting payments
+- httpx client for paying resources
+- requests client for paying resources
+
+## FastAPI Integration
+
+The simplest way to add t402 payment protection to your FastAPI application:
+
+```py
+from fastapi import FastAPI
+from t402.fastapi.middleware import require_payment
+
+app = FastAPI()
+app.middleware("http")(
+    require_payment(price="0.01", pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C")
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+```
+
+To protect specific routes:
+
+```py
+app.middleware("http")(
+    require_payment(price="0.01",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C"),
+    path="/foo"  # <-- this can also be a list ex: ["/foo", "/bar"]
+)
+```
+
+## Flask Integration
+
+The simplest way to add t402 payment protection to your Flask application:
+
+```py
+from flask import Flask
+from t402.flask.middleware import PaymentMiddleware
+
+app = Flask(__name__)
+
+# Initialize payment middleware
+payment_middleware = PaymentMiddleware(app)
+
+# Add payment protection for all routes
+payment_middleware.add(
+    price="$0.01",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+)
+
+@app.route("/")
+def root():
+    return {"message": "Hello World"}
+```
+
+To protect specific routes:
+
+```py
+# Protect specific endpoint
+payment_middleware.add(
+    path="/foo",
+    price="$0.001",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+)
+```
+
+## Client Integration
+
+### Simple Usage
+
+#### Httpx Client
+```py
+from eth_account import Account
+from t402.clients.httpx import t402HttpxClient
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create client and make request
+async with t402HttpxClient(account=account, base_url="https://api.example.com") as client:
+    response = await client.get("/protected-endpoint")
+    print(await response.aread())
+```
+
+#### Requests Session Client
+```py
+from eth_account import Account
+from t402.clients.requests import t402_requests
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and make request
+session = t402_requests(account)
+response = session.get("https://api.example.com/protected-endpoint")
+print(response.content)
+```
+
+### Advanced Usage
+
+#### Httpx Extensible Example
+```py
+import httpx
+from eth_account import Account
+from t402.clients.httpx import t402_payment_hooks
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create httpx client with t402 payment hooks
+async with httpx.AsyncClient(base_url="https://api.example.com") as client:
+    # Add payment hooks directly to client
+    client.event_hooks = t402_payment_hooks(account)
+    
+    # Make request - payment handling is automatic
+    response = await client.get("/protected-endpoint")
+    print(await response.aread())
+```
+
+#### Requests Session Extensible Example
+```py
+import requests
+from eth_account import Account
+from t402.clients.requests import t402_http_adapter
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and mount the t402 adapter
+session = requests.Session()
+adapter = t402_http_adapter(account)
+
+# Mount the adapter for both HTTP and HTTPS
+session.mount("http://", adapter)
+session.mount("https://", adapter)
+
+# Make request - payment handling is automatic
+response = session.get("https://api.example.com/protected-endpoint")
+print(response.content)
+```
+
+## Manual Server Integration
+
+If you're not using the FastAPI middleware, you can implement the t402 protocol manually. Here's what you'll need to handle:
+
+1. Return 402 error responses with the appropriate response body
+2. Use the facilitator to validate payments
+3. Use the facilitator to settle payments
+4. Return the appropriate response header to the caller
+
+Here's an example of manual integration:
+
+```py
+from typing import Annotated
+from fastapi import FastAPI, Request
+from t402.types import PaymentRequiredResponse, PaymentRequirements
+from t402.encoding import safe_base64_decode
+
+payment_requirements = PaymentRequirements(...)
+facilitator = FacilitatorClient(facilitator_url)
+
+@app.get("/foo")
+async def foo(req: request: Request):
+    payment_required = PaymentRequiredResponse(
+        t402_version: 1,
+        accepts=[payment_requirements],
+        error="",
+    )
+    payment_header = req.headers.get("X-PAYMENT", "")
+
+    if payment_header == "":
+        payment_required.error = "X-PAYMENT header not set"
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+    
+    payment = PaymentPayload(**json.loads(safe_base64_decode(payment_header)))
+
+    verify_response = await facilitator.verify(payment, payment_requirements)
+    if not verify_response.is_valid:
+        payment_required.error = "Invalid payment"
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+
+    settle_response = await facilitator.settle(payment, payment_requirements)
+    if settle_response.success:
+        response.headers["X-PAYMENT-RESPONSE"] = base64.b64encode(
+            settle_response.model_dump_json().encode("utf-8")
+        ).decode("utf-8")
+    else:
+        payment_required.error = "Settle failed: " + settle_response.error
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+```
+
+For more examples and advanced usage patterns, check out our [examples directory](https://github.com/awesome-doge/t402/tree/main/examples/python).

t402-1.0.0/README.md

@@ -0,0 +1,217 @@
+# t402 Python
+
+Python package for the t402 payments protocol.
+
+## Installation
+
+```bash
+pip install t402
+```
+
+## Overview
+
+The t402 package provides the core building blocks for implementing the t402 Payment Protocol in Python. It's designed to be used by:
+
+- FastAPI middleware for accepting payments
+- Flask middleware for accepting payments
+- httpx client for paying resources
+- requests client for paying resources
+
+## FastAPI Integration
+
+The simplest way to add t402 payment protection to your FastAPI application:
+
+```py
+from fastapi import FastAPI
+from t402.fastapi.middleware import require_payment
+
+app = FastAPI()
+app.middleware("http")(
+    require_payment(price="0.01", pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C")
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+```
+
+To protect specific routes:
+
+```py
+app.middleware("http")(
+    require_payment(price="0.01",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C"),
+    path="/foo"  # <-- this can also be a list ex: ["/foo", "/bar"]
+)
+```
+
+## Flask Integration
+
+The simplest way to add t402 payment protection to your Flask application:
+
+```py
+from flask import Flask
+from t402.flask.middleware import PaymentMiddleware
+
+app = Flask(__name__)
+
+# Initialize payment middleware
+payment_middleware = PaymentMiddleware(app)
+
+# Add payment protection for all routes
+payment_middleware.add(
+    price="$0.01",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+)
+
+@app.route("/")
+def root():
+    return {"message": "Hello World"}
+```
+
+To protect specific routes:
+
+```py
+# Protect specific endpoint
+payment_middleware.add(
+    path="/foo",
+    price="$0.001",
+    pay_to_address="0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
+)
+```
+
+## Client Integration
+
+### Simple Usage
+
+#### Httpx Client
+```py
+from eth_account import Account
+from t402.clients.httpx import t402HttpxClient
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create client and make request
+async with t402HttpxClient(account=account, base_url="https://api.example.com") as client:
+    response = await client.get("/protected-endpoint")
+    print(await response.aread())
+```
+
+#### Requests Session Client
+```py
+from eth_account import Account
+from t402.clients.requests import t402_requests
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and make request
+session = t402_requests(account)
+response = session.get("https://api.example.com/protected-endpoint")
+print(response.content)
+```
+
+### Advanced Usage
+
+#### Httpx Extensible Example
+```py
+import httpx
+from eth_account import Account
+from t402.clients.httpx import t402_payment_hooks
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create httpx client with t402 payment hooks
+async with httpx.AsyncClient(base_url="https://api.example.com") as client:
+    # Add payment hooks directly to client
+    client.event_hooks = t402_payment_hooks(account)
+    
+    # Make request - payment handling is automatic
+    response = await client.get("/protected-endpoint")
+    print(await response.aread())
+```
+
+#### Requests Session Extensible Example
+```py
+import requests
+from eth_account import Account
+from t402.clients.requests import t402_http_adapter
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and mount the t402 adapter
+session = requests.Session()
+adapter = t402_http_adapter(account)
+
+# Mount the adapter for both HTTP and HTTPS
+session.mount("http://", adapter)
+session.mount("https://", adapter)
+
+# Make request - payment handling is automatic
+response = session.get("https://api.example.com/protected-endpoint")
+print(response.content)
+```
+
+## Manual Server Integration
+
+If you're not using the FastAPI middleware, you can implement the t402 protocol manually. Here's what you'll need to handle:
+
+1. Return 402 error responses with the appropriate response body
+2. Use the facilitator to validate payments
+3. Use the facilitator to settle payments
+4. Return the appropriate response header to the caller
+
+Here's an example of manual integration:
+
+```py
+from typing import Annotated
+from fastapi import FastAPI, Request
+from t402.types import PaymentRequiredResponse, PaymentRequirements
+from t402.encoding import safe_base64_decode
+
+payment_requirements = PaymentRequirements(...)
+facilitator = FacilitatorClient(facilitator_url)
+
+@app.get("/foo")
+async def foo(req: request: Request):
+    payment_required = PaymentRequiredResponse(
+        t402_version: 1,
+        accepts=[payment_requirements],
+        error="",
+    )
+    payment_header = req.headers.get("X-PAYMENT", "")
+
+    if payment_header == "":
+        payment_required.error = "X-PAYMENT header not set"
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+    
+    payment = PaymentPayload(**json.loads(safe_base64_decode(payment_header)))
+
+    verify_response = await facilitator.verify(payment, payment_requirements)
+    if not verify_response.is_valid:
+        payment_required.error = "Invalid payment"
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+
+    settle_response = await facilitator.settle(payment, payment_requirements)
+    if settle_response.success:
+        response.headers["X-PAYMENT-RESPONSE"] = base64.b64encode(
+            settle_response.model_dump_json().encode("utf-8")
+        ).decode("utf-8")
+    else:
+        payment_required.error = "Settle failed: " + settle_response.error
+        return JSONResponse(
+            content=payment_required.model_dump(by_alias=True),
+            status_code=402,
+        )
+```
+
+For more examples and advanced usage patterns, check out our [examples directory](https://github.com/awesome-doge/t402/tree/main/examples/python).

t402-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "t402"
+version = "1.0.0"
+description = "t402: An internet native payments protocol"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "T402 Team", email = "dev@t402.io" }
+]
+requires-python = ">=3.10"
+keywords = ["t402", "sdk", "crypto", "usdt", "payments", "web3", "tether"]
+dependencies = [
+    "eth-account>=0.13.7",
+    "eth-typing>=4.0.0",
+    "eth-utils>=3.0.0",
+    "fastapi[standard]>=0.115.12",
+    "flask>=3.0.0",
+    "pydantic>=2.10.3",
+    "pydantic-settings>=2.2.1",
+    "python-dotenv>=1.0.1",
+    "web3>=6.0.0",
+]
+
+[project.scripts]
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-asyncio>=1.0.0",
+    "ruff>=0.11.9",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/t402"]
+
+[tool.hatch.metadata]
+allow-direct-references = true

t402-1.0.0/src/t402/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from t402!"

t402-1.0.0/src/t402/chains.py

@@ -0,0 +1,92 @@
+NETWORK_TO_ID = {
+    "base-sepolia": "84532",
+    "base": "8453",
+    "avalanche-fuji": "43113",
+    "avalanche": "43114",
+}
+
+
+def get_chain_id(network: str) -> str:
+    """Get the chain ID for a given network
+    Supports string encoded chain IDs and human readable networks
+    """
+    try:
+        int(network)
+        return network
+    except ValueError:
+        pass
+    if network not in NETWORK_TO_ID:
+        raise ValueError(f"Unsupported network: {network}")
+    return NETWORK_TO_ID[network]
+
+
+KNOWN_TOKENS = {
+    "84532": [
+        {
+            "human_name": "usdc",
+            "address": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+            "name": "USDC",
+            "decimals": 6,
+            "version": "2",
+        }
+    ],
+    "8453": [
+        {
+            "human_name": "usdc",
+            "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+            "name": "USD Coin",  # needs to be exactly what is returned by name() on contract
+            "decimals": 6,
+            "version": "2",
+        }
+    ],
+    "43113": [
+        {
+            "human_name": "usdc",
+            "address": "0x5425890298aed601595a70AB815c96711a31Bc65",
+            "name": "USD Coin",
+            "decimals": 6,
+            "version": "2",
+        }
+    ],
+    "43114": [
+        {
+            "human_name": "usdc",
+            "address": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+            "name": "USDC",
+            "decimals": 6,
+            "version": "2",
+        }
+    ],
+}
+
+
+def get_token_name(chain_id: str, address: str) -> str:
+    """Get the token name for a given chain and address"""
+    for token in KNOWN_TOKENS[chain_id]:
+        if token["address"] == address:
+            return token["name"]
+    raise ValueError(f"Token not found for chain {chain_id} and address {address}")
+
+
+def get_token_version(chain_id: str, address: str) -> str:
+    """Get the token version for a given chain and address"""
+    for token in KNOWN_TOKENS[chain_id]:
+        if token["address"] == address:
+            return token["version"]
+    raise ValueError(f"Token not found for chain {chain_id} and address {address}")
+
+
+def get_token_decimals(chain_id: str, address: str) -> int:
+    """Get the token decimals for a given chain and address"""
+    for token in KNOWN_TOKENS[chain_id]:
+        if token["address"] == address:
+            return token["decimals"]
+    raise ValueError(f"Token not found for chain {chain_id} and address {address}")
+
+
+def get_default_token_address(chain_id: str, token_type: str = "usdc") -> str:
+    """Get the default token address for a given chain and token type"""
+    for token in KNOWN_TOKENS[chain_id]:
+        if token["human_name"] == token_type:
+            return token["address"]
+    raise ValueError(f"Token type '{token_type}' not found for chain {chain_id}")

t402-1.0.0/src/t402/clients/__init__.py

@@ -0,0 +1,20 @@
+from t402.clients.base import t402Client, decode_x_payment_response
+from t402.clients.httpx import (
+    t402_payment_hooks,
+    t402HttpxClient,
+)
+from t402.clients.requests import (
+    t402HTTPAdapter,
+    t402_http_adapter,
+    t402_requests,
+)
+
+__all__ = [
+    "t402Client",
+    "decode_x_payment_response",
+    "t402_payment_hooks",
+    "t402HttpxClient",
+    "t402HTTPAdapter",
+    "t402_http_adapter",
+    "t402_requests",
+]