@piprail/sdk 2.16.2 → 3.0.0

package/dist/{stellar-EUFZLX6J.js → stellar-YF5LOJEM.js}

@@ -1,3 +1,6 @@
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   delay
 } from "./chunk-FURB5RP7.js";
@@ -8,11 +11,12 @@ import {
   UnknownTokenError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   parseUnits,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/stellar/index.ts
 import { Horizon, StrKey as StrKey2 } from "@stellar/stellar-sdk";
@@ -133,6 +137,151 @@ function extractResultCodes(err) {
   return [extras.transaction ?? "", ...extras.operations ?? []].filter(Boolean);
 }
 
+// src/drivers/stellar/swap.ts
+import { Asset as Asset2, BASE_FEE as BASE_FEE2, Operation as Operation2, TransactionBuilder as TransactionBuilder2 } from "@stellar/stellar-sdk";
+var SOURCE = {
+  kind: "protocol",
+  name: "Stellar SDEX",
+  note: "Rate from the ledger\u2019s own order books and liquidity pools, read live from Horizon. Order books charge no trading fee; liquidity pools charge a fixed 0.30%."
+};
+function assetForId(asset) {
+  if (asset === "native") return Asset2.native();
+  const parts = parseStellarAssetId(asset);
+  if (!parts) return null;
+  try {
+    return new Asset2(parts.code, parts.issuer);
+  } catch {
+    return null;
+  }
+}
+function hopToAsset(h) {
+  return h.asset_type === "native" ? Asset2.native() : new Asset2(h.asset_code, h.asset_issuer);
+}
+function side(t, amount) {
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? XLM_SYMBOL : t.asset),
+    decimals: STELLAR_DECIMALS,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, STELLAR_DECIMALS)
+  };
+}
+async function quoteStellarSwap(p) {
+  const fromAsset = assetForId(p.from.asset);
+  const toAsset = assetForId(p.to.asset);
+  if (!fromAsset || !toAsset) return null;
+  if (p.from.asset === p.to.asset) return null;
+  if (p.wantAmount <= 0n) return null;
+  const wantFormatted = formatUnits(p.wantAmount, STELLAR_DECIMALS);
+  let records;
+  try {
+    const page = await p.server.strictReceivePaths([fromAsset], toAsset, wantFormatted).call();
+    records = page.records;
+  } catch {
+    return null;
+  }
+  if (!records?.length) return null;
+  let best = null;
+  let spend = null;
+  for (const r of records) {
+    let candidate;
+    try {
+      candidate = parseUnits(r.source_amount, STELLAR_DECIMALS);
+    } catch {
+      continue;
+    }
+    if (candidate <= 0n) continue;
+    if (spend === null || candidate < spend) {
+      spend = candidate;
+      best = r;
+    }
+  }
+  if (best === null || spend === null) return null;
+  const maxSpend = applySlippage(spend, p.slippageBps);
+  return {
+    source: SOURCE,
+    network: p.network,
+    from: side(p.from, spend),
+    to: side(p.to, p.wantAmount),
+    maxSpend: maxSpend.toString(),
+    maxSpendFormatted: formatUnits(maxSpend, STELLAR_DECIMALS),
+    slippageBps: p.slippageBps,
+    route: best.path ?? []
+  };
+}
+async function swapStellar(p) {
+  const { server, keypair, quote } = p;
+  const sendAsset = assetForId(quote.from.asset);
+  const destAsset = assetForId(quote.to.asset);
+  if (!sendAsset || !destAsset) {
+    throw new Error(`Stellar: malformed asset id in swap quote (${quote.from.asset} \u2192 ${quote.to.asset}).`);
+  }
+  const path = Array.isArray(quote.route) ? quote.route.map(hopToAsset) : [];
+  try {
+    const source = await server.loadAccount(keypair.publicKey());
+    const tx = new TransactionBuilder2(source, { fee: BASE_FEE2, networkPassphrase: STELLAR_PASSPHRASE }).addOperation(
+      Operation2.pathPaymentStrictReceive({
+        sendAsset,
+        // The on-chain slippage cap. Validators enforce it; we do not.
+        sendMax: formatUnits(BigInt(quote.maxSpend), STELLAR_DECIMALS),
+        destination: keypair.publicKey(),
+        // ← ourselves: this is what makes it a swap
+        destAsset,
+        destAmount: quote.to.amountFormatted,
+        path
+      })
+    ).setTimeout(120).build();
+    tx.sign(keypair);
+    const res = await server.submitTransaction(tx);
+    return {
+      transaction: res.hash,
+      network: quote.network,
+      source: quote.source,
+      // Strict-RECEIVE fixes the output exactly; the input is whatever the market
+      // took, bounded by maxSpend. We report the quoted estimate for `from`.
+      from: quote.from,
+      to: quote.to
+    };
+  } catch (err) {
+    throw mapSwapError(err);
+  }
+}
+function mapSwapError(err) {
+  const codes = extractResultCodes2(err);
+  const seen = codes.join(", ");
+  const has = (re) => codes.some((c) => re.test(c));
+  if (has(/op_over_sendmax/i)) {
+    return new InsufficientFundsError(
+      `Stellar swap refused: the price moved past your slippage cap, so nothing was spent. Re-quote and retry, or raise slippageBps. (Stellar: ${seen})`,
+      { cause: err }
+    );
+  }
+  if (has(/op_too_few_offers|op_no_path/i)) {
+    return new InsufficientFundsError(
+      `Stellar swap refused: not enough liquidity on this pair right now, so nothing was spent. (Stellar: ${seen})`,
+      { cause: err }
+    );
+  }
+  if (has(/op_no_(trust|issuer)|op_not_authorized|op_line_full/i)) {
+    return new RecipientNotReadyError(
+      `Stellar swap refused: your account needs a trustline for the asset you're swapping INTO (and authorization) before it can hold it. (Stellar: ${seen})`,
+      { cause: err }
+    );
+  }
+  if (has(/underfunded|insufficient|low_reserve|src_no_trust/i)) {
+    return new InsufficientFundsError(
+      `Stellar swap failed: the account can't cover it \u2014 balance, base reserve, or no trustline to send this asset. (Stellar: ${seen})`,
+      { cause: err }
+    );
+  }
+  return toInsufficientFundsError(err) ?? err;
+}
+function extractResultCodes2(err) {
+  const extras = err?.response?.data?.extras?.result_codes;
+  if (!extras) return [];
+  return [extras.transaction ?? "", ...extras.operations ?? []].filter(Boolean);
+}
+
 // src/drivers/stellar/verify.ts
 import { hash as hash2 } from "@stellar/stellar-sdk";
 function memoCandidatesForNonce(nonce) {
@@ -388,6 +537,11 @@ function makeStellarNetwork(preset, rpcUrl) {
         detail: "base fee 100 stroops (1 operation)"
       });
     },
+    /** 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 resolveStellarWallet(wallet._native).publicKey();
+    },
     async balanceOf(wallet, asset) {
       let owner;
       try {
@@ -434,6 +588,14 @@ function makeStellarNetwork(preset, rpcUrl) {
       );
       return hasTrustline ? { ready: true } : { ready: false, reason: "NO_TRUSTLINE" };
     },
+    /* ---- swap (OPTIONAL, opt-in): a path payment to yourself. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps }) {
+      return quoteStellarSwap({ server, network, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      const keypair = resolveStellarWallet(wallet._native);
+      return swapStellar({ server, keypair, quote });
+    },
     async verify(_ref, accept) {
       return verifyStellar({ reader, accept });
     }

package/dist/{sui-KCIITCYH.js → sui-JFQSDNSZ.js}

@@ -1,13 +1,17 @@
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   ConfirmationTimeoutError,
   InsufficientFundsError,
   UnknownTokenError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/sui/index.ts
 import { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
@@ -94,6 +98,151 @@ function isSuiAffordability(err) {
   return /no valid gas|gas.*(balance|coin)|insufficient|balance is too low|GasBalanceTooLow/i.test(m);
 }
 
+// src/drivers/sui/swap.ts
+import { Transaction as Transaction2 } from "@mysten/sui/transactions";
+var AFTERMATH_API = "https://aftermath.finance/api/router";
+function sourceFor(netFeePct) {
+  const pct = typeof netFeePct === "number" ? `${(netFeePct * 100).toFixed(4)}%` : "the underlying pool fee";
+  return {
+    kind: "provider",
+    name: "Aftermath",
+    note: `Third-party Sui DEX aggregator (aftermath.finance), used keyless. It routes and returns a complete transaction block; your own keypair signs it locally and Aftermath never holds your funds. Cost on this route: ${pct}, which is the underlying pool fee. PipRail adds nothing.`
+  };
+}
+function coinType(t) {
+  return t.asset === "native" ? SUI_NATIVE_COINTYPE : t.asset;
+}
+function side(t, amount) {
+  const decimals = t.asset === "native" ? SUI_DECIMALS : t.decimals;
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? SUI_SYMBOL : t.asset),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, decimals)
+  };
+}
+function toBig(v) {
+  try {
+    if (typeof v === "bigint") return v;
+    const s = String(v ?? "").replace(/n$/, "");
+    return s ? BigInt(s) : null;
+  } catch {
+    return null;
+  }
+}
+async function postJson(url, body) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 15e3);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: ctrl.signal
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function quoteSuiSwap(p) {
+  if (p.wantAmount <= 0n) return null;
+  const coinInType = coinType(p.from);
+  const coinOutType = coinType(p.to);
+  if (coinInType === coinOutType) return null;
+  const route = (amountIn) => postJson(`${AFTERMATH_API}/trade-route`, {
+    coinInType,
+    coinOutType,
+    coinInAmount: amountIn.toString()
+  });
+  const fromDecimals = p.from.asset === "native" ? SUI_DECIMALS : p.from.decimals;
+  const probeIn = 10n ** BigInt(Math.max(fromDecimals - 2, 1));
+  const probe = await route(probeIn);
+  const probeOut = toBig(probe?.coinOut?.amount);
+  if (probeOut === null || probeOut <= 0n) return null;
+  let needIn = (probeIn * p.wantAmount + probeOut - 1n) / probeOut;
+  needIn = applySlippage(needIn, p.slippageBps);
+  const real = await route(needIn);
+  const realOut = toBig(real?.coinOut?.amount);
+  if (realOut === null) return null;
+  if (realOut < p.wantAmount) return null;
+  return {
+    source: sourceFor(real?.netTradeFeePercentage),
+    network: p.network,
+    from: side(p.from, needIn),
+    to: side(p.to, realOut),
+    // Exact-in: the input IS the cap. It cannot spend more than this.
+    maxSpend: needIn.toString(),
+    maxSpendFormatted: formatUnits(needIn, fromDecimals),
+    slippageBps: p.slippageBps,
+    // Aftermath needs its own route object back verbatim to build the transaction.
+    route: { completeRoute: real, slippage: p.slippageBps / 1e4 }
+  };
+}
+async function swapSui(p) {
+  const { client, keypair, quote } = p;
+  const route = quote.route;
+  if (!route?.completeRoute) {
+    throw new Error("Sui: swap quote is missing its Aftermath routing data \u2014 re-quote before swapping.");
+  }
+  const built = await postJson(
+    `${AFTERMATH_API}/transactions/trade`,
+    {
+      walletAddress: keypair.getPublicKey().toSuiAddress(),
+      completeRoute: route.completeRoute,
+      slippage: route.slippage ?? 0.01
+    }
+  );
+  const serialized = typeof built === "string" ? built : built?.serializedTx;
+  if (!serialized) {
+    throw new InsufficientFundsError(
+      "Aftermath could not build this swap (the route went stale, or the market moved). Nothing was spent \u2014 re-quote and retry."
+    );
+  }
+  let tx;
+  try {
+    tx = Transaction2.from(serialized);
+  } catch (cause) {
+    throw new Error("Sui: Aftermath returned a transaction this SDK could not decode.", { cause });
+  }
+  try {
+    const res = await client.signAndExecuteTransaction({ transaction: tx, signer: keypair });
+    const status = res.effects?.status?.status;
+    if (status && status !== "success") {
+      throw new InsufficientFundsError(
+        `Sui swap failed on-chain: ${res.effects?.status?.error ?? status}. Re-quote and retry.`
+      );
+    }
+    return {
+      transaction: res.digest,
+      network: quote.network,
+      source: quote.source,
+      from: quote.from,
+      to: quote.to
+    };
+  } catch (err) {
+    if (err instanceof InsufficientFundsError) throw err;
+    const msg = String(err?.message ?? err);
+    if (/insufficient|balance|GasBalanceTooLow/i.test(msg)) {
+      throw new InsufficientFundsError(
+        `Sui swap failed: the wallet can't cover it (coin balance or SUI for gas). (${msg.slice(0, 160)})`,
+        { cause: err }
+      );
+    }
+    if (/slippage|SlippageExceeded/i.test(msg)) {
+      throw new InsufficientFundsError(
+        "Sui swap refused: the price moved past your slippage cap, so nothing was spent. Re-quote and retry.",
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+
 // src/drivers/sui/verify.ts
 async function verifySui(params) {
   const { reader, digest, accept } = params;
@@ -308,6 +457,11 @@ function makeSuiNetwork(preset, rpcUrl) {
         detail: "\u22480.003 SUI (computation + storage; storage is largely rebated on success)"
       });
     },
+    /** 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 resolveSuiKeypair(wallet._native).toSuiAddress();
+    },
     async balanceOf(wallet, asset) {
       let owner;
       try {
@@ -315,9 +469,9 @@ function makeSuiNetwork(preset, rpcUrl) {
       } catch {
         return { token: null, native: null };
       }
-      const readBal = async (coinType) => {
+      const readBal = async (coinType2) => {
         try {
-          return BigInt((await client.getBalance({ owner, coinType })).totalBalance);
+          return BigInt((await client.getBalance({ owner, coinType: coinType2 })).totalBalance);
         } catch {
           return null;
         }
@@ -331,6 +485,14 @@ function makeSuiNetwork(preset, rpcUrl) {
     async recipientReady() {
       return { ready: "n/a" };
     },
+    /* ---- swap (OPTIONAL, opt-in): via Aftermath, keyless + no added fee. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps }) {
+      return quoteSuiSwap({ network, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      const keypair = resolveSuiKeypair(wallet._native);
+      return swapSui({ client, keypair, quote });
+    },
     async verify(ref, accept) {
       return verifySui({ reader, digest: ref, accept });
     }