og-test-x402 0.0.5__tar.gz

og_test_x402-0.0.5/.gitignore

@@ -0,0 +1,9 @@
+.env
+node_modules/
+dist/
+.turbo/
+.next/
+proxy
+.env
+__pycache__/
+**/.DS_Store

og_test_x402-0.0.5/.python-version

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

og_test_x402-0.0.5/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: og-test-x402
+Version: 0.0.5
+Summary: x402: An internet native payments protocol
+Author-email: erik <erik.reppel@coinbase.com>
+License: Apache-2.0
+Keywords: cdp,crypto,payments,sdk,web3,x402
+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
+
+# x402 Python
+
+Python package for the x402 payments protocol.
+
+## Installation
+
+```bash
+pip install x402
+```
+
+## Overview
+
+The x402 package provides the core building blocks for implementing the x402 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 x402 payment protection to your FastAPI application:
+
+```py
+from fastapi import FastAPI
+from x402.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 x402 payment protection to your Flask application:
+
+```py
+from flask import Flask
+from x402.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 x402.clients.httpx import x402HttpxClient
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create client and make request
+async with x402HttpxClient(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 x402.clients.requests import x402_requests
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and make request
+session = x402_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 x402.clients.httpx import x402_payment_hooks
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create httpx client with x402 payment hooks
+async with httpx.AsyncClient(base_url="https://api.example.com") as client:
+    # Add payment hooks directly to client
+    client.event_hooks = x402_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 x402.clients.requests import x402_http_adapter
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and mount the x402 adapter
+session = requests.Session()
+adapter = x402_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 x402 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 x402.types import PaymentRequiredResponse, PaymentRequirements
+from x402.encoding import safe_base64_decode
+
+payment_requirements = PaymentRequirements(...)
+facilitator = FacilitatorClient(facilitator_url)
+
+@app.get("/foo")
+async def foo(req: request: Request):
+    payment_required = PaymentRequiredResponse(
+        x402_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/coinbase/x402/tree/main/examples/python).

og_test_x402-0.0.5/README.md

@@ -0,0 +1,217 @@
+# x402 Python
+
+Python package for the x402 payments protocol.
+
+## Installation
+
+```bash
+pip install x402
+```
+
+## Overview
+
+The x402 package provides the core building blocks for implementing the x402 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 x402 payment protection to your FastAPI application:
+
+```py
+from fastapi import FastAPI
+from x402.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 x402 payment protection to your Flask application:
+
+```py
+from flask import Flask
+from x402.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 x402.clients.httpx import x402HttpxClient
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create client and make request
+async with x402HttpxClient(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 x402.clients.requests import x402_requests
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and make request
+session = x402_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 x402.clients.httpx import x402_payment_hooks
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create httpx client with x402 payment hooks
+async with httpx.AsyncClient(base_url="https://api.example.com") as client:
+    # Add payment hooks directly to client
+    client.event_hooks = x402_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 x402.clients.requests import x402_http_adapter
+
+# Initialize account
+account = Account.from_key("your_private_key")
+
+# Create session and mount the x402 adapter
+session = requests.Session()
+adapter = x402_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 x402 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 x402.types import PaymentRequiredResponse, PaymentRequirements
+from x402.encoding import safe_base64_decode
+
+payment_requirements = PaymentRequirements(...)
+facilitator = FacilitatorClient(facilitator_url)
+
+@app.get("/foo")
+async def foo(req: request: Request):
+    payment_required = PaymentRequiredResponse(
+        x402_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/coinbase/x402/tree/main/examples/python).

og_test_x402-0.0.5/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "og-test-x402"
+version = "0.0.5"
+description = "x402: An internet native payments protocol"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "erik", email = "erik.reppel@coinbase.com" }
+]
+requires-python = ">=3.10"
+keywords = ["x402", "sdk", "crypto", "cdp", "payments", "web3"]
+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/x402"]
+
+[tool.hatch.metadata]
+allow-direct-references = true

og_test_x402-0.0.5/src/x402/__init__.py

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

og_test_x402-0.0.5/src/x402/chains.py

@@ -0,0 +1,62 @@
+NETWORK_TO_ID = {
+    "og-devnet": "10744",
+}
+
+
+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 = {
+    "10744": [
+        {
+            "human_name": "ousdc",
+            "address": "0x48515A4b24f17cadcD6109a9D85a57ba55a619a6",
+            "name": "OUSDC",
+            "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}")

og_test_x402-0.0.5/src/x402/clients/__init__.py

@@ -0,0 +1,20 @@
+from x402.clients.base import x402Client, decode_x_payment_response
+from x402.clients.httpx import (
+    x402_payment_hooks,
+    x402HttpxClient,
+)
+from x402.clients.requests import (
+    x402HTTPAdapter,
+    x402_http_adapter,
+    x402_requests,
+)
+
+__all__ = [
+    "x402Client",
+    "decode_x_payment_response",
+    "x402_payment_hooks",
+    "x402HttpxClient",
+    "x402HTTPAdapter",
+    "x402_http_adapter",
+    "x402_requests",
+]