Governance preflights for AI agents before consequential actions.

# 1 — ask for the price. Free, and it costs you nothing to try right now.
curl -sS -i -X POST https://agentnomos.com/xrpl-agentic-payments/api/x402/preflight \
  -H 'content-type: application/json' \
  -d '{"intent":{"network":"xrpl:0",
        "destination":"rhteihAJz1KsY6GpWPEc9Jo1W9qrqg1z1i",
        "amount":"5000",
        "invoice_id":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
        "source_tag":1}}'

# -> HTTP/1.1 402 Payment Required
#   accepts[0] = { "scheme":"exact", "network":"xrpl:0", "asset":"XRP",
#                  "amount":"1000", "payTo":"rhtei…z1i", "maxTimeoutSeconds":600,
#                  "extra":{ "invoiceId":"…", "sourceTag":804681468 } }
#
# The intent above is the payment you are ASKING ABOUT — destination, amount and
# source_tag are yours and are echoed back untouched. The 1000 drops in accepts[]
# are the fee for the check itself. Two different payments; never conflate them.

# 2 — pay those 1000 drops on XRPL and build the payload (see Python / TypeScript)

# 3 — same request, now with the proof
curl -sS -i -X POST https://agentnomos.com/xrpl-agentic-payments/api/x402/preflight \
  -H 'content-type: application/json' \
  -H "X-PAYMENT: $PAYMENT" \
  -d "$INTENT"

# -> HTTP/1.1 200 OK
#   PAYMENT-RESPONSE: base64({"network","payer","success","transaction"})
#   body: { "decision": "ALLOW" | "REVIEW" | "BLOCK", …, "receipt": { … } }

# The cross-border endpoint speaks the same protocol, different body:
curl -sS -i -X POST https://agentnomos.com/api/x402/cross-border-preflight \
  -H 'content-type: application/json' \
  -d '{"source_regime":"EU","target_regime":"US",
        "data_category":"personal_data","max_results":1}'

# pip install xrpl-py requests
import base64, hashlib, json, math, requests
from xrpl.clients import JsonRpcClient
from xrpl.wallet import Wallet
from xrpl.models.transactions import Payment, Memo
from xrpl.transaction import autofill_and_sign
from xrpl.core.binarycodec import encode
from xrpl.models.requests import Ledger

ENDPOINT = "https://agentnomos.com/xrpl-agentic-payments/api/x402/preflight"
INTENT = {"intent": {"network": "xrpl:0",
                     "destination": "rhteihAJz1KsY6GpWPEc9Jo1W9qrqg1z1i",
                     "amount": "5000",
                     "invoice_id": "A" * 64,
                     "source_tag": 1}}

# -- 1. free request -> the 402 challenge ------------------------------
r = requests.post(ENDPOINT, json=INTENT, timeout=30)
assert r.status_code == 402, r.status_code
acc = r.json()["accepts"][0]
invoice_id = acc["extra"]["invoiceId"]

# -- 2. bind an XRPL payment to that invoice, sign it locally ---------
#      InvoiceID = sha256(invoiceId) ; memo = hex(invoiceId). Both are required.
client = JsonRpcClient("https://xrplcluster.com")
wallet = Wallet.from_seed("sEd…")          # your seed. It stays here.
latest = client.request(Ledger(ledger_index="validated")).result["ledger_index"]

tx = Payment(
    account=wallet.classic_address,
    destination=acc["payTo"],
    amount=acc["amount"],                                # "1000" drops, a string
    source_tag=acc["extra"]["sourceTag"],                 # the facilitator's, not yours
    invoice_id=hashlib.sha256(invoice_id.encode()).hexdigest().upper(),
    memos=[Memo(memo_data=invoice_id.encode().hex().upper())],
    last_ledger_sequence=latest + math.ceil(acc["maxTimeoutSeconds"] / 5) + 2,
)
signed = autofill_and_sign(tx, client, wallet)
blob = encode(signed.to_xrpl())

# -- 3. same request, now with the proof ------------------------------
payload = {"x402Version": 2,
           "accepted": {k: acc[k] for k in ("scheme", "network", "amount", "asset",
                                            "payTo", "maxTimeoutSeconds", "extra")},
           "payload": {"invoiceId": invoice_id, "signedTxBlob": blob}}
header = base64.b64encode(
    json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).decode()

r = requests.post(ENDPOINT, json=INTENT, headers={"X-PAYMENT": header}, timeout=90)
out = r.json()

# -- 4. the only line that matters ------------------------------------
if out.get("decision") != "ALLOW":
    raise SystemExit(f"not signing: {out.get('decision')} {out.get('reason_codes')}")
# … only now build and sign the payment you actually intended to make.

// npm i xrpl
import { Client, Wallet, encode } from "xrpl";
import { createHash } from "node:crypto";

const ENDPOINT = "https://agentnomos.com/xrpl-agentic-payments/api/x402/preflight";
const INTENT = { intent: { network: "xrpl:0",
                          destination: "rhteihAJz1KsY6GpWPEc9Jo1W9qrqg1z1i",
                          amount: "5000",
                          invoice_id: "A".repeat(64),
                          source_tag: 1 } };
const post = (h = {}) => fetch(ENDPOINT, { method: "POST",
  headers: { "content-type": "application/json", ...h },
  body: JSON.stringify(INTENT) });

// -- 1. free request -> the 402 challenge ------------------------------
const challenge = await post();
if (challenge.status !== 402) throw new Error(`expected 402, got ${challenge.status}`);
const acc = (await challenge.json()).accepts[0];
const invoiceId: string = acc.extra.invoiceId;

// -- 2. bind an XRPL payment to that invoice, sign it locally ---------
const client = new Client("wss://xrplcluster.com");
await client.connect();
const wallet = Wallet.fromSeed("sEd…");            // your seed. It stays here.
const latest = await client.getLedgerIndex();

const prepared = await client.autofill({
  TransactionType: "Payment",
  Account: wallet.classicAddress,
  Destination: acc.payTo,
  Amount: acc.amount,                                // "1000" drops, a string
  SourceTag: acc.extra.sourceTag,                    // the facilitator's, not yours
  InvoiceID: createHash("sha256").update(invoiceId).digest("hex").toUpperCase(),
  Memos: [{ Memo: { MemoData: Buffer.from(invoiceId).toString("hex").toUpperCase() } }],
  LastLedgerSequence: latest + Math.ceil(acc.maxTimeoutSeconds / 5) + 2,
});
const { tx_blob } = wallet.sign(prepared);
await client.disconnect();

// -- 3. same request, now with the proof.
//      Keys sorted, no spaces — the header is canonical JSON.
const payload = { accepted: Object.fromEntries(
    ["scheme", "network", "amount", "asset", "payTo", "maxTimeoutSeconds", "extra"]
      .map(k => [k, acc[k]])),
  payload: { invoiceId, signedTxBlob: tx_blob },
  x402Version: 2 };
const canon = (v: any): string => Array.isArray(v) ? `[${v.map(canon).join(",")}]`
  : v && typeof v === "object"
    ? `{${Object.keys(v).sort().map(k => JSON.stringify(k) + ":" + canon(v[k])).join(",")}}`
    : JSON.stringify(v);
const header = Buffer.from(canon(payload)).toString("base64");

const out = await (await post({ "X-PAYMENT": header })).json();

// -- 4. the only line that matters ------------------------------------
if (out.decision !== "ALLOW") {
  throw new Error(`not signing: ${out.decision} ${out.reason_codes}`);
}
// … only now build and sign the payment you actually intended to make.