Third-party service integrations

// /.well-known/x402 — publish at <your-domain>/.well-known/x402
import express from "express";
const app = express();

app.get("/.well-known/x402", (_req, res) => {
  res.json({
    x402Version: 1,
    accepts: [{
      scheme: "exact",
      network: "solana-devnet",
      asset: "<your-USDC-mint>",
      maxAmountRequired: "50000",          // $0.05 atomic units (6 decimals)
      payTo: "<YOUR_TREASURY_OWNER>",      // owner pubkey, NOT ATA
      resource: "https://yourapi.dev/api/v1/inference",
      extra: { feePayer: "<facilitator>", decimals: 6, symbol: "USDC" },
    }],
  });
});

// Priced endpoint with 402 handling
app.post("/api/v1/inference", async (req, res) => {
  const sig = req.header("PAYMENT-SIGNATURE") ?? req.header("X-PAYMENT");

  if (!sig) {
    // No payment header → return 402 with accepts list
    return res.status(402).json({
      x402Version: 1,
      accepts: [/* same shape as .well-known */],
      error: "X-PAYMENT header is required",
    });
  }

  // Verify + settle via your x402 facilitator of choice (Coinbase, etc.)
  const settled = await facilitator.verifyAndSettle(sig, req.body);
  if (!settled.ok) return res.status(402).json({ error: "payment invalid" });

  // Execute your real handler
  const result = await runInference(req.body);
  res.setHeader("PAYMENT-RESPONSE", settled.responseHeader);
  res.json({ data: result, meta: { tx_hash: settled.tx_hash } });
});

# FastAPI equivalent — same .well-known/x402 manifest shape
from fastapi import FastAPI, Header, HTTPException, Request
from fastapi.responses import JSONResponse

app = FastAPI()

WELLKNOWN = {
    "x402Version": 1,
    "accepts": [{
        "scheme": "exact",
        "network": "solana-devnet",
        "asset": "<your-USDC-mint>",
        "maxAmountRequired": "50000",
        "payTo": "<YOUR_TREASURY_OWNER>",
        "resource": "https://yourapi.dev/api/v1/inference",
    }],
}

@app.get("/.well-known/x402")
async def wellknown():
    return WELLKNOWN

@app.post("/api/v1/inference")
async def inference(
    request: Request,
    payment_signature: str | None = Header(default=None, alias="PAYMENT-SIGNATURE"),
):
    if not payment_signature:
        return JSONResponse(status_code=402, content={
            **WELLKNOWN,
            "error": "X-PAYMENT header is required",
        })
    # ... verify, settle, execute
    return {"data": ..., "meta": {"tx_hash": ...}}

// Agent code consuming any Payment Factory service
import { AxiomClient } from "@axiom-stack/sdk";

const client = new AxiomClient({
  // No API key required for pay() against third-party services —
  // your own wallet signer handles settlement end-to-end.
  walletSigner: yourSolanaWalletSigner,
});

// 1. Discover the service's payment terms
const manifest = await client.discover("https://yourapi.dev");
const target = manifest.endpoints[0];

// 2. Pay + invoke in one call
const res = await client.pay({
  to: target.payTo,
  amount_micros: parseInt(target.price_atomic_units),
  protocol: "x402",
  network: target.network,
  asset: target.asset,
  resource: target.resource,
  signer: yourSolanaWalletSigner,
});

// 3. Use the result
console.log(res.tx_sig, res.settled_amount_micros);

# Same shape in Python — LangChain / AutoGen / ElizaOS tool
from axiom_stack import AxiomClient

client = AxiomClient(wallet_signer=your_solana_wallet)

manifest = client.discover("https://yourapi.dev")
target = manifest.endpoints[0]

result = client.pay(
    to=target.pay_to,
    amount_micros=int(target.price_atomic_units),
    protocol="x402",
    network=target.network,
    asset=target.asset,
    resource=target.resource,
    signer=your_solana_wallet,
)
print(result.tx_sig, result.settled_amount_micros)