@piprail/sdk 2.16.2 → 3.0.0

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

@@ -1,7 +1,10 @@
 import {
   exactTransferMethod
-} from "./chunk-C52H5TYB.js";
-import "./chunk-2CX7XRZK.js";
+} from "./chunk-YXBQKBDH.js";
+import "./chunk-TZDVZCTC.js";
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   delay
 } from "./chunk-FURB5RP7.js";
@@ -15,10 +18,11 @@ import {
   WrongFamilyError,
   assertNoLegacyWalletKey,
   floorUnits,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/xrpl/index.ts
 import { isValidClassicAddress } from "xrpl";
@@ -150,6 +154,197 @@ function isAffordabilityCode(code) {
   return /^(tecUNFUNDED|tecINSUFF|terINSUF)/.test(code);
 }
 
+// src/drivers/xrpl/swap.ts
+var SOURCE = {
+  kind: "protocol",
+  name: "XRPL DEX + AMM",
+  note: "Rate from the ledger\u2019s own order books and AMM pools, read live via ripple_path_find, with auto-bridging through XRP where cheaper. Order books charge no protocol fee; AMM pools charge a per-pool fee (0%\u20131%) paid to the pool."
+};
+function toAmount(t, base) {
+  if (t.asset === "native") return base.toString();
+  const parts = parseXrplAssetId(t.asset);
+  if (!parts) throw new Error(`XRPL: malformed asset id "${t.asset}".`);
+  return { currency: parts.currencyHex, issuer: parts.issuer, value: formatUnits(base, t.decimals) };
+}
+function parseCeil(value, decimals) {
+  const [whole = "0", frac = ""] = value.trim().split(".");
+  const kept = frac.slice(0, decimals).padEnd(decimals, "0");
+  const rest = frac.slice(decimals);
+  const base = BigInt(whole + kept);
+  return /[1-9]/.test(rest) ? base + 1n : base;
+}
+function fromAmount(t, a) {
+  if (a == null) return null;
+  try {
+    return typeof a === "string" ? BigInt(a) : parseCeil(a.value, t.decimals);
+  } catch {
+    return null;
+  }
+}
+function sourceCurrency(t) {
+  if (t.asset === "native") return { currency: "XRP" };
+  const parts = parseXrplAssetId(t.asset);
+  if (!parts) throw new Error(`XRPL: malformed asset id "${t.asset}".`);
+  return { currency: parts.currencyHex, issuer: parts.issuer };
+}
+function side(t, amount) {
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? XRP_SYMBOL : t.asset),
+    decimals: t.asset === "native" ? XRP_DECIMALS : t.decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, t.asset === "native" ? XRP_DECIMALS : t.decimals)
+  };
+}
+async function quoteXrplSwap(p) {
+  if (p.from.asset === p.to.asset) return null;
+  if (p.wantAmount <= 0n) return null;
+  let alternatives = [];
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const res = await p.client.pathFind({
+        source_account: p.owner,
+        destination_account: p.owner,
+        // ← ourselves: this is what makes it a swap
+        destination_amount: toAmount(p.to, p.wantAmount),
+        source_currencies: [sourceCurrency(p.from)]
+      });
+      alternatives = res.alternatives ?? [];
+    } catch {
+      alternatives = [];
+    }
+    if (alternatives.length) break;
+    if (attempt === 0) await new Promise((r) => setTimeout(r, 600));
+  }
+  if (!alternatives.length) return null;
+  let best = null;
+  let bestSpend = null;
+  for (const alt of alternatives) {
+    const spend = fromAmount(p.from, alt.source_amount);
+    if (spend == null || spend <= 0n) continue;
+    if (bestSpend == null || spend < bestSpend) {
+      bestSpend = spend;
+      best = alt;
+    }
+  }
+  if (!best || bestSpend == null) return null;
+  const maxSpend = applySlippage(bestSpend, p.slippageBps);
+  return {
+    source: SOURCE,
+    network: p.network,
+    from: side(p.from, bestSpend),
+    to: side(p.to, p.wantAmount),
+    maxSpend: maxSpend.toString(),
+    maxSpendFormatted: formatUnits(maxSpend, p.from.asset === "native" ? XRP_DECIMALS : p.from.decimals),
+    slippageBps: p.slippageBps,
+    // `paths_computed` drops straight into the transaction's Paths field.
+    route: { paths: best.paths_computed ?? [], from: p.from, to: p.to }
+  };
+}
+function sanitizePaths(paths) {
+  if (!Array.isArray(paths)) return [];
+  return paths.map(
+    (path) => (Array.isArray(path) ? path : []).map((raw) => {
+      const step = raw;
+      const clean = {};
+      if (typeof step.account === "string") clean.account = step.account;
+      if (typeof step.currency === "string") clean.currency = step.currency;
+      if (typeof step.issuer === "string") clean.issuer = step.issuer;
+      return clean;
+    }).filter((step) => Object.keys(step).length > 0)
+  ).filter((path) => path.length > 0);
+}
+async function swapXrpl(p) {
+  const { client, wallet, quote } = p;
+  const route = quote.route;
+  if (!route?.from || !route?.to) {
+    throw new Error("XRPL: swap quote is missing its routing data \u2014 re-quote before swapping.");
+  }
+  try {
+    const [sequence, feeDrops, ledgerIndex] = await Promise.all([
+      client.accountSequence(wallet.classicAddress),
+      client.feeDrops(),
+      client.currentLedgerIndex()
+    ]);
+    const tx = {
+      TransactionType: "Payment",
+      Account: wallet.classicAddress,
+      Destination: wallet.classicAddress,
+      // ← ourselves: the ledger's own swap idiom
+      Amount: toAmount(route.to, BigInt(quote.to.amount)),
+      // exact output
+      SendMax: toAmount(route.from, BigInt(quote.maxSpend)),
+      // the on-chain slippage cap
+      // Sanitized: raw path steps from ripple_path_find can break xrpl.js encoding.
+      ...sanitizePaths(route.paths).length ? { Paths: sanitizePaths(route.paths) } : {},
+      Sequence: sequence,
+      Fee: feeForSubmit2(feeDrops),
+      LastLedgerSequence: ledgerIndex + 20,
+      // NOT tfPartialPayment: we want the full `Amount` delivered or nothing at all.
+      Flags: 0
+    };
+    let signed;
+    try {
+      signed = wallet.sign(tx);
+    } catch (cause) {
+      const shape = Object.fromEntries(
+        Object.entries(tx).map(([k, v]) => [k, typeof v === "object" ? JSON.stringify(v) : `${typeof v}:${String(v)}`])
+      );
+      throw new Error(
+        `XRPL could not encode the swap transaction: ${String(cause?.message ?? cause)}. Transaction was ${JSON.stringify(shape)}`,
+        { cause }
+      );
+    }
+    const res = await client.submit(signed.tx_blob);
+    const code = res.engine_result;
+    if (code.startsWith("tes")) {
+      return {
+        transaction: res.tx_json?.hash ?? signed.hash,
+        network: quote.network,
+        source: quote.source,
+        from: quote.from,
+        to: quote.to
+      };
+    }
+    throw mapEngineResult(code, res);
+  } catch (err) {
+    if (err instanceof InsufficientFundsError || err instanceof RecipientNotReadyError) throw err;
+    throw toInsufficientFundsError(err) ?? err;
+  }
+}
+function feeForSubmit2(openLedgerFee) {
+  try {
+    const f = BigInt(openLedgerFee);
+    const padded = f * 2n;
+    return (padded < 10n ? 10n : padded).toString();
+  } catch {
+    return "12";
+  }
+}
+function mapEngineResult(code, res) {
+  const err = new Error(`XRPL swap rejected: ${code}`);
+  err.cause = res;
+  if (code === "tecPATH_PARTIAL" || code === "tecPATH_DRY") {
+    return new InsufficientFundsError(
+      `XRPL swap refused: the price moved past your slippage cap, or the path ran dry, so nothing was spent. Re-quote and retry, or raise slippageBps. (XRPL: ${code})`,
+      { cause: res }
+    );
+  }
+  if (code === "tecNO_LINE" || code === "tecNO_AUTH" || code === "tecNO_ISSUER") {
+    return new RecipientNotReadyError(
+      `XRPL swap refused: your account needs a trustline for the currency you're swapping INTO before it can hold it. (XRPL: ${code})`,
+      { cause: res }
+    );
+  }
+  if (code === "tecUNFUNDED_PAYMENT" || code === "terINSUF_FEE_B" || code === "tecINSUFF_FEE") {
+    return new InsufficientFundsError(
+      `XRPL swap failed: the account can't cover it \u2014 balance or the 1 XRP base reserve. (XRPL: ${code})`,
+      { cause: res }
+    );
+  }
+  return err;
+}
+
 // src/drivers/xrpl/exact.ts
 import { createHash } from "crypto";
 var SECONDS_PER_LEDGER = 4;
@@ -170,7 +365,7 @@ function feesAreSponsored(accept) {
 function invoiceIdHash(invoiceId) {
   return createHash("sha256").update(invoiceId, "utf8").digest("hex").toUpperCase();
 }
-function feeForSubmit2(openLedgerFee) {
+function feeForSubmit3(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));
@@ -224,7 +419,7 @@ async function payExactXrpl(input) {
     Amount: accept.amount,
     // integer drops, verbatim from the trusted accept
     Sequence: sequence,
-    Fee: feeForSubmit2(openLedgerFee),
+    Fee: feeForSubmit3(openLedgerFee),
     LastLedgerSequence: ledgerIndex + ledgerWindowFor(accept.maxTimeoutSeconds),
     // tfFullyCanonicalSig ON, tfPartialPayment OFF — the shape every other XRPL client sends.
     Flags: TF_FULLY_CANONICAL_SIG
@@ -525,6 +720,9 @@ function makeXrplNetwork(preset, rpcUrl) {
     return result;
   }
   const payClient = {
+    async pathFind(params) {
+      return rpc("ripple_path_find", { ...params, ledger_index: "current" });
+    },
     async accountSequence(account) {
       const r = await rpc("account_info", {
         account,
@@ -713,6 +911,11 @@ function makeXrplNetwork(preset, rpcUrl) {
         });
       }
     },
+    /** The bound wallet's own address — where THIS wallet gets paid. Derived from the key
+     *  material only: no RPC, nothing moved. See {@link ResolvedNetwork.addressOf}. */
+    async addressOf(wallet) {
+      return resolveXrplWallet(wallet._native).classicAddress;
+    },
     async balanceOf(wallet, asset) {
       let owner;
       try {
@@ -769,6 +972,20 @@ function makeXrplNetwork(preset, rpcUrl) {
         return { ready: "unknown" };
       }
     },
+    /* ---- swap (OPTIONAL, opt-in): a cross-currency payment to yourself. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps, wallet }) {
+      let owner;
+      try {
+        owner = resolveXrplWallet(wallet._native).classicAddress;
+      } catch {
+        return null;
+      }
+      return quoteXrplSwap({ client: payClient, network, owner, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      const w = resolveXrplWallet(wallet._native);
+      return swapXrpl({ client: payClient, wallet: w, quote });
+    },
     async verify(_ref, accept) {
       return verifyXrpl({ reader, accept });
     }