@piprail/sdk 2.16.2 → 3.1.0

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

@@ -1,17 +1,22 @@
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   ConfirmationTimeoutError,
+  InsufficientFundsError,
   SettlementError,
   UnknownTokenError,
   UnsupportedSchemeError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/solana/index.ts
-import { Connection, PublicKey as PublicKey3 } from "@solana/web3.js";
+import { Connection as Connection2, PublicKey as PublicKey3 } from "@solana/web3.js";
 import {
   getAccount,
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3,
@@ -102,6 +107,148 @@ async function paySolana(params) {
   return signature;
 }
 
+// src/drivers/solana/swap.ts
+import { VersionedTransaction } from "@solana/web3.js";
+var JUPITER_API = "https://lite-api.jup.ag/swap/v1";
+var WSOL_MINT = "So11111111111111111111111111111111111111112";
+function sourceFor(platformFee) {
+  const charged = platformFee != null && !(typeof platformFee === "object" && Object.keys(platformFee).length === 0);
+  return {
+    kind: "provider",
+    name: "Jupiter",
+    note: "Third-party Solana DEX aggregator (lite-api.jup.ag), used keyless. It routes and builds the transaction; your own key signs it and Jupiter never holds your funds. " + (charged ? `\u26A0\uFE0F THIS QUOTE CARRIES A PLATFORM FEE: ${JSON.stringify(platformFee)}. PipRail did not set one.` : "This quote carries no platform fee, and PipRail adds none.")
+  };
+}
+function mintFor(t) {
+  return t.asset === "native" ? WSOL_MINT : t.asset;
+}
+function side(t, amount) {
+  const decimals = t.asset === "native" ? SOL_DECIMALS : t.decimals;
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? "SOL" : t.asset),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, decimals)
+  };
+}
+async function getJson(url, init) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 1e4);
+  try {
+    const res = await fetch(url, { ...init ?? {}, signal: ctrl.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function quoteSolanaSwap(p) {
+  if (p.wantAmount <= 0n) return null;
+  const inputMint = mintFor(p.from);
+  const outputMint = mintFor(p.to);
+  if (inputMint === outputMint) return null;
+  const url = `${JUPITER_API}/quote?inputMint=${inputMint}&outputMint=${outputMint}&amount=${p.wantAmount.toString()}&swapMode=ExactOut&slippageBps=${p.slippageBps}`;
+  const q = await getJson(url);
+  if (!q?.otherAmountThreshold || !q.inAmount) return null;
+  if (q.swapMode !== "ExactOut") return null;
+  if (q.outAmount !== p.wantAmount.toString()) return null;
+  let spend;
+  let maxSpend;
+  try {
+    spend = BigInt(q.inAmount);
+    const jupCap = BigInt(q.otherAmountThreshold);
+    const ourCap = applySlippage(spend, p.slippageBps);
+    maxSpend = jupCap > ourCap ? jupCap : ourCap;
+  } catch {
+    return null;
+  }
+  if (spend <= 0n) return null;
+  const fromDecimals = p.from.asset === "native" ? SOL_DECIMALS : p.from.decimals;
+  return {
+    source: sourceFor(q.platformFee),
+    network: p.network,
+    from: side(p.from, spend),
+    to: side(p.to, p.wantAmount),
+    maxSpend: maxSpend.toString(),
+    maxSpendFormatted: formatUnits(maxSpend, fromDecimals),
+    slippageBps: p.slippageBps,
+    // Jupiter needs its own quote object back verbatim to build the transaction.
+    route: q
+  };
+}
+async function swapSolana(p) {
+  const { connection, keypair, quote } = p;
+  const jupQuote = quote.route;
+  if (!jupQuote?.otherAmountThreshold) {
+    throw new Error("Solana: swap quote is missing its Jupiter routing data \u2014 re-quote before swapping.");
+  }
+  const built = await getJson(`${JUPITER_API}/swap`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      quoteResponse: jupQuote,
+      userPublicKey: keypair.publicKey.toBase58(),
+      // Let Jupiter create + close the wrapped-SOL account in the same transaction,
+      // so a SOL leg needs no separate setup step from the caller.
+      wrapAndUnwrapSol: true,
+      dynamicComputeUnitLimit: true
+    })
+  });
+  if (!built?.swapTransaction) {
+    throw new InsufficientFundsError(
+      "Jupiter could not build this swap transaction (no route, or the market moved). Nothing was spent \u2014 re-quote and retry."
+    );
+  }
+  let tx;
+  try {
+    tx = VersionedTransaction.deserialize(Buffer.from(built.swapTransaction, "base64"));
+  } catch (cause) {
+    throw new Error("Solana: Jupiter returned a transaction this SDK could not decode.", { cause });
+  }
+  tx.sign([keypair]);
+  try {
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const sig = await connection.sendRawTransaction(tx.serialize(), {
+      skipPreflight: false,
+      maxRetries: 3
+    });
+    const conf = await connection.confirmTransaction(
+      { signature: sig, blockhash, lastValidBlockHeight },
+      "confirmed"
+    );
+    if (conf?.value?.err) {
+      throw new InsufficientFundsError(
+        `Solana swap failed on-chain (tx ${sig}): ${JSON.stringify(conf.value.err)}. Nothing was swapped. The usual cause is slippage \u2014 re-quote and retry.`
+      );
+    }
+    return {
+      transaction: sig,
+      network: quote.network,
+      source: quote.source,
+      from: quote.from,
+      to: quote.to
+    };
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    if (/insufficient|0x1\b/i.test(msg)) {
+      throw new InsufficientFundsError(
+        `Solana swap failed: the wallet can't cover it (token balance, or SOL for fees and rent). (${msg.slice(0, 160)})`,
+        { cause: err }
+      );
+    }
+    if (/slippage|0x1771/i.test(msg)) {
+      throw new InsufficientFundsError(
+        "Solana swap refused: the price moved past your slippage cap, so nothing was spent. Re-quote and retry, or raise slippageBps.",
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+
 // src/drivers/solana/verify.ts
 async function verifySolana(params) {
   const { connection, signature, accept } = params;
@@ -210,7 +357,7 @@ import {
   PublicKey as PublicKey2,
   TransactionInstruction,
   TransactionMessage,
-  VersionedTransaction
+  VersionedTransaction as VersionedTransaction2
 } from "@solana/web3.js";
 import {
   createTransferCheckedInstruction as createTransferCheckedInstruction2,
@@ -348,7 +495,7 @@ async function payExactSolana(input) {
     recentBlockhash: blockhash,
     instructions
   }).compileToV0Message();
-  const tx = new VersionedTransaction(message);
+  const tx = new VersionedTransaction2(message);
   tx.sign([keypair]);
   const buyerIndex = message.staticAccountKeys.findIndex((k) => k.equals(keypair.publicKey));
   if (buyerIndex < 1 || buyerIndex >= message.header.numRequiredSignatures) {
@@ -396,7 +543,7 @@ async function verifyAndSettleExactSolana(input) {
   const program = tokenProgramFor(accept);
   let tx;
   try {
-    tx = VersionedTransaction.deserialize(Buffer.from(payload.transaction, "base64"));
+    tx = VersionedTransaction2.deserialize(Buffer.from(payload.transaction, "base64"));
   } catch (err) {
     return fail("signature_invalid", `Unparseable SVM transaction: ${shorten(err instanceof Error ? err.message : String(err))}.`);
   }
@@ -582,7 +729,7 @@ async function pollConfirmed(connection, signature) {
 }
 
 // src/drivers/solana/wallet.ts
-import { Keypair as Keypair3 } from "@solana/web3.js";
+import { Keypair as Keypair4 } from "@solana/web3.js";
 import bs582 from "bs58";
 function toKeypair(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
@@ -603,7 +750,7 @@ function toKeypair(wallet, network) {
     }
     try {
       const bytes = typeof sk === "string" ? bs582.decode(sk) : sk;
-      return Keypair3.fromSecretKey(bytes);
+      return Keypair4.fromSecretKey(bytes);
     } catch (err) {
       throw new WrongFamilyError(
         `chain ${network} is Solana; the wallet { key } isn't a valid Solana secret (expected a base58 secret string or a 64-byte Uint8Array): ${err instanceof Error ? err.message : String(err)}.`
@@ -616,6 +763,7 @@ function toKeypair(wallet, network) {
 }
 
 // src/drivers/solana/index.ts
+var RENT_EXEMPT_MIN_LAMPORTS = 890880n;
 var solanaDriver = {
   family: "solana",
   resolve(opts) {
@@ -625,7 +773,7 @@ var solanaDriver = {
   }
 };
 function makeSolanaNetwork(preset, rpcUrl) {
-  const connection = new Connection(rpcUrl, "confirmed");
+  const connection = new Connection2(rpcUrl, "confirmed");
   const network = preset.caip2;
   return {
     family: "solana",
@@ -735,10 +883,20 @@ function makeSolanaNetwork(preset, rpcUrl) {
         detail: "1 signature + recipient token-account rent (~0.00204 SOL, if not already created)"
       });
     },
+    /** 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 wallet._native.publicKey.toBase58();
+    },
     async balanceOf(wallet, asset) {
       const owner = wallet._native.publicKey;
       const native = await connection.getBalance(owner).then((n) => BigInt(n)).catch(() => null);
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const reserve = await connection.getMinimumBalanceForRentExemption(0).then((n) => BigInt(n)).catch(() => RENT_EXEMPT_MIN_LAMPORTS);
+        const spendable = native > reserve ? native - reserve : 0n;
+        return { token: spendable, native };
+      }
       let token;
       try {
         const mint = new PublicKey3(asset);
@@ -764,6 +922,13 @@ function makeSolanaNetwork(preset, rpcUrl) {
     async recipientReady() {
       return { ready: "n/a" };
     },
+    /* ---- swap (OPTIONAL, opt-in): via Jupiter, keyless + no platform fee. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps }) {
+      return quoteSolanaSwap({ network, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      return swapSolana({ connection, keypair: wallet._native, quote });
+    },
     async verify(ref, accept) {
       return verifySolana({ connection, signature: ref, accept });
     },

package/dist/{stellar-E2KWEV2E.cjs → stellar-5GMZJBTA.cjs}

@@ -1,5 +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; }
 
+var _chunkMZXVXC3Ccjs = require('./chunk-MZXVXC3C.cjs');
+
+
 var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
@@ -12,7 +15,8 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunkQONQSZHJcjs = require('./chunk-QONQSZHJ.cjs');
+
+var _chunk6XTNI2OQcjs = require('./chunk-6XTNI2OQ.cjs');
 
 // src/drivers/stellar/index.ts
 var _stellarsdk = require('@stellar/stellar-sdk');
@@ -98,30 +102,30 @@ function mapSubmitError(err) {
   const seen = codes.join(", ");
   const has = (re) => codes.some((c) => re.test(c));
   if (has(/op_no_destination/i)) {
-    return new (0, _chunkQONQSZHJcjs.RecipientNotReadyError)(
+    return new (0, _chunk6XTNI2OQcjs.RecipientNotReadyError)(
       `Stellar destination account doesn't exist yet \u2014 create it with \u22651 XLM (the base reserve) before it can receive. (Stellar: ${seen})`,
       { cause: err }
     );
   }
   if (has(/op_(no_trust|line_full|not_authorized)/i) && !has(/src_no_trust/i)) {
-    return new (0, _chunkQONQSZHJcjs.RecipientNotReadyError)(
+    return new (0, _chunk6XTNI2OQcjs.RecipientNotReadyError)(
       `Stellar destination can't hold this asset \u2014 it needs a trustline for it (and to be authorized) before it can receive. (Stellar: ${seen})`,
       { cause: err }
     );
   }
   if (has(/underfunded|insufficient|low_reserve|src_no_trust/i)) {
-    return new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
+    return new (0, _chunk6XTNI2OQcjs.InsufficientFundsError)(
       `Stellar payment failed: the sender can't cover it \u2014 balance, base reserve, or no trustline to send this asset. (Stellar: ${seen})`,
       { cause: err }
     );
   }
   if (isAccountNotFound(err)) {
-    return new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
+    return new (0, _chunk6XTNI2OQcjs.InsufficientFundsError)(
       "Stellar source account not found on-chain \u2014 fund the sender (\u2265 base reserve) before it can pay.",
       { cause: err }
     );
   }
-  return _nullishCoalesce(_chunkQONQSZHJcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+  return _nullishCoalesce(_chunk6XTNI2OQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
 }
 function isAccountNotFound(err) {
   const e = err;
@@ -133,6 +137,151 @@ function extractResultCodes(err) {
   return [_nullishCoalesce(extras.transaction, () => ( "")), ..._nullishCoalesce(extras.operations, () => ( []))].filter(Boolean);
 }
 
+// src/drivers/stellar/swap.ts
+
+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 _stellarsdk.Asset.native();
+  const parts = parseStellarAssetId(asset);
+  if (!parts) return null;
+  try {
+    return new (0, _stellarsdk.Asset)(parts.code, parts.issuer);
+  } catch (e2) {
+    return null;
+  }
+}
+function hopToAsset(h) {
+  return h.asset_type === "native" ? _stellarsdk.Asset.native() : new (0, _stellarsdk.Asset)(h.asset_code, h.asset_issuer);
+}
+function side(t, amount) {
+  return {
+    asset: t.asset,
+    symbol: _nullishCoalesce(t.symbol, () => ( (t.asset === "native" ? XLM_SYMBOL : t.asset))),
+    decimals: STELLAR_DECIMALS,
+    amount: amount.toString(),
+    amountFormatted: _chunk6XTNI2OQcjs.formatUnits.call(void 0, 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 = _chunk6XTNI2OQcjs.formatUnits.call(void 0, p.wantAmount, STELLAR_DECIMALS);
+  let records;
+  try {
+    const page = await p.server.strictReceivePaths([fromAsset], toAsset, wantFormatted).call();
+    records = page.records;
+  } catch (e3) {
+    return null;
+  }
+  if (!_optionalChain([records, 'optionalAccess', _9 => _9.length])) return null;
+  let best = null;
+  let spend = null;
+  for (const r of records) {
+    let candidate;
+    try {
+      candidate = _chunk6XTNI2OQcjs.parseUnits.call(void 0, r.source_amount, STELLAR_DECIMALS);
+    } catch (e4) {
+      continue;
+    }
+    if (candidate <= 0n) continue;
+    if (spend === null || candidate < spend) {
+      spend = candidate;
+      best = r;
+    }
+  }
+  if (best === null || spend === null) return null;
+  const maxSpend = _chunkMZXVXC3Ccjs.applySlippage.call(void 0, spend, p.slippageBps);
+  return {
+    source: SOURCE,
+    network: p.network,
+    from: side(p.from, spend),
+    to: side(p.to, p.wantAmount),
+    maxSpend: maxSpend.toString(),
+    maxSpendFormatted: _chunk6XTNI2OQcjs.formatUnits.call(void 0, maxSpend, STELLAR_DECIMALS),
+    slippageBps: p.slippageBps,
+    route: _nullishCoalesce(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 (0, _stellarsdk.TransactionBuilder)(source, { fee: _stellarsdk.BASE_FEE, networkPassphrase: STELLAR_PASSPHRASE }).addOperation(
+      _stellarsdk.Operation.pathPaymentStrictReceive({
+        sendAsset,
+        // The on-chain slippage cap. Validators enforce it; we do not.
+        sendMax: _chunk6XTNI2OQcjs.formatUnits.call(void 0, 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 (0, _chunk6XTNI2OQcjs.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 (0, _chunk6XTNI2OQcjs.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 (0, _chunk6XTNI2OQcjs.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 (0, _chunk6XTNI2OQcjs.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 _nullishCoalesce(_chunk6XTNI2OQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+}
+function extractResultCodes2(err) {
+  const extras = _optionalChain([err, 'optionalAccess', _10 => _10.response, 'optionalAccess', _11 => _11.data, 'optionalAccess', _12 => _12.extras, 'optionalAccess', _13 => _13.result_codes]);
+  if (!extras) return [];
+  return [_nullishCoalesce(extras.transaction, () => ( "")), ..._nullishCoalesce(extras.operations, () => ( []))].filter(Boolean);
+}
+
 // src/drivers/stellar/verify.ts
 
 function memoCandidatesForNonce(nonce) {
@@ -148,7 +297,7 @@ async function verifyStellar(params) {
   let txs;
   try {
     txs = await reader.transactionsForAccount(accept.payTo, 200);
-  } catch (e2) {
+  } catch (e5) {
     return rpcFailed(nonce);
   }
   const tx = txs.find(
@@ -173,7 +322,7 @@ async function verifyStellar(params) {
   let payments;
   try {
     payments = await reader.paymentsForTransaction(tx.hash);
-  } catch (e3) {
+  } catch (e6) {
     return rpcFailed(nonce);
   }
   const toUs = payments.filter(
@@ -218,8 +367,8 @@ function assetMatches(p, want) {
 }
 function parseAmount(amount, decimals) {
   try {
-    return _chunkQONQSZHJcjs.parseUnits.call(void 0, amount, decimals);
-  } catch (e4) {
+    return _chunk6XTNI2OQcjs.parseUnits.call(void 0, amount, decimals);
+  } catch (e7) {
     return 0n;
   }
 }
@@ -242,13 +391,13 @@ function rpcFailed(nonce) {
 
 function assertStellarWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
       `chain ${network} is Stellar; wallet must be { key } (S\u2026 seed) or { keypair }.`
     );
   }
-  _chunkQONQSZHJcjs.assertNoLegacyWalletKey.call(void 0, wallet, "Stellar");
+  _chunk6XTNI2OQcjs.assertNoLegacyWalletKey.call(void 0, wallet, "Stellar");
   if (!("key" in wallet) && !("keypair" in wallet)) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
       `chain ${network} is Stellar; wallet must be { key } (S\u2026 seed) or { keypair }.`
     );
   }
@@ -258,18 +407,19 @@ function resolveStellarWallet(config) {
   if (config.keypair) return config.keypair;
   if (config.key) {
     if (!_stellarsdk.StrKey.isValidEd25519SecretSeed(config.key)) {
-      throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Stellar wallet { key } is not a valid S\u2026 secret seed.");
+      throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)("Stellar wallet { key } is not a valid S\u2026 secret seed.");
     }
     return _stellarsdk.Keypair.fromSecret(config.key);
   }
-  throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Stellar wallet needs { key } (S\u2026 seed) or { keypair }.");
+  throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)("Stellar wallet needs { key } (S\u2026 seed) or { keypair }.");
 }
 
 // src/drivers/stellar/index.ts
 function isStellarNotFound(e) {
   const x = e;
-  return _optionalChain([x, 'optionalAccess', _9 => _9.response, 'optionalAccess', _10 => _10.status]) === 404 || _optionalChain([x, 'optionalAccess', _11 => _11.name]) === "NotFoundError";
+  return _optionalChain([x, 'optionalAccess', _14 => _14.response, 'optionalAccess', _15 => _15.status]) === 404 || _optionalChain([x, 'optionalAccess', _16 => _16.name]) === "NotFoundError";
 }
+var STELLAR_BASE_RESERVE = 5000000n;
 var stellarDriver = {
   family: "stellar",
   resolve(opts) {
@@ -317,7 +467,7 @@ function makeStellarNetwork(preset, rpcUrl) {
         const info = preset.tokens[token.toUpperCase()];
         if (!info) {
           const known = Object.keys(preset.tokens).join(", ") || "(none built in)";
-          throw new (0, _chunkQONQSZHJcjs.UnknownTokenError)(
+          throw new (0, _chunk6XTNI2OQcjs.UnknownTokenError)(
             `token "${token}" isn't built in for Stellar (known: ${known}). Pass { issuer, code, decimals } for a custom asset, or use 'native'.`
           );
         }
@@ -327,10 +477,10 @@ function makeStellarNetwork(preset, rpcUrl) {
           symbol: info.symbol
         };
       }
-      _chunkQONQSZHJcjs.rejectForeignToken.call(void 0, token, "stellar", network);
+      _chunk6XTNI2OQcjs.rejectForeignToken.call(void 0, token, "stellar", network);
       const t = token;
       if (!t.issuer || !t.code || typeof t.decimals !== "number") {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Stellar; a custom token must be { issuer, code, decimals }.`
         );
       }
@@ -351,12 +501,12 @@ function makeStellarNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Stellar, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       if (!_stellarsdk.StrKey.isValidEd25519PublicKey(payTo)) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Stellar, but payTo "${payTo}" is not a valid Stellar account (G\u2026).`
         );
       }
@@ -373,14 +523,14 @@ function makeStellarNetwork(preset, rpcUrl) {
         try {
           const tx = await server.transactions().transaction(ref).call();
           return { height: String(_nullishCoalesce(_nullishCoalesce(tx.ledger_attr, () => ( tx.ledger)), () => ( 0))) };
-        } catch (e5) {
+        } catch (e8) {
           await _chunkCQREG5LEcjs.delay.call(void 0, 1500);
         }
       }
-      throw new (0, _chunkQONQSZHJcjs.ConfirmationTimeoutError)(`Stellar tx ${ref} not visible on Horizon in time.`);
+      throw new (0, _chunk6XTNI2OQcjs.ConfirmationTimeoutError)(`Stellar tx ${ref} not visible on Horizon in time.`);
     },
     async estimateCost() {
-      return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
+      return _chunk6XTNI2OQcjs.nativeCost.call(void 0, {
         symbol: XLM_SYMBOL,
         decimals: STELLAR_DECIMALS,
         fee: 100n,
@@ -388,34 +538,46 @@ 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 {
         owner = resolveStellarWallet(wallet._native).publicKey();
-      } catch (e6) {
+      } catch (e9) {
         return { token: null, native: null };
       }
       let lines;
+      let subentryCount;
       try {
         const account = await server.loadAccount(owner);
         lines = account.balances;
+        subentryCount = account.subentry_count;
       } catch (e) {
         return isStellarNotFound(e) ? { token: 0n, native: 0n } : { token: null, native: null };
       }
       const toBase = (s) => {
         try {
-          return s != null ? _chunkQONQSZHJcjs.parseUnits.call(void 0, s, STELLAR_DECIMALS) : 0n;
-        } catch (e7) {
+          return s != null ? _chunk6XTNI2OQcjs.parseUnits.call(void 0, s, STELLAR_DECIMALS) : 0n;
+        } catch (e10) {
           return 0n;
         }
       };
-      const native = toBase(_optionalChain([lines, 'access', _12 => _12.find, 'call', _13 => _13((b) => b.asset_type === "native"), 'optionalAccess', _14 => _14.balance]));
-      if (asset === "native") return { token: native, native };
+      const native = toBase(_optionalChain([lines, 'access', _17 => _17.find, 'call', _18 => _18((b) => b.asset_type === "native"), 'optionalAccess', _19 => _19.balance]));
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const subentries = BigInt(_nullishCoalesce(subentryCount, () => ( 0)));
+        const min = (2n + subentries) * STELLAR_BASE_RESERVE;
+        return { token: native > min ? native - min : 0n, native };
+      }
       const parts = parseStellarAssetId(asset);
       const line = parts ? lines.find(
         (b) => (b.asset_type === "credit_alphanum4" || b.asset_type === "credit_alphanum12") && b.asset_code === parts.code && b.asset_issuer === parts.issuer
       ) : void 0;
-      return { token: toBase(_optionalChain([line, 'optionalAccess', _15 => _15.balance])), native };
+      return { token: toBase(_optionalChain([line, 'optionalAccess', _20 => _20.balance])), native };
     },
     async recipientReady(payTo, asset) {
       let lines;
@@ -434,6 +596,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 });
     }