@piprail/sdk 2.15.0 → 2.16.0

package/dist/{tron-42X5N4GQ.cjs → tron-HIPMOX7S.cjs}

@@ -10,7 +10,7 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunk3FR22M3Ocjs = require('./chunk-3FR22M3O.cjs');
+var _chunkQONQSZHJcjs = require('./chunk-QONQSZHJ.cjs');
 
 // src/drivers/tron/index.ts
 var _tronweb = require('tronweb');
@@ -62,7 +62,7 @@ async function payTron(params) {
       return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _7 => _7.transaction, 'optionalAccess', _8 => _8.txID]))), () => ( signed.txID));
     }
     if (isTronAffordability(broadcast.code, broadcast.message)) {
-      throw new (0, _chunk3FR22M3Ocjs.InsufficientFundsError)(
+      throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
         `Tron payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for energy/bandwidth, or insufficient token balance.`
       );
     }
@@ -70,15 +70,15 @@ async function payTron(params) {
       `Tron broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunk3FR22M3Ocjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunk3FR22M3Ocjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunkQONQSZHJcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunkQONQSZHJcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 async function payTronNative(params) {
   const { client, from, privateKey, accept } = params;
   const sun = BigInt(accept.amount);
   if (sun > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new (0, _chunk3FR22M3Ocjs.InsufficientFundsError)(
+    throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
       `Tron native amount ${accept.amount} sun exceeds the safe-integer range tronweb.sendTrx accepts \u2014 price this resource in a smaller native amount or a TRC-20 token.`
     );
   }
@@ -90,7 +90,7 @@ async function payTronNative(params) {
       return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _11 => _11.transaction, 'optionalAccess', _12 => _12.txID]))), () => ( signed.txID));
     }
     if (isTronAffordability(broadcast.code, broadcast.message)) {
-      throw new (0, _chunk3FR22M3Ocjs.InsufficientFundsError)(
+      throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
         `Tron TRX payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for the amount plus bandwidth (and the ~1 TRX account-creation fee if the recipient is new).`
       );
     }
@@ -98,8 +98,8 @@ async function payTronNative(params) {
       `Tron TRX broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunk3FR22M3Ocjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunk3FR22M3Ocjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunkQONQSZHJcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunkQONQSZHJcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 function decodeMaybeHex(message) {
@@ -273,13 +273,13 @@ function txNotFound(txid) {
 // src/drivers/tron/wallet.ts
 function assertTronWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { key } (32-byte hex).`
     );
   }
-  _chunk3FR22M3Ocjs.assertNoLegacyWalletKey.call(void 0, wallet, "Tron");
+  _chunkQONQSZHJcjs.assertNoLegacyWalletKey.call(void 0, wallet, "Tron");
   if (!("key" in wallet)) {
-    throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { key } (32-byte hex).`
     );
   }
@@ -287,14 +287,14 @@ function assertTronWallet(wallet, network) {
 }
 function resolveTronPrivateKey(config) {
   if (!config.key) {
-    throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)("Tron wallet needs { key } (32-byte hex).");
+    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet needs { key } (32-byte hex).");
   }
   if (typeof config.key !== "string") {
-    throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)("Tron wallet { key } must be a 32-byte hex string.");
+    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet { key } must be a 32-byte hex string.");
   }
   const hex = config.key.replace(/^0x/i, "").toLowerCase();
   if (!/^[0-9a-f]{64}$/.test(hex)) {
-    throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
       "Tron wallet { key } must be a 32-byte hex string (64 hex chars)."
     );
   }
@@ -344,21 +344,21 @@ function makeTronNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunk3FR22M3Ocjs.UnknownTokenError)(
+          throw new (0, _chunkQONQSZHJcjs.UnknownTokenError)(
             `token "${token}" isn't built in for Tron (known: ${known}). Note: native USDC doesn't exist on Tron. Pass { address, decimals } for a custom TRC-20.`
           );
         }
         return { asset: info.address, decimals: info.decimals, symbol: info.symbol };
       }
-      _chunk3FR22M3Ocjs.rejectForeignToken.call(void 0, token, "tron", network);
+      _chunkQONQSZHJcjs.rejectForeignToken.call(void 0, token, "tron", network);
       if (!("address" in token)) {
-        throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
           `chain ${network} is Tron; a custom token must be { address, decimals } (Base58 T\u2026 contract).`
         );
       }
       const t = token;
       if (t.address.startsWith("0x") || !tronWeb.isAddress(t.address)) {
-        throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
           `chain ${network} is Tron, but token address "${t.address}" is not a valid Tron contract (T\u2026).`
         );
       }
@@ -377,12 +377,12 @@ function makeTronNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       if (!tronWeb.isAddress(payTo)) {
-        throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)(
+        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" is not a valid Tron address (T\u2026).`
         );
       }
@@ -394,7 +394,7 @@ function makeTronNetwork(preset, rpcUrl) {
       const privateKey = resolveTronPrivateKey(wallet._native);
       const from = tronWeb.address.fromPrivateKey(privateKey);
       if (!from) {
-        throw new (0, _chunk3FR22M3Ocjs.WrongFamilyError)("Tron wallet { key } could not derive an address.");
+        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet { key } could not derive an address.");
       }
       if (accept.asset === "native") {
         return payTronNative({ client: tronWeb, from, privateKey, accept });
@@ -417,11 +417,11 @@ function makeTronNetwork(preset, rpcUrl) {
         }
         await _chunkCQREG5LEcjs.delay.call(void 0, 2500);
       }
-      throw new (0, _chunk3FR22M3Ocjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
+      throw new (0, _chunkQONQSZHJcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
     },
     async estimateCost(accept, opts) {
       if (accept.asset === "native") {
-        return _chunk3FR22M3Ocjs.nativeCost.call(void 0, {
+        return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
           symbol: "TRX",
           decimals: TRX_DECIMALS,
           fee: 1300000n,
@@ -445,7 +445,7 @@ function makeTronNetwork(preset, rpcUrl) {
           );
           const energy = BigInt(_nullishCoalesce(r.energy_used, () => ( 0)));
           if (energy > 0n) {
-            return _chunk3FR22M3Ocjs.nativeCost.call(void 0, {
+            return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
               symbol: "TRX",
               decimals: TRX_DECIMALS,
               fee: energy * ENERGY_PRICE + BANDWIDTH_SUN,
@@ -456,7 +456,7 @@ function makeTronNetwork(preset, rpcUrl) {
         } catch (e8) {
         }
       }
-      return _chunk3FR22M3Ocjs.nativeCost.call(void 0, {
+      return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
         symbol: "TRX",
         decimals: TRX_DECIMALS,
         fee: 30000n * ENERGY_PRICE + BANDWIDTH_SUN,

package/dist/{xrpl-Q2UWPCTJ.js → xrpl-RUOB37QH.js}

@@ -1,3 +1,7 @@
+import {
+  exactTransferMethod
+} from "./chunk-C52H5TYB.js";
+import "./chunk-2CX7XRZK.js";
 import {
   delay
 } from "./chunk-FURB5RP7.js";
@@ -5,14 +9,16 @@ import {
   ConfirmationTimeoutError,
   InsufficientFundsError,
   RecipientNotReadyError,
+  SettlementError,
   UnknownTokenError,
+  UnsupportedSchemeError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
   floorUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-3ZWM3DKM.js";
+} from "./chunk-QU25LSVS.js";
 
 // src/drivers/xrpl/index.ts
 import { isValidClassicAddress } from "xrpl";
@@ -48,8 +54,11 @@ var XRPL_MAINNET = {
 function xrplAssetId(currencyHex, issuer) {
   return `${currencyHex}:${issuer}`;
 }
+function isXrpNative(asset) {
+  return asset === "native" || asset === "XRP";
+}
 function parseXrplAssetId(asset) {
-  if (asset === "native") return null;
+  if (isXrpNative(asset)) return null;
   const i = asset.indexOf(":");
   if (i <= 0 || i === asset.length - 1) return null;
   return { currencyHex: asset.slice(0, i), issuer: asset.slice(i + 1) };
@@ -141,6 +150,216 @@ function isAffordabilityCode(code) {
   return /^(tecUNFUNDED|tecINSUFF|terINSUF)/.test(code);
 }
 
+// src/drivers/xrpl/exact.ts
+import { createHash } from "crypto";
+var SECONDS_PER_LEDGER = 4;
+var MIN_LEDGER_WINDOW = 5;
+var MAX_LEDGER_WINDOW = 60;
+function ledgerWindowFor(maxTimeoutSeconds) {
+  const secs = Number.isFinite(maxTimeoutSeconds) && maxTimeoutSeconds > 0 ? maxTimeoutSeconds : 60;
+  const ledgers = Math.floor(secs / SECONDS_PER_LEDGER);
+  return Math.min(MAX_LEDGER_WINDOW, Math.max(MIN_LEDGER_WINDOW, ledgers));
+}
+var MIN_FEE_DROPS = 12;
+var MAX_FEE_DROPS = 1e6;
+var TF_FULLY_CANONICAL_SIG = 2147483648;
+var TF_PARTIAL_PAYMENT = 131072;
+function feesAreSponsored(accept) {
+  return accept.extra?.areFeesSponsored === true;
+}
+function invoiceIdHash(invoiceId) {
+  return createHash("sha256").update(invoiceId, "utf8").digest("hex").toUpperCase();
+}
+function feeForSubmit2(openLedgerFee) {
+  const fee = Number(openLedgerFee);
+  const chosen = Number.isFinite(fee) && fee > MIN_FEE_DROPS ? Math.ceil(fee) : MIN_FEE_DROPS;
+  return String(Math.min(chosen, MAX_FEE_DROPS));
+}
+async function payExactXrpl(input) {
+  const { client, wallet, accept } = input;
+  if (!isXrpNative(accept.asset)) {
+    throw new UnsupportedSchemeError(
+      `XRPL exact currently signs native XRP only \u2014 ${accept.asset} is an issued currency, whose wire amount is a decimal rather than base units and would misprice the spend cap. Pay it via onchain-proof.`
+    );
+  }
+  if (feesAreSponsored(accept)) {
+    throw new UnsupportedSchemeError(
+      "XRPL exact rail advertises areFeesSponsored:true, but the XRP Ledger charges the fee to the transaction Account \u2014 the scheme requires false and PipRail cannot honour a sponsor here."
+    );
+  }
+  const method = exactTransferMethod(accept, "xrpl");
+  if (method !== "sequence") {
+    throw new UnsupportedSchemeError(
+      `XRPL exact: unsupported assetTransferMethod "${method}". Only "sequence" is signable \u2014 "ticketSequence" needs a Ticket pre-minted on the payer account, which PipRail does not manage.`
+    );
+  }
+  if (!/^[0-9]+$/.test(accept.amount)) {
+    throw new UnsupportedSchemeError(
+      `XRPL exact: native amount "${accept.amount}" is not an integer drops string.`
+    );
+  }
+  let sequence;
+  let openLedgerFee;
+  let ledgerIndex;
+  try {
+    ;
+    [sequence, openLedgerFee, ledgerIndex] = await Promise.all([
+      client.accountSequence(wallet.classicAddress),
+      client.feeDrops(),
+      client.currentLedgerIndex()
+    ]);
+  } catch (err) {
+    if (/actNotFound/i.test(String(err?.message ?? err))) {
+      throw new InsufficientFundsError(
+        `XRPL exact: the payer account ${wallet.classicAddress} does not exist on the ledger. An XRPL account must hold the base reserve (currently 1 XRP) before it can send anything \u2014 fund it first.`,
+        { cause: err instanceof Error ? err : new Error(String(err)) }
+      );
+    }
+    throw err;
+  }
+  const tx = {
+    TransactionType: "Payment",
+    Account: wallet.classicAddress,
+    Destination: accept.payTo,
+    Amount: accept.amount,
+    // integer drops, verbatim from the trusted accept
+    Sequence: sequence,
+    Fee: feeForSubmit2(openLedgerFee),
+    LastLedgerSequence: ledgerIndex + ledgerWindowFor(accept.maxTimeoutSeconds),
+    // tfFullyCanonicalSig ON, tfPartialPayment OFF — the shape every other XRPL client sends.
+    Flags: TF_FULLY_CANONICAL_SIG
+  };
+  if (typeof accept.extra?.destinationTag === "number") {
+    tx.DestinationTag = accept.extra.destinationTag;
+  }
+  if (typeof accept.extra?.sourceTag === "number") {
+    tx.SourceTag = accept.extra.sourceTag;
+  }
+  if (typeof accept.extra?.invoiceId === "string" && accept.extra.invoiceId.length > 0) {
+    tx.InvoiceID = invoiceIdHash(accept.extra.invoiceId);
+  }
+  let signed;
+  try {
+    signed = wallet.sign(tx);
+  } catch (err) {
+    throw new UnsupportedSchemeError(
+      `XRPL exact: could not sign this rail \u2014 ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err instanceof Error ? err : new Error(String(err)) }
+    );
+  }
+  return {
+    payload: { signedTxBlob: signed.tx_blob },
+    accepted: accept,
+    payerFrom: wallet.classicAddress,
+    // The tx hash is the natural single-use key: the ledger itself enforces one settlement per
+    // (account, sequence), so a replay can never move funds twice even if a gate forgot to dedupe.
+    nonce: signed.hash
+  };
+}
+var fail = (error, detail) => ({ ok: false, error, detail });
+async function verifyAndSettleExactXrpl(input) {
+  const { client, decode, payload, accept } = input;
+  const attempts = input.pollAttempts ?? 8;
+  const sleep = input.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  if (feesAreSponsored(accept)) {
+    throw new SettlementError("XRPL exact: rail advertises areFeesSponsored:true, which this ledger cannot honour.");
+  }
+  let tx;
+  try {
+    tx = decode(payload.signedTxBlob);
+  } catch (err) {
+    return fail("signature_invalid", `XRPL exact: undecodable tx blob (${err instanceof Error ? err.message : String(err)}).`);
+  }
+  if (tx.TransactionType !== "Payment") {
+    return fail("signature_invalid", `XRPL exact: expected a Payment, got ${String(tx.TransactionType)}.`);
+  }
+  if (tx.Memos !== void 0) return fail("signature_invalid", "XRPL exact: Memos are rejected by the scheme.");
+  if (tx.Delegate !== void 0) return fail("signature_invalid", "XRPL exact: Delegate is rejected by the scheme.");
+  if (tx.Paths !== void 0) return fail("signature_invalid", "XRPL exact: Paths must be omitted.");
+  if (tx.DeliverMin !== void 0) return fail("signature_invalid", "XRPL exact: DeliverMin must be omitted.");
+  if (tx.Amount !== void 0 && tx.DeliverMax !== void 0) {
+    return fail("signature_invalid", "XRPL exact: Amount and DeliverMax must not both be present.");
+  }
+  if (typeof tx.Flags === "number" && (tx.Flags & TF_PARTIAL_PAYMENT) !== 0) {
+    return fail("signature_invalid", "XRPL exact: tfPartialPayment is rejected.");
+  }
+  if (typeof tx.LastLedgerSequence !== "number") {
+    return fail("signature_invalid", "XRPL exact: LastLedgerSequence must be present.");
+  }
+  if (!tx.TxnSignature && !tx.Signers) {
+    return fail("signature_invalid", "XRPL exact: the transaction is not signed.");
+  }
+  if (tx.Destination !== accept.payTo) {
+    return fail("wrong_recipient", `XRPL exact: pays ${String(tx.Destination)}, not payTo ${accept.payTo}.`);
+  }
+  if (tx.Amount !== accept.amount) {
+    return fail("amount_too_low", `XRPL exact: Amount ${String(tx.Amount)} \u2260 the rail's ${accept.amount} drops.`);
+  }
+  if (typeof accept.extra?.destinationTag === "number" && tx.DestinationTag !== accept.extra.destinationTag) {
+    return fail("signature_invalid", `XRPL exact: DestinationTag ${String(tx.DestinationTag)} \u2260 the rail's ${accept.extra.destinationTag}.`);
+  }
+  if (typeof accept.extra?.invoiceId === "string" && accept.extra.invoiceId.length > 0) {
+    const want = invoiceIdHash(accept.extra.invoiceId);
+    if (String(tx.InvoiceID ?? "").toUpperCase() !== want) {
+      return fail("signature_invalid", "XRPL exact: InvoiceID does not bind this challenge.");
+    }
+  }
+  const feeDrops = Number(tx.Fee);
+  if (!Number.isFinite(feeDrops) || feeDrops < 0 || feeDrops > MAX_FEE_DROPS) {
+    return fail("signature_invalid", `XRPL exact: implausible Fee ${String(tx.Fee)} drops.`);
+  }
+  let hash;
+  try {
+    const res = await client.submit(payload.signedTxBlob);
+    if (!res.engine_result.startsWith("tes") && !res.engine_result.startsWith("ter")) {
+      return fail(
+        "transfer_not_found",
+        `XRPL exact: submit rejected \u2014 ${res.engine_result}${res.engine_result_message ? ` (${res.engine_result_message})` : ""}.`
+      );
+    }
+    hash = res.tx_json?.hash ?? "";
+    if (!hash) throw new Error("submit returned no transaction hash");
+  } catch (err) {
+    throw new SettlementError(`XRPL exact: submit failed (${err instanceof Error ? err.message : String(err)}).`);
+  }
+  for (let i = 0; i < attempts; i += 1) {
+    let record;
+    try {
+      record = await client.txByHash(hash);
+    } catch {
+      record = null;
+    }
+    if (record?.validated) {
+      const code = record.meta?.TransactionResult;
+      if (code !== "tesSUCCESS") {
+        return fail("transfer_not_found", `XRPL exact: validated with ${String(code)}, not tesSUCCESS.`);
+      }
+      const delivered = record.meta?.delivered_amount;
+      if (delivered !== void 0 && typeof delivered === "string" && delivered !== accept.amount) {
+        return fail("amount_too_low", `XRPL exact: delivered ${delivered} drops, expected ${accept.amount}.`);
+      }
+      return {
+        ok: true,
+        receipt: {
+          scheme: "exact",
+          success: true,
+          network: accept.network,
+          transaction: hash,
+          asset: accept.asset,
+          amount: accept.amount,
+          payer: String(record.Account ?? tx.Account ?? ""),
+          payTo: accept.payTo,
+          verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+    await sleep(1200);
+  }
+  throw new SettlementError(
+    `XRPL exact: submitted ${hash} but it was not validated within ${attempts} polls. It may still settle; retry the request.`
+  );
+}
+
 // src/drivers/xrpl/verify.ts
 var RIPPLE_EPOCH_OFFSET = 946684800;
 async function verifyXrpl(params) {
@@ -325,6 +544,16 @@ function makeXrplNetwork(preset, rpcUrl) {
       return rpc("submit", { tx_blob: txBlob });
     }
   };
+  const exactSettleClient = {
+    submit: (txBlob) => payClient.submit(txBlob),
+    async txByHash(hash) {
+      try {
+        return await rpc("tx", { transaction: hash, binary: false });
+      } catch {
+        return null;
+      }
+    }
+  };
   const reader = {
     async transactionsForAccount(account, limit) {
       const r = await rpc("account_tx", {
@@ -373,7 +602,7 @@ function makeXrplNetwork(preset, rpcUrl) {
       };
     },
     describeAsset(asset) {
-      if (asset === "native") return { symbol: XRP_SYMBOL, decimals: XRP_DECIMALS };
+      if (isXrpNative(asset)) return { symbol: XRP_SYMBOL, decimals: XRP_DECIMALS };
       for (const info of Object.values(preset.tokens)) {
         if (xrplAssetId(info.currencyHex, info.issuer) === asset) {
           return { symbol: info.symbol, decimals: info.decimals };
@@ -400,6 +629,55 @@ function makeXrplNetwork(preset, rpcUrl) {
       const w = resolveXrplWallet(wallet._native);
       return payXrpl({ client: payClient, wallet: w, accept });
     },
+    /*
+     * ── Standard x402 `exact` rail (scheme_exact_xrpl.md) ───────────────────────────
+     * XRPL is the family where the PAYER pays the fee, so there is no sponsor to wire: the buyer
+     * signs a complete `Payment` and the merchant simply submits it. See drivers/xrpl/exact.ts for
+     * why the binding is `InvoiceID` (never a memo) and why only native XRP is exact-payable today.
+     */
+    // Native XRP only. An issued currency states its amount as a DECIMAL on the wire while the SDK
+    // prices and spend-caps in base units — signing one would let a 12-RLUSD rail pass a cap set in
+    // base units. Dropping it here means the gather skips it, rather than planning `payable` and
+    // throwing at signing time.
+    exactPayableAsset: (asset) => isXrpNative(asset),
+    async payExact(wallet, accept) {
+      const w = resolveXrplWallet(wallet._native);
+      return payExactXrpl({ client: payClient, wallet: w, accept });
+    },
+    // The gate advertises the rail. No `feePayer` and no sponsor key: uniquely on XRPL the buyer's
+    // own signed transaction carries its fee, so settlement is a bare submit.
+    //
+    // NB `server.ts` still requires a `relayer` for `settle: 'self'` — an unconditional config
+    // guard, and correctly chain-agnostic, so it cannot special-case XRPL. The relayer is accepted
+    // and then ignored here. Making it optional needs a driver-declared capability flag (the same
+    // shape as `exactPermit2Supported`); worth doing, since an XRPL merchant currently has to hand
+    // the gate a key it never uses, but it is a separate change from the buyer this rail is for.
+    async resolveExactRail({ asset }) {
+      if (asset !== "native") return null;
+      return {
+        method: "sequence",
+        // `areFeesSponsored` is REQUIRED by the scheme and must be false; we emit it explicitly
+        // even though no deployed rail does, because emitting the conformant shape costs nothing
+        // and a strict third-party buyer may look for it. (Our own buyer reads it as false when
+        // absent — requiring it would have rejected the entire deployed XRPL web.)
+        extra: { areFeesSponsored: false }
+      };
+    },
+    // SELLER side — decode + check the buyer's blob against the trusted accept, submit it, and wait
+    // for a validated tesSUCCESS. `relayer` is accepted for signature-compatibility with the other
+    // families and deliberately unused: the payer already paid the fee inside the signed blob.
+    async settleExactSelf({ payload, accept }) {
+      if (!("signedTxBlob" in payload)) {
+        return { ok: false, error: "signature_invalid", detail: "XRPL exact expects a { signedTxBlob } payload." };
+      }
+      const { decode } = await import("xrpl");
+      return verifyAndSettleExactXrpl({
+        client: exactSettleClient,
+        decode: (blob) => decode(blob),
+        payload,
+        accept
+      });
+    },
     async confirm(ref) {
       for (let i = 0; i < 12; i += 1) {
         try {
@@ -452,7 +730,7 @@ function makeXrplNetwork(preset, rpcUrl) {
       } catch (e) {
         native = isXrplActNotFound(e) ? 0n : null;
       }
-      if (asset === "native") return { token: native, native };
+      if (isXrpNative(asset)) return { token: native, native };
       let token = null;
       try {
         const [currencyHex, issuer] = asset.split(":");
@@ -476,7 +754,7 @@ function makeXrplNetwork(preset, rpcUrl) {
         if (isXrplActNotFound(e)) return { ready: false, reason: "INACTIVE" };
         return { ready: "unknown" };
       }
-      if (asset === "native") return { ready: true };
+      if (isXrpNative(asset)) return { ready: true };
       try {
         const [currencyHex, issuer] = asset.split(":");
         const r = await rpc("account_lines", {