@piprail/sdk 2.16.2 → 3.1.0

package/dist/{algorand-25FMBCT3.js → algorand-KJ5XHSMT.js}

@@ -1,6 +1,9 @@
 import {
   ALGORAND_SPEC_CAIP2
-} from "./chunk-2CX7XRZK.js";
+} from "./chunk-TZDVZCTC.js";
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   ConfirmationTimeoutError,
   InsufficientFundsError,
@@ -10,10 +13,11 @@ import {
   UnsupportedSchemeError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/algorand/index.ts
 import algosdk3 from "algosdk";
@@ -86,6 +90,144 @@ function firstLine(message) {
   return message.split("\n")[0].slice(0, 160);
 }
 
+// src/drivers/algorand/swap.ts
+var VESTIGE_API = "https://api.vestigelabs.org";
+var ALGO_ASA = 0;
+function sourceFor(poolFee) {
+  const fee = typeof poolFee === "number" ? `${(poolFee * 100).toFixed(2)}%` : "the pool's own fee";
+  return {
+    kind: "provider",
+    name: "Vestige",
+    note: `Third-party Algorand DEX aggregator (api.vestigelabs.org), used keyless. It returns an UNSIGNED atomic transaction group in which every signer is you: nobody co-signs and nothing is delegated. Pool fee on this route: ${fee}. PipRail adds nothing.`
+  };
+}
+function asaId(t) {
+  if (t.asset === "native") return ALGO_ASA;
+  const n = Number(t.asset);
+  return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
+function side(t, amount) {
+  const decimals = t.asset === "native" ? ALGO_DECIMALS : t.decimals;
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? "ALGO" : t.asset),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, decimals)
+  };
+}
+async function req(url, init) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 15e3);
+  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 quoteAlgorandSwap(p) {
+  if (p.wantAmount <= 0n) return null;
+  const fromAsa = asaId(p.from);
+  const toAsa = asaId(p.to);
+  if (fromAsa === null || toAsa === null || fromAsa === toAsa) return null;
+  const quoteFor = (amountIn) => req(
+    `${VESTIGE_API}/swap/v4?from_asa=${fromAsa}&to_asa=${toAsa}&amount=${amountIn.toString()}&mode=sef&denominating_asset_id=0`
+  );
+  const fromDecimals = p.from.asset === "native" ? ALGO_DECIMALS : p.from.decimals;
+  let probeIn = 10n ** BigInt(Math.max(fromDecimals - 2, 1));
+  let probeOut = 0;
+  for (let step = 0; step < 4; step += 1) {
+    const probe = await quoteFor(probeIn);
+    const out = probe?.amount_out;
+    if (out && out > 0) {
+      probeOut = out;
+      break;
+    }
+    probeIn *= 10n;
+  }
+  if (!probeOut) return null;
+  let needIn = (probeIn * p.wantAmount + BigInt(probeOut) - 1n) / BigInt(probeOut);
+  needIn = applySlippage(needIn, p.slippageBps);
+  const real = await quoteFor(needIn);
+  const realOut = real?.amount_out;
+  if (!realOut) return null;
+  if (BigInt(Math.floor(realOut)) < p.wantAmount) return null;
+  const poolFee = real.single?.transactions?.[0]?.swaps?.[0]?.fee;
+  return {
+    source: sourceFor(poolFee),
+    network: p.network,
+    from: side(p.from, needIn),
+    to: side(p.to, BigInt(Math.floor(realOut))),
+    maxSpend: needIn.toString(),
+    maxSpendFormatted: formatUnits(needIn, fromDecimals),
+    slippageBps: p.slippageBps,
+    // The build endpoint wants the ENTIRE quote response back, unmodified.
+    route: { quote: real }
+  };
+}
+async function swapAlgorand(p) {
+  const route = p.quote.route;
+  if (!route?.quote) {
+    throw new Error("Algorand: swap quote is missing its Vestige routing data \u2014 re-quote before swapping.");
+  }
+  const slippage = p.quote.slippageBps / 1e4;
+  const unsigned = await req(
+    `${VESTIGE_API}/swap/v4/transactions?sender=${p.signer.addr}&slippage=${slippage}`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(route.quote)
+    }
+  );
+  if (!unsigned?.length) {
+    throw new RecipientNotReadyError(
+      "Vestige could not build this swap. The usual cause is that your account is not opted in to the asset you are swapping INTO: opt in first, then re-quote. Nothing was spent."
+    );
+  }
+  for (const t of unsigned) {
+    if (t.signers && t.signers.some((s) => s !== p.signer.addr)) {
+      throw new Error(
+        "Algorand swap refused: the built group asks a third party to co-sign, which this rail must never do. Nothing was signed."
+      );
+    }
+  }
+  try {
+    const signed = unsigned.map((t) => {
+      const decoded = p.algosdk.decodeUnsignedTransaction(Buffer.from(t.txn, "base64"));
+      return decoded.signTxn(p.signer.sk);
+    });
+    const res = await p.algod.sendRawTransaction(signed).do();
+    const txid = res.txid ?? res.txId;
+    if (!txid) throw new Error("Algorand: sendRawTransaction returned no transaction id.");
+    return {
+      transaction: txid,
+      network: p.quote.network,
+      source: p.quote.source,
+      from: p.quote.from,
+      to: p.quote.to
+    };
+  } catch (err) {
+    const msg = String(err?.message ?? err);
+    if (/asset .* missing|not opted in|receiver error/i.test(msg)) {
+      throw new RecipientNotReadyError(
+        `Algorand swap refused: your account must opt in to the asset you are swapping INTO first. (${msg.slice(0, 140)})`,
+        { cause: err }
+      );
+    }
+    if (/overspend|insufficient|below min/i.test(msg)) {
+      throw new InsufficientFundsError(
+        `Algorand swap failed: the account can't cover it (balance, the 0.1 ALGO minimum, or group fees). (${msg.slice(0, 140)})`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+
 // src/drivers/algorand/exact.ts
 import algosdk from "algosdk";
 var ZERO_ADDRESS = algosdk.Address.zeroAddress().toString();
@@ -408,6 +550,8 @@ function resolveAlgorandWallet(config) {
 }
 
 // src/drivers/algorand/index.ts
+var ALGO_MIN_BALANCE = 100000n;
+var ALGO_MIN_BALANCE_PER_ASSET = 100000n;
 var algorandDriver = {
   family: "algorand",
   resolve(opts) {
@@ -556,6 +700,11 @@ function makeAlgorandNetwork(preset, algodUrl) {
         detail: "min fee 1000 \xB5Algos (1 transaction)"
       });
     },
+    /** 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 String(resolveAlgorandWallet(wallet._native).addr);
+    },
     async balanceOf(wallet, asset) {
       let owner;
       try {
@@ -570,7 +719,11 @@ function makeAlgorandNetwork(preset, algodUrl) {
         return { token: null, native: null };
       }
       const native = info.amount != null ? BigInt(info.amount) : null;
-      if (asset === "native") return { token: native, native };
+      if (asset === "native") {
+        if (native === null) return { token: null, native };
+        const min = info.minBalance != null ? BigInt(info.minBalance) : ALGO_MIN_BALANCE + ALGO_MIN_BALANCE_PER_ASSET * BigInt((info.assets ?? []).length);
+        return { token: native > min ? native - min : 0n, native };
+      }
       const assetId = parseAlgorandAssetId(asset);
       const holding = (info.assets ?? []).find((a) => Number(a.assetId) === assetId);
       return { token: holding ? BigInt(holding.amount) : 0n, native };
@@ -590,6 +743,14 @@ function makeAlgorandNetwork(preset, algodUrl) {
         return { ready: "unknown" };
       }
     },
+    /* ---- swap (OPTIONAL, opt-in): via Vestige, keyless + no integrator fee. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps }) {
+      return quoteAlgorandSwap({ network, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      const signer = resolveAlgorandWallet(wallet._native);
+      return swapAlgorand({ algosdk: algosdk3, algod, signer, quote });
+    },
     async verify(_ref, accept) {
       return verifyAlgorand({ reader, accept });
     },