@chainpearc/sdk 0.0.0-stage → 0.3.0

package/dist/index.js

@@ -0,0 +1,1107 @@
+// src/chainpe.ts
+import { erc20Abi, formatUnits as formatUnits2, parseUnits, getAddress as getAddress2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import {
+  decodePaymentResponseHeader,
+  wrapFetchWithPaymentFromConfig
+} from "@x402/fetch";
+import { isBatchPayment } from "@circle-fin/x402-batching";
+import {
+  BatchEvmScheme,
+  CompositeEvmScheme,
+  GatewayClient
+} from "@circle-fin/x402-batching/client";
+
+// src/networks.ts
+import { createPublicClient, http, getAddress } from "viem";
+import { arc, arcTestnet } from "viem/chains";
+var USDC_DECIMALS = 6;
+var ARC_USDC = "0x3600000000000000000000000000000000000000";
+var NETWORKS = {
+  "arc-testnet": {
+    chain: arcTestnet,
+    caip2: "eip155:5042002",
+    gatewayChain: "arcTestnet",
+    rpcUrl: () => process.env.ARC_TESTNET_RPC_URL ?? "https://rpc.testnet.arc.io",
+    explorer: "https://explorer.testnet.arc.io",
+    accounts: "0xD315322c9D83A6f50A04236A2a242e0259bfB580",
+    reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
+  },
+  arc: {
+    chain: arc,
+    caip2: "eip155:5042",
+    gatewayChain: "arc",
+    rpcUrl: () => process.env.ARC_RPC_URL ?? "https://rpc.mainnet.arc.io",
+    explorer: "https://explorer.arc.io",
+    reputation: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63"
+  }
+};
+function info(network) {
+  if (!Object.hasOwn(NETWORKS, network)) {
+    throw new Error(`Invalid network "${network}" (expected arc-testnet or arc).`);
+  }
+  return NETWORKS[network];
+}
+function assertNetwork(network) {
+  info(network);
+  return network;
+}
+function getCaip2(network) {
+  return info(network).caip2;
+}
+function getGatewayChain(network) {
+  return info(network).gatewayChain;
+}
+function rpcUrlFor(network) {
+  return info(network).rpcUrl();
+}
+function explorerFor(network) {
+  return info(network).explorer;
+}
+function getUsdcAddress(network) {
+  info(network);
+  return ARC_USDC;
+}
+function chainFor(network) {
+  const { chain, explorer } = info(network);
+  return {
+    ...chain,
+    rpcUrls: { default: { http: [rpcUrlFor(network)] } },
+    blockExplorers: { default: { name: "Arc Explorer", url: explorer } }
+  };
+}
+function publicClientFor(network) {
+  return createPublicClient({
+    chain: chainFor(network),
+    transport: http(rpcUrlFor(network))
+  });
+}
+function resolveAccountsAddress(network, explicit) {
+  const candidate = explicit ?? process.env.CHAINPE_ACCOUNTS_ADDRESS ?? info(network).accounts;
+  return candidate ? getAddress(candidate) : void 0;
+}
+function resolveReputationRegistry(network, explicit) {
+  return getAddress(
+    explicit ?? process.env.ERC8004_REPUTATION_REGISTRY ?? info(network).reputation
+  );
+}
+function normalizeKey(key) {
+  return key.startsWith("0x") ? key : `0x${key}`;
+}
+
+// src/discovery.ts
+import { formatUnits } from "viem";
+
+// src/registry.ts
+var SERVICE_COMPONENTS = [
+  { name: "key", type: "bytes32" },
+  { name: "provider", type: "address" },
+  { name: "payTo", type: "address" },
+  { name: "agentId", type: "uint256" },
+  { name: "name", type: "string" },
+  { name: "description", type: "string" },
+  { name: "tags", type: "string" },
+  { name: "endpoint", type: "string" },
+  { name: "pricePerRequest", type: "string" },
+  { name: "network", type: "string" },
+  { name: "acceptsExact", type: "bool" },
+  { name: "acceptsGateway", type: "bool" },
+  { name: "active", type: "bool" },
+  { name: "createdAt", type: "uint64" },
+  { name: "updatedAt", type: "uint64" }
+];
+var ACCOUNTS_ABI = [
+  {
+    type: "function",
+    name: "serviceCount",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "MAX_SERVICES_PER_PAGE",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "getServices",
+    stateMutability: "view",
+    inputs: [
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [{ name: "page", type: "tuple[]", components: SERVICE_COMPONENTS }]
+  }
+];
+function decodeService(raw, network) {
+  const createdAt = Number(raw.createdAt);
+  const updatedAt = Number(raw.updatedAt);
+  const rails = [];
+  if (raw.acceptsGateway) rails.push("gateway");
+  if (raw.acceptsExact) rails.push("exact");
+  return {
+    id: raw.key,
+    name: raw.name,
+    description: raw.description,
+    tags: raw.tags.split(",").map((t) => t.trim()).filter(Boolean),
+    endpoint: raw.endpoint,
+    pricePerRequest: raw.pricePerRequest,
+    paymentToken: "USDC",
+    walletAddress: raw.payTo,
+    network,
+    rails,
+    source: "chainpe",
+    developer: raw.provider,
+    agentId: raw.agentId > 0n ? raw.agentId.toString() : void 0,
+    createdAt: createdAt ? new Date(createdAt * 1e3).toISOString() : void 0,
+    updatedAt: updatedAt ? new Date(updatedAt * 1e3).toISOString() : void 0
+  };
+}
+function filterServices(services, options) {
+  let results = [...services];
+  if (options.query) {
+    const q = options.query.toLowerCase();
+    results = results.filter(
+      (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.tags.some((tag) => tag.toLowerCase().includes(q))
+    );
+  }
+  if (options.tags?.length) {
+    const tl = options.tags.map((t) => t.toLowerCase());
+    results = results.filter(
+      (s) => s.tags.some((tag) => tl.includes(tag.toLowerCase()))
+    );
+  }
+  if (options.maxPrice) {
+    const max = parseFloat(options.maxPrice);
+    results = results.filter((s) => parseFloat(s.pricePerRequest) <= max);
+  }
+  if (options.gatewayOnly) {
+    results = results.filter((s) => s.rails.includes("gateway"));
+  }
+  return results;
+}
+function rankByReputation(services) {
+  return [...services].sort((a, b) => {
+    const sa = a.reputation?.score;
+    const sb = b.reputation?.score;
+    const aHas = sa != null;
+    const bHas = sb != null;
+    if (aHas !== bHas) return aHas ? -1 : 1;
+    if (aHas && bHas && sa !== sb) return sb - sa;
+    const ca = a.reputation?.count ?? 0;
+    const cb = b.reputation?.count ?? 0;
+    if (ca !== cb) return cb - ca;
+    return parseFloat(a.pricePerRequest) - parseFloat(b.pricePerRequest);
+  });
+}
+var RegistryClient = class {
+  constructor(network, address) {
+    this.network = network;
+    this.address = address;
+  }
+  network;
+  address;
+  getAddress() {
+    return this.address;
+  }
+  /** Lists every active service. Deactivated listings stay on-chain, so they are dropped here. */
+  async listAllServices() {
+    const client = publicClientFor(this.network);
+    const [count, maxPage] = await Promise.all([
+      client.readContract({
+        address: this.address,
+        abi: ACCOUNTS_ABI,
+        functionName: "serviceCount"
+      }),
+      client.readContract({
+        address: this.address,
+        abi: ACCOUNTS_ABI,
+        functionName: "MAX_SERVICES_PER_PAGE"
+      })
+    ]);
+    const total = Number(count);
+    const pageSize = Number(maxPage);
+    const out = [];
+    for (let offset = 0; offset < total; offset += pageSize) {
+      const limit = Math.min(pageSize, total - offset);
+      const page = await client.readContract({
+        address: this.address,
+        abi: ACCOUNTS_ABI,
+        functionName: "getServices",
+        args: [BigInt(offset), BigInt(limit)]
+      });
+      for (const raw of page) {
+        if (raw.active) out.push(decodeService(raw, this.network));
+      }
+    }
+    return out;
+  }
+};
+
+// src/reputation.ts
+import { createWalletClient, http as http2 } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var REPUTATION_ABI = [
+  {
+    type: "function",
+    name: "giveFeedback",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "value", type: "int128" },
+      { name: "valueDecimals", type: "uint8" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" },
+      { name: "endpoint", type: "string" },
+      { name: "feedbackURI", type: "string" },
+      { name: "feedbackHash", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "getSummary",
+    stateMutability: "view",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "clientAddresses", type: "address[]" },
+      { name: "tag1", type: "string" },
+      { name: "tag2", type: "string" }
+    ],
+    outputs: [
+      { name: "count", type: "uint64" },
+      { name: "summaryValue", type: "int128" },
+      { name: "summaryValueDecimals", type: "uint8" }
+    ]
+  },
+  {
+    type: "function",
+    name: "getClients",
+    stateMutability: "view",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address[]" }]
+  }
+];
+function summaryToScore(summaryValue, decimals) {
+  return Number(summaryValue) / 10 ** decimals;
+}
+async function getReputation(network, registry, agentId) {
+  if (!agentId || agentId === "0") return null;
+  if (!registry) return null;
+  try {
+    const client = publicClientFor(network);
+    const id = BigInt(agentId);
+    const clients = await client.readContract({
+      address: registry,
+      abi: REPUTATION_ABI,
+      functionName: "getClients",
+      args: [id]
+    });
+    if (clients.length === 0) return { count: 0, score: null };
+    const [count, summaryValue, decimals] = await client.readContract({
+      address: registry,
+      abi: REPUTATION_ABI,
+      functionName: "getSummary",
+      args: [id, clients, "", ""]
+    });
+    return {
+      count: Number(count),
+      score: summaryToScore(summaryValue, Number(decimals))
+    };
+  } catch {
+    return null;
+  }
+}
+async function giveFeedback(network, registry, privateKey, params) {
+  if (!registry) throw new Error("Reputation registry address not configured");
+  const account = privateKeyToAccount(normalizeKey(privateKey));
+  const wallet = createWalletClient({
+    account,
+    chain: chainFor(network),
+    transport: http2(rpcUrlFor(network))
+  });
+  const client = publicClientFor(network);
+  const { request } = await client.simulateContract({
+    account,
+    chain: chainFor(network),
+    address: registry,
+    abi: REPUTATION_ABI,
+    functionName: "giveFeedback",
+    args: [
+      BigInt(params.agentId),
+      BigInt(Math.round(params.value)),
+      0,
+      "x402",
+      params.tag ?? "paid-call",
+      params.endpoint ?? "",
+      "",
+      ZERO_HASH
+    ]
+  });
+  const hash = await wallet.writeContract(request);
+  if (params.waitConfirm) {
+    const receipt = await client.waitForTransactionReceipt({ hash });
+    if (receipt.status !== "success") throw new Error(`Feedback transaction ${hash} reverted.`);
+  }
+  return hash;
+}
+
+// src/discovery.ts
+var CIRCLE_DISCOVERY_URL = "https://api.circle.com/v2/x402/discovery/resources";
+var GATEWAY_SCHEME_NAME = "GatewayWalletBatched";
+var DEFAULT_LIMIT = 20;
+function mapCircleItem(item, network) {
+  const caip2 = getCaip2(network);
+  const accepts = (item.accepts ?? []).filter((a) => a.network === caip2);
+  if (accepts.length === 0) return void 0;
+  const cheapest = accepts.reduce(
+    (low, a) => BigInt(a.amount) < BigInt(low.amount) ? a : low
+  );
+  const rails = [];
+  if (accepts.some((a) => a.extra?.name === GATEWAY_SCHEME_NAME)) rails.push("gateway");
+  if (accepts.some((a) => a.extra?.name !== GATEWAY_SCHEME_NAME)) rails.push("exact");
+  const provider = item.metadata?.provider;
+  return {
+    id: item.resource,
+    name: provider?.name ?? new URL(item.resource).hostname,
+    description: item.metadata?.description ?? provider?.description ?? "",
+    tags: provider?.tags ?? [],
+    endpoint: item.resource,
+    method: item.metadata?.method,
+    pricePerRequest: formatUnits(BigInt(cheapest.amount), USDC_DECIMALS),
+    paymentToken: "USDC",
+    walletAddress: cheapest.payTo,
+    network,
+    rails,
+    source: "circle",
+    category: provider?.category,
+    updatedAt: item.lastUpdated
+  };
+}
+async function searchCircle(network, options) {
+  const url = new URL(CIRCLE_DISCOVERY_URL);
+  url.searchParams.set("network", getCaip2(network));
+  url.searchParams.set("limit", String(options.limit ?? DEFAULT_LIMIT));
+  if (options.query) url.searchParams.set("query", options.query);
+  if (options.category) url.searchParams.set("category", options.category);
+  if (options.maxPrice) url.searchParams.set("maxUsdPrice", options.maxPrice);
+  if (options.gatewayOnly) url.searchParams.set("supportsCircleGateway", "true");
+  const res = await fetch(url, { signal: AbortSignal.timeout(15e3) });
+  if (!res.ok) throw new Error(`Circle Discovery answered ${res.status}.`);
+  const body = await res.json();
+  return (body.items ?? []).flatMap((item) => mapCircleItem(item, network) ?? []);
+}
+function mergeListings(circle, chainpe) {
+  const key = (s) => `${s.walletAddress.toLowerCase()}@${hostOf(s.endpoint)}`;
+  const listed = new Set(circle.map(key));
+  return [...chainpe.filter((s) => !listed.has(key(s))), ...circle];
+}
+async function discoverServices(network, query = {}, addresses = {}) {
+  const options = typeof query === "string" ? { query } : query;
+  const accounts = resolveAccountsAddress(network, addresses.accountsAddress);
+  const reputationRegistry = resolveReputationRegistry(
+    network,
+    addresses.reputationRegistry
+  );
+  const [circle, chainpe] = await Promise.allSettled([
+    searchCircle(network, options),
+    accounts ? new RegistryClient(network, accounts).listAllServices().then((services2) => filterServices(services2, options)) : Promise.resolve([])
+  ]);
+  if (circle.status === "rejected" && chainpe.status === "rejected") {
+    throw new Error(
+      `Could not discover services: ${String(circle.reason)}; ${String(chainpe.reason)}`
+    );
+  }
+  const services = mergeListings(
+    circle.status === "fulfilled" ? circle.value : [],
+    chainpe.status === "fulfilled" ? chainpe.value : []
+  ).slice(0, options.limit ?? DEFAULT_LIMIT);
+  const ranked = await Promise.all(
+    services.map(async (s) => ({
+      ...s,
+      reputation: s.agentId ? await getReputation(network, reputationRegistry, s.agentId) : null
+    }))
+  );
+  return rankByReputation(ranked);
+}
+function hostOf(endpoint) {
+  try {
+    return new URL(endpoint).host;
+  } catch {
+    return endpoint;
+  }
+}
+
+// src/types.ts
+var ChainPePaymentError = class extends Error {
+  txHash;
+  reason;
+  constructor(message, { txHash, reason } = {}) {
+    super(message);
+    this.name = "ChainPePaymentError";
+    this.txHash = txHash;
+    this.reason = reason;
+  }
+};
+
+// src/chainpe.ts
+var DEFAULT_RAILS = ["gateway", "exact"];
+var AGENT_ID_HEADER = "x-chainpe-agent-id";
+var TX_HASH = /^0x[0-9a-fA-F]{64}$/;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function railPolicy(rails, gatewayAvailable) {
+  return (_version, requirements) => {
+    for (const rail of rails) {
+      const options = rail === "gateway" ? requirements.filter(
+        (r) => isBatchPayment(r) && BigInt(r.amount) <= gatewayAvailable
+      ) : requirements.filter((r) => !isBatchPayment(r));
+      if (options.length > 0) return options;
+    }
+    return [];
+  };
+}
+var ChainPe = class {
+  network;
+  rails;
+  accountsAddress;
+  reputationRegistry;
+  privateKey;
+  account;
+  maxPerCallAtomic;
+  autoFeedback;
+  gatewayClient;
+  constructor(options) {
+    if (!options.privateKey) {
+      throw new Error("ChainPe: `privateKey` is required.");
+    }
+    this.privateKey = normalizeKey(options.privateKey);
+    this.network = assertNetwork(options.network ?? "arc-testnet");
+    this.rails = options.rails?.length ? options.rails : DEFAULT_RAILS;
+    for (const rail of this.rails) {
+      if (rail !== "gateway" && rail !== "exact") {
+        throw new Error(`Invalid rail "${String(rail)}" (expected gateway or exact).`);
+      }
+    }
+    this.accountsAddress = resolveAccountsAddress(this.network, options.accountsAddress);
+    this.reputationRegistry = resolveReputationRegistry(
+      this.network,
+      options.reputationRegistry
+    );
+    this.account = privateKeyToAccount2(this.privateKey).address;
+    this.maxPerCallAtomic = parseUnits(options.maxPerCall ?? "1", USDC_DECIMALS);
+    this.autoFeedback = options.autoFeedback ?? false;
+  }
+  /** Echoes the resolved configuration (no secrets). */
+  get config() {
+    return {
+      network: this.network,
+      address: this.account,
+      rails: this.rails,
+      accountsAddress: this.accountsAddress,
+      reputationRegistry: this.reputationRegistry,
+      maxPerCall: formatUnits2(this.maxPerCallAtomic, USDC_DECIMALS)
+    };
+  }
+  /** The wallet address that signs payments and feedback. */
+  getAddress() {
+    return this.account;
+  }
+  /** Reads the wallet's USDC and the Circle Gateway deposit (human units). */
+  async balance() {
+    const usdc = await publicClientFor(this.network).readContract({
+      address: getUsdcAddress(this.network),
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [getAddress2(this.account)]
+    });
+    return {
+      usdc: formatUnits2(usdc, USDC_DECIMALS),
+      gateway: formatUnits2(await this.gatewayAvailable(), USDC_DECIMALS)
+    };
+  }
+  /** Deposits USDC into Circle Gateway, to pay on the Gateway rail with no gas. */
+  async depositGateway(amount) {
+    if (!/^\d+(\.\d{1,6})?$/.test(amount) || parseUnits(amount, USDC_DECIMALS) <= 0n) {
+      throw new Error(`Invalid amount "${amount}" (expected positive USDC, e.g. 1.50).`);
+    }
+    const result = await this.gateway().deposit(amount);
+    return { txHash: result.depositTxHash, amount: result.formattedAmount };
+  }
+  /**
+   * Drop-in `fetch` that automatically pays an x402 `402 Payment Required` in
+   * USDC and returns the final live {@link Response}.
+   */
+  async fetch(url, opts = {}) {
+    const { result, autoFeedback } = await this.execute(url, opts);
+    if (result.payment && (autoFeedback ?? this.autoFeedback)) {
+      await this.tryAutoFeedback(url, result.payment.recipient, result.agentId);
+    }
+    return result.response;
+  }
+  /**
+   * Like {@link fetch}, but returns the live, unread {@link Response} together
+   * with the payment details. Never posts feedback.
+   */
+  async request(url, opts = {}) {
+    return (await this.execute(url, opts)).result;
+  }
+  /**
+   * Like {@link fetch}, but returns a structured, body-parsed result with the
+   * payment + (optional) reputation details. Convenient for agents.
+   */
+  async pay(url, opts = {}) {
+    const { result, autoFeedback } = await this.execute(url, opts);
+    const { response } = result;
+    let reputation;
+    if (result.payment && (autoFeedback ?? this.autoFeedback)) {
+      reputation = await this.tryAutoFeedback(
+        url,
+        result.payment.recipient,
+        result.agentId
+      );
+    }
+    const data = await this.parseBody(response);
+    return {
+      status: response.status,
+      ok: response.ok,
+      headers: headersToObject(response.headers),
+      data,
+      payment: result.payment,
+      reputation
+    };
+  }
+  /**
+   * Finds services through Circle's Discovery API and ChainPeAccounts, annotated
+   * with ERC-8004 reputation and ranked. ChainPeAccounts also covers providers
+   * Circle has not listed yet. Throws only when neither source can be read.
+   */
+  async discover(query = {}) {
+    return discoverServices(this.network, query, {
+      accountsAddress: this.accountsAddress,
+      reputationRegistry: this.reputationRegistry
+    });
+  }
+  /** Reads a provider agent's aggregate ERC-8004 reputation. */
+  async getReputation(agentId) {
+    return getReputation(this.network, this.reputationRegistry, agentId);
+  }
+  /** Posts ERC-8004 feedback (0–100) for a provider agent. Returns the tx hash. */
+  async giveFeedback(agentId, score, opts = {}) {
+    return giveFeedback(this.network, this.reputationRegistry, this.privateKey, {
+      agentId,
+      value: score,
+      ...opts
+    });
+  }
+  // ─── internals ─────────────────────────────────────────────────────────────
+  gateway() {
+    this.gatewayClient ??= new GatewayClient({
+      chain: getGatewayChain(this.network),
+      privateKey: this.privateKey,
+      rpcUrl: rpcUrlFor(this.network)
+    });
+    return this.gatewayClient;
+  }
+  /** A deposit we cannot read counts as empty, so payment falls back to the wallet. */
+  async gatewayAvailable() {
+    try {
+      return (await this.gateway().getBalances()).gateway.available;
+    } catch {
+      return 0n;
+    }
+  }
+  /**
+   * Runs the x402 flow: request → on 402, cap the price, choose a rail, sign →
+   * retry. Spend limits run before anything is signed.
+   */
+  async execute(url, opts) {
+    const { autoFeedback, timeout = DEFAULT_TIMEOUT_MS, ...init } = opts;
+    let selected;
+    let agentId;
+    let gatewayAvailable = 0n;
+    const baseFetch = async (input, requestInit) => {
+      const caller = requestInit?.signal ?? (input instanceof Request ? input.signal : void 0);
+      const expiry = AbortSignal.timeout(timeout);
+      const response2 = await fetch(input, {
+        ...requestInit,
+        signal: caller ? AbortSignal.any([caller, expiry]) : expiry
+      });
+      agentId = response2.headers.get(AGENT_ID_HEADER) ?? agentId;
+      if (response2.status === 402 && !selected && this.rails.includes("gateway")) {
+        gatewayAvailable = await this.gatewayAvailable();
+      }
+      return response2;
+    };
+    const account = privateKeyToAccount2(this.privateKey);
+    const client = new CompositeEvmScheme(
+      new BatchEvmScheme(account),
+      new ExactEvmScheme(account)
+    );
+    const caip2 = getCaip2(this.network);
+    const payingFetch = wrapFetchWithPaymentFromConfig(baseFetch, {
+      schemes: [{ network: caip2, client }],
+      // CompositeEvmScheme cannot name default assets, so Arc USDC is listed with its own cap.
+      spendControls: {
+        maxAmountPerPayment: false,
+        allowedAssets: [
+          {
+            network: caip2,
+            asset: getUsdcAddress(this.network),
+            maxAmountPerPayment: this.maxPerCallAtomic.toString()
+          }
+        ]
+      },
+      policies: [
+        (version, requirements) => {
+          const options = railPolicy(this.rails, gatewayAvailable)(version, requirements);
+          selected = options[0];
+          return options;
+        }
+      ]
+    });
+    let response;
+    try {
+      response = await payingFetch(url, init);
+    } catch (err) {
+      throw this.explainPaymentError(err, url);
+    }
+    if (response.status === 402) {
+      const reason = await readFailureReason(response);
+      throw new ChainPePaymentError(
+        `x402: payment signed but the server did not accept it (${reason}). Check the USDC on ${this.network} or the Gateway deposit.`,
+        { reason }
+      );
+    }
+    return {
+      result: {
+        response,
+        payment: selected ? this.paymentInfo(selected, response) : void 0,
+        agentId
+      },
+      autoFeedback
+    };
+  }
+  paymentInfo(selected, response) {
+    const payment = {
+      amount: formatUnits2(BigInt(selected.amount), USDC_DECIMALS),
+      recipient: selected.payTo,
+      network: this.network,
+      rail: isBatchPayment(selected) ? "gateway" : "exact"
+    };
+    const header = response.headers.get("PAYMENT-RESPONSE");
+    if (header) {
+      try {
+        const receipt = decodePaymentResponseHeader(header);
+        payment.settlement = receipt;
+        if (TX_HASH.test(receipt.transaction)) payment.txHash = receipt.transaction;
+        else if (receipt.transaction) payment.transferId = receipt.transaction;
+      } catch {
+      }
+    }
+    return payment;
+  }
+  explainPaymentError(err, url) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/no network\/scheme registered/i.test(message)) {
+      return new Error(`x402: ${url} does not accept payment on ${this.network}.`);
+    }
+    if (/spend|maxAmountPerPayment|allowedAssets|exceed/i.test(message)) {
+      return new Error(
+        `x402: the price for ${url} exceeds maxPerCall ${formatUnits2(this.maxPerCallAtomic, USDC_DECIMALS)} USDC. Nothing was signed.`
+      );
+    }
+    if (/filtered|policy|policies/i.test(message)) {
+      return new ChainPePaymentError(
+        `x402: ${url} has no payment option for rails [${this.rails.join(", ")}]. A Gateway-only price needs a Gateway deposit.`,
+        { reason: "no_usable_rail" }
+      );
+    }
+    return err;
+  }
+  /**
+   * Best-effort positive feedback for the provider's agent after a paid call.
+   * Prefers the agent id the provider advertises; otherwise looks for its `payTo`
+   * in ChainPeAccounts. Never throws (self-feedback, no gas, etc. are swallowed).
+   */
+  async tryAutoFeedback(url, payTo, advertisedAgentId) {
+    try {
+      let agentId = advertisedAgentId;
+      if ((!agentId || agentId === "0") && this.accountsAddress) {
+        const registry = new RegistryClient(this.network, this.accountsAddress);
+        const services = await registry.listAllServices();
+        agentId = services.find(
+          (s) => s.walletAddress.toLowerCase() === payTo.toLowerCase() && s.agentId
+        )?.agentId;
+      }
+      if (!agentId || agentId === "0") return void 0;
+      const txHash = await giveFeedback(
+        this.network,
+        this.reputationRegistry,
+        this.privateKey,
+        {
+          agentId,
+          value: 100,
+          endpoint: new URL(url).origin,
+          tag: "x402-success"
+        }
+      );
+      return { agentId, score: 100, txHash };
+    } catch {
+      return void 0;
+    }
+  }
+  async parseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      try {
+        return await response.json();
+      } catch {
+        return null;
+      }
+    }
+    return response.text();
+  }
+};
+async function readFailureReason(response) {
+  const header = response.headers.get("PAYMENT-RESPONSE");
+  if (header) {
+    try {
+      const receipt = decodePaymentResponseHeader(header);
+      if (receipt.errorReason) return receipt.errorReason;
+    } catch {
+    }
+  }
+  try {
+    const body = await response.clone().json();
+    return body.reason ?? body.error ?? "settlement refused";
+  } catch {
+    return "settlement refused";
+  }
+}
+function headersToObject(headers) {
+  const obj = {};
+  headers.forEach((value, key) => {
+    obj[key] = value;
+  });
+  return obj;
+}
+
+// src/policyvault.ts
+import {
+  createWalletClient as createWalletClient2,
+  http as http3,
+  parseUnits as parseUnits2,
+  formatUnits as formatUnits3,
+  getAddress as getAddress3
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+var VAULT_ABI = [
+  {
+    type: "function",
+    name: "deposit",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "setPolicy",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "sessionKey", type: "address" },
+      { name: "maxPerCall", type: "uint256" },
+      { name: "dailyCap", type: "uint256" },
+      { name: "totalBudget", type: "uint256" },
+      { name: "expiry", type: "uint64" },
+      { name: "allowlistOnly", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "setAllowlist",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "allowed", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "revokeSession",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "spend",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "sessionSig", type: "bytes" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "nonces",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "dailyRemaining",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "budgetRemaining",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var SPEND_TYPES = {
+  Spend: [
+    { name: "owner", type: "address" },
+    { name: "to", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var PolicyVaultClient = class {
+  network;
+  vault;
+  account;
+  constructor(options) {
+    if (!options.privateKey) throw new Error("PolicyVaultClient: privateKey required");
+    if (!options.vaultAddress) throw new Error("PolicyVaultClient: vaultAddress required");
+    this.network = options.network ?? "arc-testnet";
+    this.vault = getAddress3(options.vaultAddress);
+    this.account = privateKeyToAccount3(normalizeKey(options.privateKey));
+  }
+  getAddress() {
+    return this.account.address;
+  }
+  wallet() {
+    return createWalletClient2({
+      account: this.account,
+      chain: chainFor(this.network),
+      transport: http3(rpcUrlFor(this.network))
+    });
+  }
+  usdc(human) {
+    return parseUnits2(human, USDC_DECIMALS);
+  }
+  // ─── reads ────────────────────────────────────────────────────────────────
+  async balanceOf(owner) {
+    const raw = await publicClientFor(this.network).readContract({
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "balanceOf",
+      args: [getAddress3(owner)]
+    });
+    return formatUnits3(raw, USDC_DECIMALS);
+  }
+  async dailyRemaining(owner) {
+    const raw = await publicClientFor(this.network).readContract({
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "dailyRemaining",
+      args: [getAddress3(owner)]
+    });
+    return formatUnits3(raw, USDC_DECIMALS);
+  }
+  async budgetRemaining(owner) {
+    const raw = await publicClientFor(this.network).readContract({
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "budgetRemaining",
+      args: [getAddress3(owner)]
+    });
+    return formatUnits3(raw, USDC_DECIMALS);
+  }
+  async nonce(owner) {
+    return await publicClientFor(this.network).readContract({
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "nonces",
+      args: [getAddress3(owner)]
+    });
+  }
+  // ─── owner ops (this key is the owner) ──────────────────────────────────────
+  async deposit(human) {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "deposit",
+      args: [this.usdc(human)]
+    });
+  }
+  async withdraw(human) {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "withdraw",
+      args: [this.usdc(human)]
+    });
+  }
+  async setPolicy(p) {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "setPolicy",
+      args: [
+        getAddress3(p.sessionKey),
+        this.usdc(p.maxPerCall),
+        this.usdc(p.dailyCap),
+        this.usdc(p.totalBudget),
+        BigInt(p.expiry),
+        p.allowlistOnly ?? false
+      ]
+    });
+  }
+  async setAllowlist(to, allowed) {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "setAllowlist",
+      args: [getAddress3(to), allowed]
+    });
+  }
+  async revokeSession() {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "revokeSession",
+      args: []
+    });
+  }
+  // ─── agent: sign a spend (gasless — no tx) ──────────────────────────────────
+  /**
+   * Signs a spend authorization with this key (the session key). Reads the
+   * owner's current nonce so the relayer can submit it. `ttlSeconds` bounds how
+   * long the authorization stays valid (default 5 min).
+   */
+  async signSpend(params) {
+    const owner = getAddress3(params.owner);
+    const to = getAddress3(params.to);
+    const amountAtomic = this.usdc(params.amount);
+    const nonce = await this.nonce(owner);
+    const deadline = Math.floor(Date.now() / 1e3) + (params.ttlSeconds ?? 300);
+    const signature = await this.account.signTypedData({
+      domain: {
+        name: "ChainPePolicyVault",
+        version: "1",
+        chainId: chainFor(this.network).id,
+        verifyingContract: this.vault
+      },
+      types: SPEND_TYPES,
+      primaryType: "Spend",
+      message: {
+        owner,
+        to,
+        amount: amountAtomic,
+        nonce,
+        deadline: BigInt(deadline)
+      }
+    });
+    return {
+      owner,
+      to,
+      amount: params.amount,
+      amountAtomic: amountAtomic.toString(),
+      nonce: nonce.toString(),
+      deadline,
+      signature
+    };
+  }
+  // ─── relayer: submit a signed spend (pays gas) ──────────────────────────────
+  /**
+   * Submits a session-signed spend. Throws with the on-chain revert reason if a
+   * policy limit is violated (e.g. "over per-call cap").
+   */
+  async relaySpend(auth) {
+    return this.wallet().writeContract({
+      account: this.account,
+      chain: chainFor(this.network),
+      address: this.vault,
+      abi: VAULT_ABI,
+      functionName: "spend",
+      args: [
+        getAddress3(auth.owner),
+        getAddress3(auth.to),
+        BigInt(auth.amountAtomic),
+        BigInt(auth.deadline),
+        auth.signature
+      ]
+    });
+  }
+};
+export {
+  CIRCLE_DISCOVERY_URL,
+  ChainPe,
+  ChainPePaymentError,
+  PolicyVaultClient,
+  RegistryClient,
+  USDC_DECIMALS,
+  chainFor,
+  decodeService,
+  discoverServices,
+  explorerFor,
+  filterServices,
+  getCaip2,
+  getReputation,
+  getUsdcAddress,
+  giveFeedback,
+  mapCircleItem,
+  mergeListings,
+  normalizeKey,
+  publicClientFor,
+  railPolicy,
+  rankByReputation,
+  resolveAccountsAddress,
+  resolveReputationRegistry,
+  rpcUrlFor,
+  searchCircle,
+  summaryToScore
+};
+//# sourceMappingURL=index.js.map