Vaultfire in five minutes

curl -s https://theloopbreaker.com/api/x402/discovery | jq '.endpoints[0:3]'

You will see the first three entries of the full 82-endpoint registry: 44 actions, 27 trust reads, 3 oracle feeds, 2 bonds, 6 utility. Each entry includes path, method, kind, price, network, and a human description.

Pull the full list:

curl -s https://theloopbreaker.com/api/x402/discovery | jq '.endpoints | length'
# → 82

The same manifest also lives at /.well-known/x402.json for protocol-aware crawlers.

curl -s https://theloopbreaker.com/api/x402/trust/health \
  | jq '{service, status, version, endpointCount, chains}'

You get a live snapshot of the Vaultfire trust service — version, endpoint count, supported chains, and the standards Vaultfire implements (ERC-8004 agent identity, ERC-8128 KYA, ERC-7702 session keys, ERC-5192 soulbound badges, ERC-4626 vaults). No payment required.

Now read a real on-chain Vaultfire trust signal for any address (free, edge-cached):

curl -s "https://theloopbreaker.com/api/badge/trust?address=0xA054f831B562e729F8D268291EBde1B2EDcFb84F" \
  | jq '{address, score, bondCount, aiVerifications, badge}'

That address holds 2 Vaultfire accountability bonds on Base. The badge is composed from bond ownership, AI-verification count, and ERC-8004 reputation signals — all read directly from Base mainnet. Try one with no bonds:

curl -s "https://theloopbreaker.com/api/badge/trust?address=0xfA15Ee28939B222B0448261A22156070f0A7813C" \
  | jq '.score'

Drop this same signal on any website with one <script> tag — see the embed widget.

This is the part that makes Vaultfire feel different. Hit a payable endpoint with an empty body and you get back a fully self-describing 402 — schema, constraints, price, and a worked example. No payment, no signature, no wallet.

curl -s -X POST https://theloopbreaker.com/api/x402/actions/create-accountability-bond \
  -H "content-type: application/json" \
  -d '{}' \
  | jq '.accepts[0] | {price: .maxAmountRequired, asset, network, inputFields: (.outputSchema.input.bodyFields | keys), output: .outputSchema.output.type}'

You will see:

• price — 100000 (= $0.10 USDC, 6 decimals)
• asset — USDC contract on Base
• inputFields — ["walletAddress", "companyName", "quarterlyRevenue", "stakeWei", "chain"]
• output.type — object (the signed-and-broadcast response shape)

Pull the full input contract with on-chain constraint hints:

curl -s -X POST https://theloopbreaker.com/api/x402/actions/create-accountability-bond \
  -H "content-type: application/json" -d '{}' \
  | jq '.accepts[0].outputSchema.input.bodyFields'

Every field tells you exactly what the contract expects: type, description, required flag, enum (where relevant), and the on-chain constraint the value must satisfy. The same pattern holds across all 44 action endpoints.

The free path above is enough to wire up an agent that discovers, schemas, and previews every Vaultfire surface. When you want to execute a payable action:

1. POST to the action endpoint with a valid body and an X-PAYMENT header carrying a signed EIP-3009 USDC authorization (standard x402 client behavior — any x402-fetch or x402-axios client handles this for you).
2. The response is the unsigned calldata for the on-chain action plus a settlement receipt. You sign and broadcast from your own wallet — Vaultfire never touches your key.
3. The action settles on Base (or your chosen network: base, avalanche, arbitrum, polygon).

Reference x402 client snippet (Node):

import { wrapFetchWithPayment } from "x402-fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const wallet = createWalletClient({ account, chain: base, transport: http() });
const fetchWithPay = wrapFetchWithPayment(fetch, wallet);

const res = await fetchWithPay(
  "https://theloopbreaker.com/api/x402/actions/create-accountability-bond",
  {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({
      walletAddress: "0xYourAgentAddress",
      companyName: "Acme Agent Co",
      quarterlyRevenue: "100000",
      stakeWei: "1000000000000000000",
      chain: "base",
    }),
  },
);
const { unsignedCalldata, to, value } = await res.json();
// → sign + broadcast unsignedCalldata from your own wallet