@piprail/sdk 2.15.1 → 2.16.1

package/dist/{solana-S2T3JNR7.cjs → solana-AI2G7V33.cjs}

@@ -229,14 +229,24 @@ var MAX_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 100000n;
 var CB_SET_UNIT_LIMIT = 2;
 var CB_SET_UNIT_PRICE = 3;
 function tokenProgramFor(accept) {
-  return accept.extra.tokenProgram === "token-2022" ? _spltoken.TOKEN_2022_PROGRAM_ID : _spltoken.TOKEN_PROGRAM_ID;
+  return _optionalChain([accept, 'access', _3 => _3.extra, 'optionalAccess', _4 => _4.tokenProgram]) === "token-2022" ? _spltoken.TOKEN_2022_PROGRAM_ID : _spltoken.TOKEN_PROGRAM_ID;
+}
+async function readMintDecimals(connection, mint) {
+  try {
+    const info = await connection.getAccountInfo(mint);
+    const data = _optionalChain([info, 'optionalAccess', _5 => _5.data]);
+    if (!data || data.length < 45) return void 0;
+    return data[44];
+  } catch (e3) {
+    return void 0;
+  }
 }
 function isEmptySig(sig) {
   return !sig || sig.every((b) => b === 0);
 }
 function memoRandomNonce() {
   const g = globalThis.crypto;
-  if (!_optionalChain([g, 'optionalAccess', _3 => _3.getRandomValues])) {
+  if (!_optionalChain([g, 'optionalAccess', _6 => _6.getRandomValues])) {
     throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)(
       "this runtime lacks Web Crypto (globalThis.crypto.getRandomValues); SVM exact needs a CSPRNG nonce."
     );
@@ -246,7 +256,7 @@ function memoRandomNonce() {
   return Buffer.from([...raw].map((b) => b.toString(16).padStart(2, "0")).join(""), "utf8");
 }
 function memoDataFor(accept) {
-  if (accept.extra.memo !== void 0) {
+  if (_optionalChain([accept, 'access', _7 => _7.extra, 'optionalAccess', _8 => _8.memo]) !== void 0) {
     const bytes = Buffer.from(accept.extra.memo, "utf8");
     if (bytes.length > MAX_MEMO_BYTES) {
       throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)(
@@ -267,17 +277,15 @@ async function payExactSolana(input) {
       "SVM exact is SPL-token only (TransferChecked); native SOL is not exact-payable. Pay via onchain-proof."
     );
   }
-  if (!accept.extra.feePayer) {
+  const extra = _nullishCoalesce(accept.extra, () => ( {}));
+  if (!extra.feePayer) {
     throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)("SVM exact rail must advertise extra.feePayer (the merchant sponsor key).");
   }
-  if (accept.extra.decimals === void 0) {
-    throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)("SVM exact rail must advertise extra.decimals for the TransferChecked.");
-  }
   let feePayer;
   let mint;
   let payTo;
   try {
-    feePayer = new (0, _web3js.PublicKey)(accept.extra.feePayer);
+    feePayer = new (0, _web3js.PublicKey)(extra.feePayer);
     mint = new (0, _web3js.PublicKey)(accept.asset);
     payTo = new (0, _web3js.PublicKey)(accept.payTo);
   } catch (err) {
@@ -285,6 +293,18 @@ async function payExactSolana(input) {
       `SVM exact: bad feePayer/asset/payTo (${err instanceof Error ? err.message : String(err)}).`
     );
   }
+  const onChainDecimals = await readMintDecimals(connection, mint);
+  const decimals = _nullishCoalesce(onChainDecimals, () => ( extra.decimals));
+  if (decimals === void 0) {
+    throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)(
+      `SVM exact: couldn't read the decimals of mint ${accept.asset} on-chain, and the rail states none. Retry with a reliable rpcUrl \u2014 TransferChecked cannot be built without them.`
+    );
+  }
+  if (onChainDecimals !== void 0 && extra.decimals !== void 0 && extra.decimals !== onChainDecimals) {
+    throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)(
+      `SVM exact: the rail states ${extra.decimals} decimals for ${accept.asset} but the mint says ${onChainDecimals} \u2014 refusing to sign (a mismatch this size misprices the transfer).`
+    );
+  }
   if (feePayer.equals(payTo)) {
     throw new (0, _chunkQONQSZHJcjs.UnsupportedSchemeError)(
       "SVM exact: the fee payer must differ from payTo \u2014 payTo appears in the transfer instruction, which the fee payer must not (a scheme MUST-rule). Use a separate relayer key for the gate."
@@ -296,7 +316,7 @@ async function payExactSolana(input) {
   let destInfo = "unknown";
   try {
     destInfo = await input.connection.getAccountInfo(dest);
-  } catch (e3) {
+  } catch (e4) {
     destInfo = "unknown";
   }
   if (destInfo === null) {
@@ -314,7 +334,8 @@ async function payExactSolana(input) {
       dest,
       keypair.publicKey,
       BigInt(accept.amount),
-      accept.extra.decimals,
+      decimals,
+      // read from the MINT (see above), not from the server's `extra`
       [],
       program
     ),
@@ -359,7 +380,7 @@ async function verifyAndSettleExactSolana(input) {
   try {
     payTo = new (0, _web3js.PublicKey)(accept.payTo);
     mint = new (0, _web3js.PublicKey)(accept.asset);
-    if (!accept.extra.feePayer) throw new Error("rail is missing extra.feePayer");
+    if (!_optionalChain([accept, 'access', _9 => _9.extra, 'optionalAccess', _10 => _10.feePayer])) throw new Error("rail is missing extra.feePayer");
     railFeePayer = new (0, _web3js.PublicKey)(accept.extra.feePayer);
   } catch (err) {
     throw new (0, _chunkQONQSZHJcjs.SettlementError)(`SVM exact: rail has a bad payTo/asset/feePayer (${err instanceof Error ? err.message : String(err)}).`);
@@ -389,7 +410,7 @@ async function verifyAndSettleExactSolana(input) {
     try {
       ;
       ({ value } = await connection.getAddressLookupTable(lookup.accountKey));
-    } catch (e4) {
+    } catch (e5) {
       return fail("tx_not_found", `Could not read lookup table ${lookup.accountKey.toBase58()} (transient RPC) \u2014 retry.`);
     }
     if (!value) {
@@ -411,7 +432,7 @@ async function verifyAndSettleExactSolana(input) {
       return fail("signature_invalid", "The fee payer is invoked as a program.");
     }
     for (const i of ix.accountKeyIndexes) {
-      if (_optionalChain([keys, 'access', _4 => _4.get, 'call', _5 => _5(i), 'optionalAccess', _6 => _6.equals, 'call', _7 => _7(feePayerKey)])) {
+      if (_optionalChain([keys, 'access', _11 => _11.get, 'call', _12 => _12(i), 'optionalAccess', _13 => _13.equals, 'call', _14 => _14(feePayerKey)])) {
         return fail("signature_invalid", "The fee payer appears in an instruction account list (would risk a fund drain).");
       }
     }
@@ -460,14 +481,14 @@ async function verifyAndSettleExactSolana(input) {
         }),
         program
       );
-    } catch (e5) {
+    } catch (e6) {
       continue;
     }
     if (!decoded.keys.mint.pubkey.equals(mint)) continue;
     if (!decoded.keys.destination.pubkey.equals(expectedDest)) {
       return fail("wrong_recipient", `A transfer pays ${decoded.keys.destination.pubkey.toBase58()}, not payTo's ATA ${expectedDest.toBase58()}.`);
     }
-    if (decoded.data.decimals !== accept.extra.decimals) {
+    if (_optionalChain([accept, 'access', _15 => _15.extra, 'optionalAccess', _16 => _16.decimals]) !== void 0 && decoded.data.decimals !== accept.extra.decimals) {
       return fail("transfer_not_found", `Transfer decimals ${decoded.data.decimals} \u2260 rail decimals ${accept.extra.decimals}.`);
     }
     sawTransferToPayTo = true;
@@ -548,7 +569,7 @@ async function pollConfirmed(connection, signature) {
     try {
       const { value } = await connection.getSignatureStatuses([signature], { searchTransactionHistory: true });
       info = value[0];
-    } catch (e6) {
+    } catch (e7) {
       info = null;
     }
     if (info) {
@@ -651,7 +672,7 @@ function makeSolanaNetwork(preset, rpcUrl) {
       }
       try {
         new (0, _web3js.PublicKey)(payTo);
-      } catch (e7) {
+      } catch (e8) {
         throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
           `chain ${network} is Solana, but payTo "${payTo}" is not a base58 address.`
         );
@@ -722,7 +743,7 @@ function makeSolanaNetwork(preset, rpcUrl) {
       try {
         const mint = new (0, _web3js.PublicKey)(asset);
         const info = await connection.getAccountInfo(mint);
-        const programId = _optionalChain([info, 'optionalAccess', _8 => _8.owner, 'access', _9 => _9.equals, 'call', _10 => _10(_spltoken.TOKEN_2022_PROGRAM_ID)]) ? _spltoken.TOKEN_2022_PROGRAM_ID : _spltoken.TOKEN_PROGRAM_ID;
+        const programId = _optionalChain([info, 'optionalAccess', _17 => _17.owner, 'access', _18 => _18.equals, 'call', _19 => _19(_spltoken.TOKEN_2022_PROGRAM_ID)]) ? _spltoken.TOKEN_2022_PROGRAM_ID : _spltoken.TOKEN_PROGRAM_ID;
         const ata = _spltoken.getAssociatedTokenAddressSync.call(void 0, mint, owner, false, programId);
         token = (await _spltoken.getAccount.call(void 0, connection, ata, "confirmed", programId)).amount;
       } catch (e) {
@@ -780,14 +801,14 @@ function makeSolanaNetwork(preset, rpcUrl) {
       if (!fp) return null;
       try {
         new (0, _web3js.PublicKey)(fp);
-      } catch (e8) {
+      } catch (e9) {
         return null;
       }
       let tokenProgram = "spl-token";
       try {
         const info = await connection.getAccountInfo(new (0, _web3js.PublicKey)(asset));
-        if (_optionalChain([info, 'optionalAccess', _11 => _11.owner, 'access', _12 => _12.equals, 'call', _13 => _13(_spltoken.TOKEN_2022_PROGRAM_ID)])) tokenProgram = "token-2022";
-      } catch (e9) {
+        if (_optionalChain([info, 'optionalAccess', _20 => _20.owner, 'access', _21 => _21.equals, 'call', _22 => _22(_spltoken.TOKEN_2022_PROGRAM_ID)])) tokenProgram = "token-2022";
+      } catch (e10) {
       }
       return { method: "svm", extra: { feePayer: fp, tokenProgram } };
     }

package/dist/{solana-WO2G7WWZ.js → solana-HTKDRTD3.js}

@@ -229,7 +229,17 @@ var MAX_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 100000n;
 var CB_SET_UNIT_LIMIT = 2;
 var CB_SET_UNIT_PRICE = 3;
 function tokenProgramFor(accept) {
-  return accept.extra.tokenProgram === "token-2022" ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+  return accept.extra?.tokenProgram === "token-2022" ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+}
+async function readMintDecimals(connection, mint) {
+  try {
+    const info = await connection.getAccountInfo(mint);
+    const data = info?.data;
+    if (!data || data.length < 45) return void 0;
+    return data[44];
+  } catch {
+    return void 0;
+  }
 }
 function isEmptySig(sig) {
   return !sig || sig.every((b) => b === 0);
@@ -246,7 +256,7 @@ function memoRandomNonce() {
   return Buffer.from([...raw].map((b) => b.toString(16).padStart(2, "0")).join(""), "utf8");
 }
 function memoDataFor(accept) {
-  if (accept.extra.memo !== void 0) {
+  if (accept.extra?.memo !== void 0) {
     const bytes = Buffer.from(accept.extra.memo, "utf8");
     if (bytes.length > MAX_MEMO_BYTES) {
       throw new UnsupportedSchemeError(
@@ -267,17 +277,15 @@ async function payExactSolana(input) {
       "SVM exact is SPL-token only (TransferChecked); native SOL is not exact-payable. Pay via onchain-proof."
     );
   }
-  if (!accept.extra.feePayer) {
+  const extra = accept.extra ?? {};
+  if (!extra.feePayer) {
     throw new UnsupportedSchemeError("SVM exact rail must advertise extra.feePayer (the merchant sponsor key).");
   }
-  if (accept.extra.decimals === void 0) {
-    throw new UnsupportedSchemeError("SVM exact rail must advertise extra.decimals for the TransferChecked.");
-  }
   let feePayer;
   let mint;
   let payTo;
   try {
-    feePayer = new PublicKey2(accept.extra.feePayer);
+    feePayer = new PublicKey2(extra.feePayer);
     mint = new PublicKey2(accept.asset);
     payTo = new PublicKey2(accept.payTo);
   } catch (err) {
@@ -285,6 +293,18 @@ async function payExactSolana(input) {
       `SVM exact: bad feePayer/asset/payTo (${err instanceof Error ? err.message : String(err)}).`
     );
   }
+  const onChainDecimals = await readMintDecimals(connection, mint);
+  const decimals = onChainDecimals ?? extra.decimals;
+  if (decimals === void 0) {
+    throw new UnsupportedSchemeError(
+      `SVM exact: couldn't read the decimals of mint ${accept.asset} on-chain, and the rail states none. Retry with a reliable rpcUrl \u2014 TransferChecked cannot be built without them.`
+    );
+  }
+  if (onChainDecimals !== void 0 && extra.decimals !== void 0 && extra.decimals !== onChainDecimals) {
+    throw new UnsupportedSchemeError(
+      `SVM exact: the rail states ${extra.decimals} decimals for ${accept.asset} but the mint says ${onChainDecimals} \u2014 refusing to sign (a mismatch this size misprices the transfer).`
+    );
+  }
   if (feePayer.equals(payTo)) {
     throw new UnsupportedSchemeError(
       "SVM exact: the fee payer must differ from payTo \u2014 payTo appears in the transfer instruction, which the fee payer must not (a scheme MUST-rule). Use a separate relayer key for the gate."
@@ -314,7 +334,8 @@ async function payExactSolana(input) {
       dest,
       keypair.publicKey,
       BigInt(accept.amount),
-      accept.extra.decimals,
+      decimals,
+      // read from the MINT (see above), not from the server's `extra`
       [],
       program
     ),
@@ -359,7 +380,7 @@ async function verifyAndSettleExactSolana(input) {
   try {
     payTo = new PublicKey2(accept.payTo);
     mint = new PublicKey2(accept.asset);
-    if (!accept.extra.feePayer) throw new Error("rail is missing extra.feePayer");
+    if (!accept.extra?.feePayer) throw new Error("rail is missing extra.feePayer");
     railFeePayer = new PublicKey2(accept.extra.feePayer);
   } catch (err) {
     throw new SettlementError(`SVM exact: rail has a bad payTo/asset/feePayer (${err instanceof Error ? err.message : String(err)}).`);
@@ -467,7 +488,7 @@ async function verifyAndSettleExactSolana(input) {
     if (!decoded.keys.destination.pubkey.equals(expectedDest)) {
       return fail("wrong_recipient", `A transfer pays ${decoded.keys.destination.pubkey.toBase58()}, not payTo's ATA ${expectedDest.toBase58()}.`);
     }
-    if (decoded.data.decimals !== accept.extra.decimals) {
+    if (accept.extra?.decimals !== void 0 && decoded.data.decimals !== accept.extra.decimals) {
       return fail("transfer_not_found", `Transfer decimals ${decoded.data.decimals} \u2260 rail decimals ${accept.extra.decimals}.`);
     }
     sawTransferToPayTo = true;

package/dist/{xrpl-6B2XOXGC.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,7 +9,9 @@ import {
   ConfirmationTimeoutError,
   InsufficientFundsError,
   RecipientNotReadyError,
+  SettlementError,
   UnknownTokenError,
+  UnsupportedSchemeError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
   floorUnits,
@@ -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", {