@piprail/sdk 2.16.2 → 3.0.0

package/dist/{tron-FXBXDNEY.js → tron-HG3IOOCG.js}

@@ -1,3 +1,6 @@
+import {
+  applySlippage
+} from "./chunk-GVCGUSTE.js";
 import {
   delay
 } from "./chunk-FURB5RP7.js";
@@ -7,10 +10,11 @@ import {
   UnknownTokenError,
   WrongFamilyError,
   assertNoLegacyWalletKey,
+  formatUnits,
   nativeCost,
   rejectForeignToken,
   toInsufficientFundsError
-} from "./chunk-QU25LSVS.js";
+} from "./chunk-5GRBEMCA.js";
 
 // src/drivers/tron/index.ts
 import { TronWeb } from "tronweb";
@@ -121,6 +125,257 @@ function isTronAffordability(code, message) {
   return /balance is not sufficient|insufficient (funds|balance|energy)|not enough/i.test(decoded);
 }
 
+// src/drivers/tron/swap.ts
+var SUNSWAP_V2_ROUTER = "TKzxdSv2FZKQrEqkKVgp5DcwEXBEKMg2Ax";
+var WTRX = "TNUC9Qb1rRpS5CbWLmNMxXBjyFoydXjWFR";
+var TRX_SYMBOL = "TRX";
+var TRON_SWAP_ENERGY = 230629;
+var FEE_LIMIT_SUN = 4e7;
+var APPROVE_FEE_LIMIT_SUN = 2e7;
+var APPROVE_TIMEOUT_MS = 6e4;
+var APPROVE_POLL_MS = 3e3;
+var DEADLINE_SECONDS = 300;
+function sourceFor(needsApproval) {
+  return {
+    kind: "provider",
+    name: "SunSwap V2",
+    note: "Third-party Tron DEX (SunSwap V2), called contract-to-contract with no API and no API key: the quote is a constant contract call and the swap is a router call your own key signs. Cost on this route: the pool's own 0.30% constant-product fee. PipRail adds nothing, and the router has no fee parameter to add. Note Tron charges roughly 23 TRX of ENERGY per swap regardless of size, which is usually the dominant cost" + (needsApproval ? ", and selling a TRC-20 costs a second transaction on top: an approve to the router, about another 10 TRX the first time, so budget roughly 33 TRX for this direction." : "; selling native TRX needs no approval, so this is a single transaction.")
+  };
+}
+function pathFor(from, to) {
+  const a = from.asset === "native" ? WTRX : from.asset;
+  const b = to.asset === "native" ? WTRX : to.asset;
+  return [a, b];
+}
+function side(t, amount) {
+  const decimals = t.asset === "native" ? TRX_DECIMALS : t.decimals;
+  return {
+    asset: t.asset,
+    symbol: t.symbol ?? (t.asset === "native" ? TRX_SYMBOL : t.asset),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: formatUnits(amount, decimals)
+  };
+}
+function decodeUintArray(hex) {
+  try {
+    if (!hex) return null;
+    const words = hex.match(/.{64}/g);
+    if (!words || words.length < 3) return null;
+    const len = Number(BigInt("0x" + words[1]));
+    if (!Number.isSafeInteger(len) || len < 2) return null;
+    const vals = words.slice(2, 2 + len).map((w) => BigInt("0x" + w));
+    return vals.length === len ? vals : null;
+  } catch {
+    return null;
+  }
+}
+async function quoteTronSwap(p) {
+  if (p.wantAmount <= 0n) return null;
+  const path = pathFor(p.from, p.to);
+  if (path[0] === path[1]) return null;
+  let amounts = null;
+  try {
+    const res = await p.client.transactionBuilder.triggerConstantContract(
+      SUNSWAP_V2_ROUTER,
+      "getAmountsIn(uint256,address[])",
+      {},
+      [
+        { type: "uint256", value: p.wantAmount.toString() },
+        { type: "address[]", value: path }
+      ],
+      p.owner
+    );
+    if (res?.result?.result !== true) return null;
+    amounts = decodeUintArray(res.constant_result?.[0]);
+  } catch {
+    return null;
+  }
+  if (!amounts?.length) return null;
+  const amountIn = amounts[0];
+  if (amountIn === void 0 || amountIn <= 0n) return null;
+  const amountInMax = applySlippage(amountIn, p.slippageBps);
+  return {
+    source: sourceFor(p.from.asset !== "native"),
+    network: p.network,
+    from: side(p.from, amountIn),
+    to: side(p.to, p.wantAmount),
+    maxSpend: amountInMax.toString(),
+    maxSpendFormatted: formatUnits(amountInMax, p.from.asset === "native" ? TRX_DECIMALS : p.from.decimals),
+    slippageBps: p.slippageBps,
+    route: {
+      router: SUNSWAP_V2_ROUTER,
+      path,
+      amountInMax: amountInMax.toString(),
+      fromIsNative: p.from.asset === "native",
+      toIsNative: p.to.asset === "native",
+      needsApproval: p.from.asset !== "native",
+      tokenIn: p.from.asset === "native" ? "" : p.from.asset
+    }
+  };
+}
+async function readAllowance(client, token, owner, spender) {
+  try {
+    const res = await client.transactionBuilder.triggerConstantContract(
+      token,
+      "allowance(address,address)",
+      {},
+      [
+        { type: "address", value: owner },
+        { type: "address", value: spender }
+      ],
+      owner
+    );
+    if (res?.result?.result !== true) return 0n;
+    const raw = res.constant_result?.[0];
+    return raw ? BigInt("0x" + raw.slice(0, 64)) : 0n;
+  } catch {
+    return 0n;
+  }
+}
+async function sendAndConfirm(client, contract, selector, params, owner, privateKey, feeLimit) {
+  const built = await client.transactionBuilder.triggerSmartContract(
+    contract,
+    selector,
+    { feeLimit },
+    params,
+    owner
+  );
+  if (built?.result?.result !== true) {
+    throw new Error(built?.result?.message ?? `Tron: ${selector} could not be built`);
+  }
+  const signed = await client.trx.sign(built.transaction, privateKey);
+  const broadcast = await client.trx.sendRawTransaction(signed);
+  if (broadcast?.result === false || broadcast?.code) {
+    throw new Error(`${broadcast.code ?? "broadcast failed"}: ${broadcast.message ?? ""}`);
+  }
+  const txid = broadcast?.txid ?? broadcast?.transaction?.txID ?? signed.txID;
+  const deadline = Date.now() + APPROVE_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, APPROVE_POLL_MS));
+    let info = null;
+    try {
+      info = await client.trx.getTransactionInfo(txid);
+    } catch {
+      continue;
+    }
+    const result = info?.receipt?.result;
+    if (!result) continue;
+    if (result !== "SUCCESS") {
+      throw new Error(`Tron: ${selector} failed on-chain (${result}, tx ${txid})`);
+    }
+    return txid;
+  }
+  throw new Error(`Tron: ${selector} was not confirmed within ${APPROVE_TIMEOUT_MS / 1e3}s (tx ${txid})`);
+}
+function safeCallValue(sun) {
+  const n = Number(sun);
+  if (!Number.isSafeInteger(n)) {
+    throw new InsufficientFundsError(
+      `Tron: a native input of ${sun} sun exceeds the largest amount that can be sent without rounding. Split the swap into smaller amounts.`
+    );
+  }
+  return n;
+}
+async function swapTron(p) {
+  const route = p.quote.route;
+  if (!route?.router || !route.path?.length) {
+    throw new Error("Tron: swap quote is missing its SunSwap routing data \u2014 re-quote before swapping.");
+  }
+  const amountOut = BigInt(p.quote.to.amount);
+  const amountInMax = BigInt(route.amountInMax);
+  const deadline = Math.floor(Date.now() / 1e3) + DEADLINE_SECONDS;
+  const selector = route.fromIsNative ? "swapETHForExactTokens(uint256,address[],address,uint256)" : route.toIsNative ? "swapTokensForExactETH(uint256,uint256,address[],address,uint256)" : "swapTokensForExactTokens(uint256,uint256,address[],address,uint256)";
+  const params = route.fromIsNative ? [
+    { type: "uint256", value: amountOut.toString() },
+    { type: "address[]", value: route.path },
+    { type: "address", value: p.owner },
+    { type: "uint256", value: deadline }
+  ] : [
+    { type: "uint256", value: amountOut.toString() },
+    { type: "uint256", value: amountInMax.toString() },
+    { type: "address[]", value: route.path },
+    { type: "address", value: p.owner },
+    { type: "uint256", value: deadline }
+  ];
+  try {
+    if (route.needsApproval && route.tokenIn) {
+      const allowance = await readAllowance(p.client, route.tokenIn, p.owner, route.router);
+      if (allowance < amountInMax) {
+        if (allowance > 0n) {
+          await sendAndConfirm(
+            p.client,
+            route.tokenIn,
+            "approve(address,uint256)",
+            [
+              { type: "address", value: route.router },
+              { type: "uint256", value: "0" }
+            ],
+            p.owner,
+            p.privateKey,
+            APPROVE_FEE_LIMIT_SUN
+          );
+        }
+        await sendAndConfirm(
+          p.client,
+          route.tokenIn,
+          "approve(address,uint256)",
+          [
+            { type: "address", value: route.router },
+            { type: "uint256", value: amountInMax.toString() }
+          ],
+          p.owner,
+          p.privateKey,
+          APPROVE_FEE_LIMIT_SUN
+        );
+      }
+    }
+    const built = await p.client.transactionBuilder.triggerSmartContract(
+      route.router,
+      selector,
+      {
+        feeLimit: FEE_LIMIT_SUN,
+        /*
+         * A native input is sent as callValue, capped at the ceiling: the router refunds
+         * whatever the exact-output trade did not need.
+         *
+         * TronWeb's callValue is a JS number, so a value past 2^53 would be silently rounded
+         * and the swap would spend an amount nobody chose. That is ~9 billion TRX, far more
+         * than anyone will ever swap, but a payment library must never round money quietly.
+         */
+        ...route.fromIsNative ? { callValue: safeCallValue(amountInMax) } : {}
+      },
+      params,
+      p.owner
+    );
+    if (built?.result?.result !== true) {
+      throw new Error(built?.result?.message ?? "SunSwap router refused to build the swap");
+    }
+    const signed = await p.client.trx.sign(built.transaction, p.privateKey);
+    const broadcast = await p.client.trx.sendRawTransaction(signed);
+    if (broadcast?.result === false || broadcast?.code) {
+      throw new Error(`${broadcast.code ?? "broadcast failed"}: ${broadcast.message ?? ""}`);
+    }
+    const txid = broadcast?.txid ?? broadcast?.transaction?.txID ?? signed.txID;
+    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 (/energy|bandwidth|balance|insufficient|OUT_OF_ENERGY/i.test(msg)) {
+      throw new InsufficientFundsError(
+        `Tron swap failed: the account cannot cover it. Note a SunSwap swap burns about ${TRON_SWAP_ENERGY.toLocaleString("en-US")} energy, which without staked energy is charged as roughly 23 TRX regardless of trade size. (${msg.slice(0, 140)})`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+
 // src/drivers/tron/verify.ts
 var TRANSFER_TOPIC = "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
 async function verifyTron(params) {
@@ -464,6 +719,13 @@ function makeTronNetwork(preset, rpcUrl) {
         detail: "~30k energy + bandwidth (sender not staked; pass { from } for a precise estimate)"
       });
     },
+    /** 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) {
+      const addr = tronWeb.address.fromPrivateKey(resolveTronPrivateKey(wallet._native));
+      if (!addr) throw new WrongFamilyError(`chain ${network}: the Tron wallet key is not a valid private key.`);
+      return addr;
+    },
     async balanceOf(wallet, asset) {
       const owner = tronWeb.address.fromPrivateKey(
         resolveTronPrivateKey(wallet._native)
@@ -489,6 +751,26 @@ function makeTronNetwork(preset, rpcUrl) {
       return { token, native };
     },
     // No receive prerequisite — any Tron account receives TRX/TRC-20 immediately.
+    /* ---- swap (OPTIONAL, opt-in): via SunSwap V2, no API, no key, no added fee. See ./swap.ts ---- */
+    async quoteSwap({ from, to, wantAmount, slippageBps, wallet }) {
+      const owner = tronWeb.address.fromPrivateKey(resolveTronPrivateKey(wallet._native));
+      if (!owner) return null;
+      return quoteTronSwap({
+        client: tronWeb,
+        network,
+        from,
+        to,
+        wantAmount,
+        slippageBps,
+        owner
+      });
+    },
+    async swap(wallet, quote) {
+      const privateKey = resolveTronPrivateKey(wallet._native);
+      const owner = tronWeb.address.fromPrivateKey(privateKey);
+      if (!owner) throw new Error("Tron: could not derive the payer address from the wallet key.");
+      return swapTron({ client: tronWeb, owner, privateKey, quote });
+    },
     async recipientReady() {
       return { ready: "n/a" };
     },