@piprail/sdk 2.15.1 → 2.16.0

package/dist/{xrpl-VOUXIUYD.cjs → xrpl-SVVS445B.cjs}

@@ -1,4 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkOXEFPLZAcjs = require('./chunk-OXEFPLZA.cjs');
+require('./chunk-V2IJ5HUW.cjs');
+
 
 var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
@@ -12,6 +16,8 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
+
+
 var _chunkQONQSZHJcjs = require('./chunk-QONQSZHJ.cjs');
 
 // src/drivers/xrpl/index.ts
@@ -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
+var _crypto = require('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 _optionalChain([accept, 'access', _3 => _3.extra, 'optionalAccess', _4 => _4.areFeesSponsored]) === true;
+}
+function invoiceIdHash(invoiceId) {
+  return _crypto.createHash.call(void 0, "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 (0, _chunkQONQSZHJcjs.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 (0, _chunkQONQSZHJcjs.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 = _chunkOXEFPLZAcjs.exactTransferMethod.call(void 0, accept, "xrpl");
+  if (method !== "sequence") {
+    throw new (0, _chunkQONQSZHJcjs.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 (0, _chunkQONQSZHJcjs.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(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _5 => _5.message]), () => ( err))))) {
+      throw new (0, _chunkQONQSZHJcjs.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 _optionalChain([accept, 'access', _6 => _6.extra, 'optionalAccess', _7 => _7.destinationTag]) === "number") {
+    tx.DestinationTag = accept.extra.destinationTag;
+  }
+  if (typeof _optionalChain([accept, 'access', _8 => _8.extra, 'optionalAccess', _9 => _9.sourceTag]) === "number") {
+    tx.SourceTag = accept.extra.sourceTag;
+  }
+  if (typeof _optionalChain([accept, 'access', _10 => _10.extra, 'optionalAccess', _11 => _11.invoiceId]) === "string" && accept.extra.invoiceId.length > 0) {
+    tx.InvoiceID = invoiceIdHash(accept.extra.invoiceId);
+  }
+  let signed;
+  try {
+    signed = wallet.sign(tx);
+  } catch (err) {
+    throw new (0, _chunkQONQSZHJcjs.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 = _nullishCoalesce(input.pollAttempts, () => ( 8));
+  const sleep = _nullishCoalesce(input.sleep, () => ( ((ms) => new Promise((r) => setTimeout(r, ms)))));
+  if (feesAreSponsored(accept)) {
+    throw new (0, _chunkQONQSZHJcjs.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 _optionalChain([accept, 'access', _12 => _12.extra, 'optionalAccess', _13 => _13.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 _optionalChain([accept, 'access', _14 => _14.extra, 'optionalAccess', _15 => _15.invoiceId]) === "string" && accept.extra.invoiceId.length > 0) {
+    const want = invoiceIdHash(accept.extra.invoiceId);
+    if (String(_nullishCoalesce(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 = _nullishCoalesce(_optionalChain([res, 'access', _16 => _16.tx_json, 'optionalAccess', _17 => _17.hash]), () => ( ""));
+    if (!hash) throw new Error("submit returned no transaction hash");
+  } catch (err) {
+    throw new (0, _chunkQONQSZHJcjs.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 (e2) {
+      record = null;
+    }
+    if (_optionalChain([record, 'optionalAccess', _18 => _18.validated])) {
+      const code = _optionalChain([record, 'access', _19 => _19.meta, 'optionalAccess', _20 => _20.TransactionResult]);
+      if (code !== "tesSUCCESS") {
+        return fail("transfer_not_found", `XRPL exact: validated with ${String(code)}, not tesSUCCESS.`);
+      }
+      const delivered = _optionalChain([record, 'access', _21 => _21.meta, 'optionalAccess', _22 => _22.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(_nullishCoalesce(_nullishCoalesce(record.Account, () => ( tx.Account)), () => ( ""))),
+          payTo: accept.payTo,
+          verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }
+    await sleep(1200);
+  }
+  throw new (0, _chunkQONQSZHJcjs.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) {
@@ -152,7 +371,7 @@ async function verifyXrpl(params) {
   let txs;
   try {
     txs = await reader.transactionsForAccount(accept.payTo, 200);
-  } catch (e2) {
+  } catch (e3) {
     return rpcFailed(nonce);
   }
   const tx = txs.find(
@@ -216,7 +435,7 @@ async function verifyXrpl(params) {
 }
 function hasNonceMemo(memos, wantMemo) {
   if (!memos) return false;
-  return memos.some((m) => (_nullishCoalesce(_optionalChain([m, 'access', _3 => _3.Memo, 'optionalAccess', _4 => _4.MemoData]), () => ( ""))).toUpperCase() === wantMemo);
+  return memos.some((m) => (_nullishCoalesce(_optionalChain([m, 'access', _23 => _23.Memo, 'optionalAccess', _24 => _24.MemoData]), () => ( ""))).toUpperCase() === wantMemo);
 }
 function deliveredBaseUnits(delivered, want, decimals) {
   if (delivered === void 0) return null;
@@ -231,7 +450,7 @@ function deliveredBaseUnits(delivered, want, decimals) {
   }
   try {
     return _chunkQONQSZHJcjs.floorUnits.call(void 0, delivered.value, decimals);
-  } catch (e3) {
+  } catch (e4) {
     return null;
   }
 }
@@ -279,7 +498,7 @@ function resolveXrplWallet(config) {
 
 // src/drivers/xrpl/index.ts
 function isXrplActNotFound(e) {
-  return /actNotFound/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _5 => _5.message]), () => ( e))));
+  return /actNotFound/i.test(String(_nullishCoalesce(_optionalChain([e, 'optionalAccess', _25 => _25.message]), () => ( e))));
 }
 var xrplDriver = {
   family: "xrpl",
@@ -301,7 +520,7 @@ function makeXrplNetwork(preset, rpcUrl) {
     const json = await res.json();
     const result = json.result;
     if (!result || result.status === "error" || result.error) {
-      throw new Error(`XRPL RPC ${method} error: ${_nullishCoalesce(_optionalChain([result, 'optionalAccess', _6 => _6.error]), () => ( "unknown"))}`);
+      throw new Error(`XRPL RPC ${method} error: ${_nullishCoalesce(_optionalChain([result, 'optionalAccess', _26 => _26.error]), () => ( "unknown"))}`);
     }
     return result;
   }
@@ -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 (e5) {
+        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 Promise.resolve().then(() => _interopRequireWildcard(require("xrpl")));
+      return verifyAndSettleExactXrpl({
+        client: exactSettleClient,
+        decode: (blob) => decode(blob),
+        payload,
+        accept
+      });
+    },
     async confirm(ref) {
       for (let i = 0; i < 12; i += 1) {
         try {
@@ -407,7 +685,7 @@ function makeXrplNetwork(preset, rpcUrl) {
             transaction: ref
           });
           if (tx.validated) return { height: String(_nullishCoalesce(tx.ledger_index, () => ( 0))) };
-        } catch (e4) {
+        } catch (e6) {
         }
         await _chunkCQREG5LEcjs.delay.call(void 0, 1500);
       }
@@ -425,7 +703,7 @@ function makeXrplNetwork(preset, rpcUrl) {
           basis: "estimated",
           detail: `network fee ${fee} drops`
         });
-      } catch (e5) {
+      } catch (e7) {
         return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
           symbol: XRP_SYMBOL,
           decimals: XRP_DECIMALS,
@@ -439,7 +717,7 @@ function makeXrplNetwork(preset, rpcUrl) {
       let owner;
       try {
         owner = resolveXrplWallet(wallet._native).classicAddress;
-      } catch (e6) {
+      } catch (e8) {
         return { token: null, native: null };
       }
       let native = null;
@@ -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", {
@@ -487,7 +765,7 @@ function makeXrplNetwork(preset, rpcUrl) {
           (l) => l.currency.toUpperCase() === (_nullishCoalesce(currencyHex, () => ( ""))).toUpperCase() && l.account === issuer
         );
         return has ? { ready: true } : { ready: false, reason: "NO_TRUSTLINE" };
-      } catch (e7) {
+      } catch (e9) {
         return { ready: "unknown" };
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piprail/sdk",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "description": "Accept x402 crypto payments across 29 chains — every major EVM chain plus Solana, TON, Tron, NEAR, Sui, Aptos, Algorand, Stellar & XRPL — in a couple of lines. No backend, no database, no fee; payments settle straight to your wallet.",
   "type": "module",
   "main": "./dist/index.cjs",