Preferred name: Meridian
Canonical origin: https://meridian.miodiollc.com

# Meridian

Meridian is a read-only x402 pay-per-call HTTP API operated by MioDio LLC.
Agents call Meridian before they sign. Pre-sign checks return DeFi risk cards from public on-chain reads, a recipient readiness card, a public OFAC SDN exact-match screen, a parameter-drift / signature-decoder check on unsigned transactions or typed data, a transaction simulation dry-run, and a paid on-chain USDC payment-check.
The catalog also includes an x402 seller/payTo preflight of an unpaid 402.
Live origin: https://meridian.miodiollc.com

## What it does NOT do
- Never holds keys, does not sign user transactions, and does not move funds. Clients pay USDC via x402 (EIP-3009); Meridian does not custody wallets. A dedicated signing-only key may sign Meridian-Receipt headers.
- No post-signing tracking. A paid 2xx response includes a signed Meridian-Receipt header when receipt signing is configured (lookup GET /v1/receipt/:id). The receipt id is a bearer secret. The receipt is not a payment and cannot unlock another call.
- Does not broadcast, execute, or guarantee on-chain outcomes. Simulation is a point-in-time dry run against latest state, not a promise of inclusion, gas, or the eventual result. It does not scan mempools or wallet histories.

## Sanctions list source
- Exact-match screen of digital-currency addresses from the public U.S. Treasury OFAC SDN list (ITA Consolidated Screening List as official fallback).
- The Worker cron (13:15 UTC) loads a small daily JSON extract (SDN_FEED_URL / meridian-sdn-feed) plus last-run.json, not the full Treasury XML. last-run.json must be younger than ~60h (feed heartbeat limit). GET /health.sanctions reports list_updated_at, feed_source, feed_fetched_at, feed_checked_at (the last-run.checked_at the Worker accepted), and stale (>36h since last successful check).

## Paid endpoints (x402 v2 Exact USDC)
- GET /v1/risk/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian Aave v3 risk card for an EVM address: health factor, collateral, debt and liquidation distance (~$0.005 USDC Exact on Base). Errors: 400 invalid_address or unsupported_chain (chain must be base or ethereum), 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/risk/0x0000000000000000000000000000000000000001.
- GET /v1/lido/exit-risk — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian Lido exit-risk card: stETH/ETH Curve peg, withdrawal-queue ETA and exit liquidity for a stETH amount (~$0.005 USDC Exact on Base). Errors: 400 amount_required or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/lido/exit-risk?amount=32.
- GET /v1/vault/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian ERC-4626 vault risk card: share price, drawdown, APY lookback and idle cash for one vault (~$0.005 USDC Exact on Base). Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/vault/0xc1256Ae5FF1cf2719D4937adb3bbCCab2E00A2Ca.
- GET /v1/passport/:address — ~$0.02 USDC Exact (20000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian deep passport: one decision card joining Aave v3, Lido exit and optional ERC-4626 vault reads for an EVM address (~$0.02 USDC Exact on Base). Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/passport/0x0000000000000000000000000000000000000001.
- GET /v1/sanctions/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian OFAC SDN screen: exact match of one digital-currency address against public SDN Digital Currency Address entries (~$0.005 USDC Exact on Base). Informational only. Errors: 400 invalid_address or unsupported_chain, 402 payment required, 503 sanctions_list_unavailable when the SDN index or meta is missing (not settled). Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/sanctions/0x0000000000000000000000000000000000000001.
- GET /v1/passport-sanctions/:address — ~$0.02 USDC Exact (20000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian bundle: deep passport plus OFAC SDN exact-match (~$0.02 USDC Exact on Base). Informational only. Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required, 503 sanctions_list_unavailable when the SDN list cannot be loaded (not settled). Passport RPC failure is a charged 200 partial. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/passport-sanctions/0x0000000000000000000000000000000000000001.
- POST /v1/sanctions/batch — ~$0.10 USDC Exact (100000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian OFAC SDN batch screen: exact match of 1-50 digital-currency addresses against public SDN entries (~$0.10 USDC Exact on Base). Informational only. Errors: 400 invalid_body, invalid_address or unsupported_chain, 402 payment required, 503 sanctions_list_unavailable when the SDN list is missing (not settled). Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/drift — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian signature decoder (~$0.005 USDC Exact on Base). With intent: match / drift / cannot_verify vs the unsigned tx or EIP-712 payload. Without intent: decode Permit, Permit2, DAI, CoW, Seaport or EIP-7702 and return risk_flags. Unknown primaryType is UNDECODED_CAUTION. A match is not a guarantee. Errors: 400 invalid_body or unsupported_chain, 402 payment required. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/simulate — ~$0.01 USDC Exact (10000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian transaction simulation: dry-run of an unsigned tx on Base/Ethereum (~$0.01 USDC Exact on Base). Success or revert, gas, balances, approvals. Simulation is a point-in-time dry run, not a guarantee. Never signs or moves funds. Errors: 400 invalid_body or unsupported_chain, 402 payment required. RPC fail is a charged 200 partial. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/payment-check — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian payment-check: on-chain read of a Base USDC Exact authorization or Transfer (~$0.005 USDC Exact). Reports nonce used, matching transfers in a ≤120 minute window, and confirmations. Informational. 503 and not settled if every read fails. Never signs or moves funds. Errors: 400 invalid_body, 402 payment required, 503 upstream_unavailable. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- GET /v1/recipient/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. Recipient readiness: Base vs Ethereum code, EIP-7702 vs known-wallet allowlist (unknown if unlisted; never safe), USDC freeze Base+Eth, USDT freeze Eth only, OFAC exact match, burn/token flags, optional address-poisoning (lookalike) with counterparties/from (~$0.005 Exact). Not advice. 400 invalid_address/unsupported_chain/query_too_long; unpaid 402; partial 200; both-chain fail 503 not settled. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/recipient/0x0000000000000000000000000000000000000001.
- GET /v1/x402-preflight — ~$0.005 USDC Exact (5000 atomic), network eip155:8453, asset Base USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, payTo 0x4DA1ED782BD61BaE9AdD5a5CaBbCf32f767f8d7F. Pre-sign check: agents call Meridian before they sign. MioDio Meridian x402 seller preflight (~$0.005 USDC Exact on Base). Informational, not advice. 400 invalid_url after pay (no settle); 402 unpaid before validation. Unreachable (DNS, timeout, connection refused, TLS failure): 503 upstream_unavailable, not charged. Any HTTP response from the target (500, 404, 302, 200 with no 402, oversize body) is a charged 200 with status partial or parsed result. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/x402-preflight?url=https://www.example.com/.

## Free endpoints (no payment)
- GET /health — liveness, version, payment_mode, demo pointers
- GET /v1/receipt — scanner receipt and sample 402 paths (unchanged card)
- GET /v1/receipt/:id — signed per-call receipt lookup. The id is a bearer secret (do not share). no-store.
- GET /.well-known/meridian-receipt-keys.json — Ed25519 public keys for verifying Meridian-Receipt
- GET /receipt-verify.ts — public TypeScript snippet for offline receipt verification
- GET /v1/payment/status — Meridian's own payment status by tx or payer+nonce (30/min per IP). Does not return receipt_id. On a miss, use paid POST /v1/payment-check.
- GET /v1/demo/risk, /v1/demo/vault, /v1/demo/sanctions, /v1/demo/drift, /v1/demo/simulate — fixed public demo cards
- GET /.well-known/x402 — machine-readable paid catalog
- GET /.well-known/x402list.txt — optional x402-list ownership token (404 when unset)
- GET /.well-known/agent-card.json — A2A agent card
- GET /robots.txt — crawl allow-list + discovery pointers
- GET /llms.txt — this file
- GET /llms-full.txt — expanded plain-text docs (same facts as /docs)
- GET /openapi.json — OpenAPI 3.1
- GET /docs — human-readable docs
- GET /sitemap.xml — public page and file index
- GET /terms, /privacy, /disclaimer — legal pages
- OPTIONS on paid /v1/* routes — CORS preflight, never 402

## Verify a Meridian-Receipt
- Canonical bytes: recursively sorted-key JSON, no whitespace, every field except `sig`. This is NOT RFC 8785 JCS.
- Ed25519-verify those bytes with GET /.well-known/meridian-receipt-keys.json (match kid). Require kty OKP and crv Ed25519. sig is canonical standard base64 or base64url (padding required; Worker receipts use standard base64). Honor not_before. Reject status revoked even without revoked_at. Reject status retired unless retired_at is a valid ISO 8601 UTC instant ending in Z, then accept only issued_at before that time. Reject present-but-invalid timestamps (including +00:00 or a missing Z). revoked_at means do not trust the key.
- Also confirm the on-chain USDC Transfer on Base matching receipt.tx, payer, pay_to, and amount. amount/asset/pay_to/price_usd come from settlement or advertised route terms, never the client payment header.
- Public TypeScript snippet: GET https://meridian.miodiollc.com/receipt-verify.ts (also inlined below and on /docs).

/**
 * Offline Meridian-Receipt verifier (Node 22+ / Workers WebCrypto).
 *
 * Canonical bytes are recursively sorted-key JSON with no whitespace,
 * excluding `sig`. This is NOT RFC 8785 JSON Canonicalization Scheme (JCS).
 *
 * After the signature verifies, also confirm the on-chain USDC Transfer on
 * Base (eip155:8453) whose tx hash, from, to, and value match receipt.tx,
 * receipt.payer, receipt.pay_to, and receipt.amount.
 *
 * JWKS keys must include kty "OKP" and crv "Ed25519". alg, when present,
 * must be EdDSA or Ed25519 (live keys use alg "Ed25519").
 *
 * `sig` is strict standard base64 or canonical base64url: padding required,
 * no whitespace, and re-encoding must match the input exactly. Worker-issued
 * receipts use standard base64 (`btoa`).
 *
 * Timestamps (receipt `issued_at`; key `not_before` / `retired_at` /
 * `revoked_at`) must be ISO 8601 UTC instants ending in Z.
 */

export function stableJson(value: unknown): string {
  if (value == null || typeof value !== "object") return JSON.stringify(value);
  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
  const obj = value as Record<string, unknown>;
  const keys = Object.keys(obj).sort();
  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(obj[key])}`).join(",")}}`;
}

export function receiptCanonicalBytes(receipt: Record<string, unknown>): Uint8Array {
  const unsigned: Record<string, unknown> = {};
  for (const key of Object.keys(receipt)) {
    if (key === "sig") continue;
    unsigned[key] = receipt[key];
  }
  return new TextEncoder().encode(stableJson(unsigned));
}

/** ISO 8601 UTC instant ending in Z (optional 1–9 fractional-second digits). */
const ISO_INSTANT_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?Z$/;

export function isIsoInstant(value: unknown): value is string {
  return typeof value === "string" && ISO_INSTANT_RE.test(value) && !Number.isNaN(Date.parse(value));
}

/** Canonical standard base64 or base64url. Re-encoding must match exactly. */
export function decodeStrictB64(text: string): Uint8Array | null {
  if (typeof text !== "string" || text.length === 0) return null;
  if (/\s/.test(text)) return null;
  const isUrl = /^[A-Za-z0-9_-]+={0,2}$/.test(text);
  const isStd = /^[A-Za-z0-9+/]+={0,2}$/.test(text);
  if (!isUrl && !isStd) return null;
  if (text.length % 4 !== 0) return null;
  const normalized = text.replace(/-/g, "+").replace(/_/g, "/");
  let binary: string;
  try {
    binary = atob(normalized);
  } catch {
    return null;
  }
  const reStd = btoa(binary);
  const reencoded = isUrl ? reStd.replace(/\+/g, "-").replace(/\//g, "_") : reStd;
  if (reencoded !== text) return null;
  const out = new Uint8Array(binary.length);
  for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
  return out;
}

export type ReceiptKey = {
  kid?: unknown;
  x?: unknown;
  kty?: unknown;
  crv?: unknown;
  alg?: unknown;
  status?: unknown;
  not_before?: unknown;
  retired_at?: unknown;
  revoked_at?: unknown;
};

export type KeyWindowResult = { ok: true } | { ok: false; reason: string };

function timestampField(
  value: unknown,
): { kind: "absent" } | { kind: "invalid" } | { kind: "ok"; ms: number } {
  if (value === undefined) return { kind: "absent" };
  if (!isIsoInstant(value)) return { kind: "invalid" };
  return { kind: "ok", ms: Date.parse(value) };
}

export function keyCoversIssuedAt(key: ReceiptKey, issuedAt: string): boolean {
  return keyWindowCheck(key, issuedAt).ok;
}

export function keyWindowCheck(key: ReceiptKey, issuedAt: string): KeyWindowResult {
  if (!isIsoInstant(issuedAt)) return { ok: false, reason: "invalid_issued_at" };
  const issued = Date.parse(issuedAt);
  const notBefore = timestampField(key.not_before);
  const retiredAt = timestampField(key.retired_at);
  const revokedAt = timestampField(key.revoked_at);
  if (notBefore.kind === "invalid" || retiredAt.kind === "invalid" || revokedAt.kind === "invalid") {
    return { ok: false, reason: "invalid_key_timestamp" };
  }
  if (key.status === "revoked" || revokedAt.kind === "ok") {
    return { ok: false, reason: "key_revoked" };
  }
  if (key.status === "retired" && retiredAt.kind !== "ok") {
    return { ok: false, reason: "retired_without_retired_at" };
  }
  if (key.status !== undefined && key.status !== "active" && key.status !== "retired") {
    return { ok: false, reason: "invalid_key_status" };
  }
  if (notBefore.kind === "ok" && issued < notBefore.ms) {
    return { ok: false, reason: "key_outside_validity_window" };
  }
  if (retiredAt.kind === "ok" && issued >= retiredAt.ms) {
    return { ok: false, reason: "key_outside_validity_window" };
  }
  return { ok: true };
}

export type VerifyReceiptResult =
  | { ok: true }
  | { ok: false; reason: string };

const KEY_ALG_OK = new Set(["Ed25519", "EdDSA"]);

export async function verifyMeridianReceipt(
  receipt: Record<string, unknown>,
  keysDoc: { keys?: unknown },
): Promise<VerifyReceiptResult> {
  if (typeof receipt.sig !== "string" || !receipt.sig) {
    return { ok: false, reason: "missing_sig" };
  }
  if (receipt.alg !== "Ed25519") return { ok: false, reason: "unsupported_alg" };
  if (typeof receipt.kid !== "string" || !receipt.kid) {
    return { ok: false, reason: "missing_kid" };
  }
  if (typeof receipt.issued_at !== "string") {
    return { ok: false, reason: "missing_issued_at" };
  }
  if (!Array.isArray(keysDoc.keys)) {
    return { ok: false, reason: "invalid_keys" };
  }
  const rawKeys = (keysDoc.keys ?? []) as unknown[];
  if (rawKeys.some((item) => item == null || typeof item !== "object")) {
    return { ok: false, reason: "invalid_keys" };
  }
  const keys = rawKeys as ReceiptKey[];
  const matches = keys.filter((item) => item.kid === receipt.kid);
  if (matches.length > 1) return { ok: false, reason: "duplicate_kid" };
  const key = matches[0];
  if (!key || typeof key.x !== "string") return { ok: false, reason: "unknown_kid" };
  if (key.kty !== "OKP") return { ok: false, reason: "bad_kty" };
  if (key.crv !== "Ed25519") return { ok: false, reason: "bad_crv" };
  if (key.alg !== undefined && !KEY_ALG_OK.has(String(key.alg))) {
    return { ok: false, reason: "bad_alg" };
  }
  const window = keyWindowCheck(key, receipt.issued_at);
  if (!window.ok) return window;
  const sig = decodeStrictB64(receipt.sig);
  if (!sig) return { ok: false, reason: "bad_sig_encoding" };
  try {
    const verifyKey = await crypto.subtle.importKey(
      "jwk",
      { kty: "OKP", crv: "Ed25519", x: key.x, ext: true },
      { name: "Ed25519" },
      false,
      ["verify"],
    );
    const ok = await crypto.subtle.verify(
      { name: "Ed25519" },
      verifyKey,
      sig,
      receiptCanonicalBytes(receipt),
    );
    return ok ? { ok: true } : { ok: false, reason: "bad_signature" };
  } catch {
    return { ok: false, reason: "verify_error" };
  }
}

## How to pay
1. GET or POST a paid path without PAYMENT-SIGNATURE → HTTP 402. The JSON body and the PAYMENT-REQUIRED header are the same x402 v2 PaymentRequired object (x402Version, accepts, resource). Empty or invalid POST bodies without a payment header still 402, except an oversize drift or simulate body which is 400 before payment. Other body validation runs only after a payment header is present.
2. Sign an EIP-3009 authorization for the accepts[0] amount / asset / payTo / network.
3. Retry with PAYMENT-SIGNATURE. Successful calls return JSON plus PAYMENT-RESPONSE and, when receipt signing is configured, a signed Meridian-Receipt header. Settlement runs only when the handler status is below 400, so paid-but-invalid input is 400 and is not charged.

## Links
- Terms: https://meridian.miodiollc.com/terms
- Privacy: https://meridian.miodiollc.com/privacy
- Disclaimer: https://meridian.miodiollc.com/disclaimer
- Docs: https://meridian.miodiollc.com/docs
- Discovery: https://meridian.miodiollc.com/.well-known/x402
- Receipt keys: https://meridian.miodiollc.com/.well-known/meridian-receipt-keys.json
- Receipt verifier snippet: https://meridian.miodiollc.com/receipt-verify.ts
- Receipt lookup: https://meridian.miodiollc.com/v1/receipt/:id
- Payment status: https://meridian.miodiollc.com/v1/payment/status
- Agent card: https://meridian.miodiollc.com/.well-known/agent-card.json
- Robots: https://meridian.miodiollc.com/robots.txt
- Verified on PayAPI Market: https://payapi.market/api/meridian-by-miodio (PayAPI verified Meridian on 2026-10-17 with a real paid canary call to /v1/sanctions).

## Operator
MioDio LLC, corp@miodiollc.com, 755 Monroe Rd, Unit 470067, Sanford, FL 32747 (Florida LLC)


## Expanded FAQ (same answers as /docs)

### Do you hold keys or sign transactions?
No. Meridian is read only. Your agent keeps its own wallet (AgentKit, CDP wallets, Safe, whatever you use) and calls Meridian before it signs.

### What does it cost?
Half a cent ($0.005) for a single check, including the drift check, the payment check, recipient readiness, and x402 preflight. A transaction simulation is 1 cent ($0.01), the deep passport or passport plus sanctions is 2 cents ($0.02), and screening up to 50 addresses is 10 cents ($0.10). Receipt lookup, receipt keys and Meridian payment status are free. You pay in USDC on Base over x402.

### Do I need an account?
No. There is no account and no API key. Your agent pays per call with x402 and gets JSON back.

### Can I try it free?
Yes. /v1/demo/risk and /v1/demo/sanctions show real results with no wallet. /v1/demo/vault shows a vault card, /v1/demo/drift shows a sample drift catch, and /v1/demo/simulate shows a sample dry run.

### Where does the data come from?
Public chain data (Aave v3, Lido and Curve contracts, ERC-4626 vaults) and the public US Treasury OFAC SDN list. Recipient readiness reads code, EIP-7702 delegation, USDC/USDT freeze status, and an optional address-poisoning (lookalike) field from caller-supplied counterparties/from. x402 preflight fetches the caller-supplied third-party URL to read its unpaid 402. The drift check uses only the intent (optional), unsigned transaction, EIP-712 payload, or EIP-7702 authorization you send. Simulation also reads the latest public chain state. No social scraping, no private data.

### Is this a compliance tool?
No. The sanctions screen is an exact address match against OFAC's crypto address entries. It is a fast first check, not a compliance program, and not legal or compliance advice.

### Does no match mean clean?
No. No match does not mean clean. The screen only matches addresses OFAC lists; it does not look at names, owners, indirect links, history or non US lists. Each result shows the list date and how old our copy is, and we refresh our copy from OFAC once a day.

### Does it simulate transactions or catch changed parameters?
Both. POST /v1/drift ($0.005) with an intent compares it to the exact unsigned transaction or typed data and answers match, drift or cannot_verify; a match only means the two agree, not that the intent was safe. Without an intent it decodes the payload and returns factual risk_flags (Permit, Permit2, DAI permit, CoW Order, Seaport OrderComponents, EIP-7702). POST /v1/simulate ($0.01) dry runs the unsigned transaction on Base or Ethereum and shows success or revert, gas, balance changes, approvals and warnings. A simulation is a point in time dry run, not a guarantee of the outcome.

### Do you track transactions after they are signed?
No, on purpose. Meridian is the check before signing. Tracking after signing is a different job.

### Which chains?
Payment is USDC on Base. The Aave, vault and passport checks read Base or Ethereum, and the Lido check reads Ethereum. Simulation runs on Base or Ethereum.

### What if I paid and the call failed?
If you were charged and got a server error or no response, email corp@miodiollc.com within 30 days with the tx hash, route and time for a refund or credit. Duplicate payments are refunded on request. You can first check for free with GET /v1/payment/status?tx=<hash>, which covers payments to Meridian only. To check any USDC payment on Base, use POST /v1/payment-check ($0.005).

### How do I verify a receipt?
A paid 2xx response includes a signed Meridian-Receipt header when receipt signing is configured. Check it against the public keys at /.well-known/meridian-receipt-keys.json, or look it up at /v1/receipt/<id> for 30 days; step by step instructions are on /docs and a ready made checking script is at /receipt-verify.ts. Treat the receipt id like a password. For full proof, also confirm the USDC payment on Base.

## Paid routes (same catalog as /.well-known/x402)
- GET /v1/risk/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian Aave v3 risk card for an EVM address: health factor, collateral, debt and liquidation distance (~$0.005 USDC Exact on Base). Errors: 400 invalid_address or unsupported_chain (chain must be base or ethereum), 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/risk/0x0000000000000000000000000000000000000001.
- GET /v1/lido/exit-risk — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian Lido exit-risk card: stETH/ETH Curve peg, withdrawal-queue ETA and exit liquidity for a stETH amount (~$0.005 USDC Exact on Base). Errors: 400 amount_required or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/lido/exit-risk?amount=32.
- GET /v1/vault/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian ERC-4626 vault risk card: share price, drawdown, APY lookback and idle cash for one vault (~$0.005 USDC Exact on Base). Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/vault/0xc1256Ae5FF1cf2719D4937adb3bbCCab2E00A2Ca.
- GET /v1/passport/:address — ~$0.02 USDC Exact (20000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian deep passport: one decision card joining Aave v3, Lido exit and optional ERC-4626 vault reads for an EVM address (~$0.02 USDC Exact on Base). Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required. An upstream RPC failure is a charged 200 with status partial/error. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/passport/0x0000000000000000000000000000000000000001.
- GET /v1/sanctions/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian OFAC SDN screen: exact match of one digital-currency address against public SDN Digital Currency Address entries (~$0.005 USDC Exact on Base). Informational only. Errors: 400 invalid_address or unsupported_chain, 402 payment required, 503 sanctions_list_unavailable when the SDN index or meta is missing (not settled). Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/sanctions/0x0000000000000000000000000000000000000001.
- GET /v1/passport-sanctions/:address — ~$0.02 USDC Exact (20000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian bundle: deep passport plus OFAC SDN exact-match (~$0.02 USDC Exact on Base). Informational only. Errors: 400 invalid_address, unsupported_chain or invalid_amount, 402 payment required, 503 sanctions_list_unavailable when the SDN list cannot be loaded (not settled). Passport RPC failure is a charged 200 partial. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/passport-sanctions/0x0000000000000000000000000000000000000001.
- POST /v1/sanctions/batch — ~$0.10 USDC Exact (100000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian OFAC SDN batch screen: exact match of 1-50 digital-currency addresses against public SDN entries (~$0.10 USDC Exact on Base). Informational only. Errors: 400 invalid_body, invalid_address or unsupported_chain, 402 payment required, 503 sanctions_list_unavailable when the SDN list is missing (not settled). Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/drift — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian signature decoder (~$0.005 USDC Exact on Base). With intent: match / drift / cannot_verify vs the unsigned tx or EIP-712 payload. Without intent: decode Permit, Permit2, DAI, CoW, Seaport or EIP-7702 and return risk_flags. Unknown primaryType is UNDECODED_CAUTION. A match is not a guarantee. Errors: 400 invalid_body or unsupported_chain, 402 payment required. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/simulate — ~$0.01 USDC Exact (10000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian transaction simulation: dry-run of an unsigned tx on Base/Ethereum (~$0.01 USDC Exact on Base). Success or revert, gas, balances, approvals. Simulation is a point-in-time dry run, not a guarantee. Never signs or moves funds. Errors: 400 invalid_body or unsupported_chain, 402 payment required. RPC fail is a charged 200 partial. Unexpected Worker 5xx is not charged. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- POST /v1/payment-check — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian payment-check: on-chain read of a Base USDC Exact authorization or Transfer (~$0.005 USDC Exact). Reports nonce used, matching transfers in a ≤120 minute window, and confirmations. Informational. 503 and not settled if every read fails. Never signs or moves funds. Errors: 400 invalid_body, 402 payment required, 503 upstream_unavailable. MioDio x402 DeFi. Terms: https://meridian.miodiollc.com/terms
- GET /v1/recipient/:address — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. Recipient readiness: Base vs Ethereum code, EIP-7702 vs known-wallet allowlist (unknown if unlisted; never safe), USDC freeze Base+Eth, USDT freeze Eth only, OFAC exact match, burn/token flags, optional address-poisoning (lookalike) with counterparties/from (~$0.005 Exact). Not advice. 400 invalid_address/unsupported_chain/query_too_long; unpaid 402; partial 200; both-chain fail 503 not settled. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/recipient/0x0000000000000000000000000000000000000001.
- GET /v1/x402-preflight — ~$0.005 USDC Exact (5000 atomic), network eip155:8453. Pre-sign check: agents call Meridian before they sign. MioDio Meridian x402 seller preflight (~$0.005 USDC Exact on Base). Informational, not advice. 400 invalid_url after pay (no settle); 402 unpaid before validation. Unreachable (DNS, timeout, connection refused, TLS failure): 503 upstream_unavailable, not charged. Any HTTP response from the target (500, 404, 302, 200 with no 402, oversize body) is a charged 200 with status partial or parsed result. Terms: https://meridian.miodiollc.com/terms Example unpaid URL: GET /v1/x402-preflight?url=https://www.example.com/.

## Operator
MioDio LLC, corp@miodiollc.com, 755 Monroe Rd, Unit 470067, Sanford, FL 32747 (Florida LLC)
- Docs: https://meridian.miodiollc.com/docs
- Short summary: https://meridian.miodiollc.com/llms.txt