@piprail/sdk 2.16.2 → 3.0.0

package/dist/{near-OLKCMTBI.js → near-5X2CQGML.js}

@@ -1,3 +1,6 @@
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   ConfirmationTimeoutError,
   InsufficientFundsError,
@@ -7,10 +10,11 @@ import {
   UnsupportedSchemeError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/near/index.ts
 import { JsonRpcProvider, Account, actions as actions2 } from "near-api-js";
@@ -435,6 +439,160 @@ function resolveNearWallet(config) {
   return { accountId: config.accountId, signer };
 }
 
+// src/drivers/near/swap.ts
+var REF_EXCHANGE = "v2.ref-finance.near";
+var WRAP_NEAR = "wrap.near";
+var REF_INDEXER = "https://indexer.ref.finance";
+function sourceFor(feeBps) {
+  const fee = feeBps === null ? "the pool's own fee" : `${(feeBps / 100).toFixed(2)}%`;
+  return {
+    kind: "provider",
+    name: "Ref Finance",
+    note: `Third-party NEAR AMM (v2.ref-finance.near), used keyless over the chain's own RPC. The swap is one ft_transfer_call receipt chain, so no solver ever takes possession of the funds, which is why this is used instead of an intent network. Pool fee on this route: ${fee}. PipRail adds nothing.`
+  };
+}
+function refToken(t) {
+  return t.asset === "native" ? WRAP_NEAR : t.asset;
+}
+function side(t, amount) {
+  const decimals = t.asset === "native" ? NEAR_DECIMALS : t.decimals;
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? "NEAR" : t.asset),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, decimals)
+  };
+}
+async function getJson(url) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 12e3);
+  try {
+    const res = await fetch(url, { signal: ctrl.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function findPools(tokenIn, tokenOut) {
+  const all = await getJson(`${REF_INDEXER}/list-top-pools`);
+  if (!Array.isArray(all)) return [];
+  return all.filter(
+    (p) => Array.isArray(p.token_account_ids) && p.token_account_ids.includes(tokenIn) && p.token_account_ids.includes(tokenOut)
+  ).sort((a, b) => Number(b.tvl ?? 0) - Number(a.tvl ?? 0)).slice(0, 4).map((p) => ({ ...p, id: Number(p.id) }));
+}
+async function quoteNearSwap(p) {
+  if (p.wantAmount <= 0n) return null;
+  const tokenIn = refToken(p.from);
+  const tokenOut = refToken(p.to);
+  if (tokenIn === tokenOut) return null;
+  const pools = await findPools(tokenIn, tokenOut);
+  if (!pools.length) return null;
+  const fromDecimals = p.from.asset === "native" ? NEAR_DECIMALS : p.from.decimals;
+  const probeIn = 10n ** BigInt(Math.max(fromDecimals - 2, 1));
+  const getReturn = async (poolId, amountIn) => {
+    try {
+      const out = await p.client.view(REF_EXCHANGE, "get_return", {
+        pool_id: poolId,
+        token_in: tokenIn,
+        amount_in: amountIn.toString(),
+        token_out: tokenOut
+      });
+      const s = String(out ?? "");
+      return s && /^\d+$/.test(s) ? BigInt(s) : null;
+    } catch {
+      return null;
+    }
+  };
+  for (const pool of pools) {
+    const probeOut = await getReturn(pool.id, probeIn);
+    if (probeOut === null || probeOut <= 0n) continue;
+    let needIn = (probeIn * p.wantAmount + probeOut - 1n) / probeOut;
+    needIn = applySlippage(needIn, p.slippageBps);
+    const realOut = await getReturn(pool.id, needIn);
+    if (realOut === null) continue;
+    if (realOut < p.wantAmount) continue;
+    const minOut = p.wantAmount;
+    return {
+      source: sourceFor(typeof pool.total_fee === "number" ? pool.total_fee : null),
+      network: p.network,
+      from: side(p.from, needIn),
+      to: side(p.to, realOut),
+      maxSpend: needIn.toString(),
+      maxSpendFormatted: formatUnits(needIn, fromDecimals),
+      slippageBps: p.slippageBps,
+      route: {
+        poolId: pool.id,
+        tokenIn,
+        tokenOut,
+        amountIn: needIn.toString(),
+        minAmountOut: minOut.toString()
+      }
+    };
+  }
+  return null;
+}
+async function swapNear(p) {
+  const route = p.quote.route;
+  if (!route?.poolId || !route.tokenIn) {
+    throw new Error("NEAR: swap quote is missing its Ref routing data \u2014 re-quote before swapping.");
+  }
+  const msg = JSON.stringify({
+    force: 0,
+    actions: [
+      {
+        pool_id: route.poolId,
+        token_in: route.tokenIn,
+        token_out: route.tokenOut,
+        amount_in: route.amountIn,
+        min_amount_out: route.minAmountOut
+      }
+    ]
+  });
+  try {
+    const tx = await p.call({
+      contractId: route.tokenIn,
+      method: "ft_transfer_call",
+      args: { receiver_id: REF_EXCHANGE, amount: route.amountIn, msg },
+      // NEP-141 transfer_call into an AMM needs generous gas: 180 TGas.
+      gas: 180000000000000n,
+      // ft_transfer_call requires exactly 1 yoctoNEAR as a signing assertion.
+      deposit: 1n
+    });
+    return {
+      transaction: tx,
+      network: p.quote.network,
+      source: p.quote.source,
+      from: p.quote.from,
+      to: p.quote.to
+    };
+  } catch (err) {
+    const msgText = String(err?.message ?? err);
+    if (/storage|not registered|NotRegistered/i.test(msgText)) {
+      throw new RecipientNotReadyError(
+        "NEAR swap refused: your account is not storage-registered on the token you are swapping INTO. Call storage_deposit on that token contract first (about 0.00125 NEAR).",
+        { cause: err }
+      );
+    }
+    if (/ERR_MIN_AMOUNT|slippage/i.test(msgText)) {
+      throw new InsufficientFundsError(
+        "NEAR swap refused: the pool could not deliver the minimum output, so the tokens were returned. Re-quote and retry.",
+        { cause: err }
+      );
+    }
+    if (/insufficient|balance|exceeded/i.test(msgText)) {
+      throw new InsufficientFundsError(
+        `NEAR swap failed: the account can't cover it (token balance or NEAR for gas). (${msgText.slice(0, 160)})`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+
 // src/drivers/near/index.ts
 var nearDriver = {
   family: "near",
@@ -587,6 +745,11 @@ function makeNearNetwork(preset, rpcUrl) {
         detail: "~14 TGas for ft_transfer (\u22480.0015 NEAR) + 1 yoctoNEAR deposit"
       });
     },
+    /** 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 resolveNearWallet(wallet._native).accountId;
+    },
     async balanceOf(wallet, asset) {
       let accountId;
       try {
@@ -637,6 +800,39 @@ function makeNearNetwork(preset, rpcUrl) {
         return { ready: "unknown" };
       }
     },
+    /* ---- swap (OPTIONAL, opt-in): via Ref Finance, keyless over the chain's own RPC.
+           Chosen over NEAR Intents because Intents re-adds a facilitator. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps }) {
+      const viewClient = {
+        async view(contractId, method, args) {
+          const r = await provider.query({
+            request_type: "call_function",
+            finality: "final",
+            account_id: contractId,
+            method_name: method,
+            args_base64: Buffer.from(JSON.stringify(args)).toString("base64")
+          });
+          return r.result ? JSON.parse(Buffer.from(r.result).toString()) : null;
+        }
+      };
+      return quoteNearSwap({ client: viewClient, network, from, to, wantAmount, slippageBps });
+    },
+    async swap(wallet, quote) {
+      const { accountId, signer } = resolveNearWallet(wallet._native);
+      const account = new Account(accountId, provider, signer);
+      return swapNear({
+        quote,
+        async call({ contractId, method, args, gas, deposit }) {
+          const outcome = await account.signAndSendTransaction({
+            receiverId: contractId,
+            actions: [actions2.functionCall(method, args, gas, deposit)]
+          });
+          const hash = outcome.transaction?.hash;
+          if (!hash) throw new Error("NEAR: signAndSendTransaction returned no tx hash.");
+          return hash;
+        }
+      });
+    },
     async verify(ref, accept) {
       const { senderId, hash } = decodeRef(ref);
       return verifyNear({ reader, hash, senderId, accept });