@piprail/sdk 2.16.2 → 3.0.0

package/dist/{tron-HIPMOX7S.cjs → tron-S4WX7OHY.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');
 
 
@@ -10,7 +13,8 @@ var _chunkCQREG5LEcjs = require('./chunk-CQREG5LE.cjs');
 
 
 
-var _chunkQONQSZHJcjs = require('./chunk-QONQSZHJ.cjs');
+
+var _chunk6XTNI2OQcjs = require('./chunk-6XTNI2OQ.cjs');
 
 // src/drivers/tron/index.ts
 var _tronweb = require('tronweb');
@@ -62,7 +66,7 @@ async function payTron(params) {
       return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _7 => _7.transaction, 'optionalAccess', _8 => _8.txID]))), () => ( signed.txID));
     }
     if (isTronAffordability(broadcast.code, broadcast.message)) {
-      throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
+      throw new (0, _chunk6XTNI2OQcjs.InsufficientFundsError)(
         `Tron payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for energy/bandwidth, or insufficient token balance.`
       );
     }
@@ -70,15 +74,15 @@ async function payTron(params) {
       `Tron broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunkQONQSZHJcjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunkQONQSZHJcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunk6XTNI2OQcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunk6XTNI2OQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 async function payTronNative(params) {
   const { client, from, privateKey, accept } = params;
   const sun = BigInt(accept.amount);
   if (sun > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
+    throw new (0, _chunk6XTNI2OQcjs.InsufficientFundsError)(
       `Tron native amount ${accept.amount} sun exceeds the safe-integer range tronweb.sendTrx accepts \u2014 price this resource in a smaller native amount or a TRC-20 token.`
     );
   }
@@ -90,7 +94,7 @@ async function payTronNative(params) {
       return _nullishCoalesce(_nullishCoalesce(broadcast.txid, () => ( _optionalChain([broadcast, 'access', _11 => _11.transaction, 'optionalAccess', _12 => _12.txID]))), () => ( signed.txID));
     }
     if (isTronAffordability(broadcast.code, broadcast.message)) {
-      throw new (0, _chunkQONQSZHJcjs.InsufficientFundsError)(
+      throw new (0, _chunk6XTNI2OQcjs.InsufficientFundsError)(
         `Tron TRX payment rejected (${_nullishCoalesce(broadcast.code, () => ( "broadcast"))}): not enough TRX for the amount plus bandwidth (and the ~1 TRX account-creation fee if the recipient is new).`
       );
     }
@@ -98,8 +102,8 @@ async function payTronNative(params) {
       `Tron TRX broadcast failed: ${_nullishCoalesce(broadcast.code, () => ( ""))} ${decodeMaybeHex(broadcast.message)}`.trim()
     );
   } catch (err) {
-    if (err instanceof _chunkQONQSZHJcjs.InsufficientFundsError) throw err;
-    throw _nullishCoalesce(_chunkQONQSZHJcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
+    if (err instanceof _chunk6XTNI2OQcjs.InsufficientFundsError) throw err;
+    throw _nullishCoalesce(_chunk6XTNI2OQcjs.toInsufficientFundsError.call(void 0, err), () => ( err));
   }
 }
 function decodeMaybeHex(message) {
@@ -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: _nullishCoalesce(t.symbol, () => ( (t.asset === "native" ? TRX_SYMBOL : t.asset))),
+    decimals,
+    amount: amount.toString(),
+    amountFormatted: _chunk6XTNI2OQcjs.formatUnits.call(void 0, 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 (e2) {
+    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 (_optionalChain([res, 'optionalAccess', _13 => _13.result, 'optionalAccess', _14 => _14.result]) !== true) return null;
+    amounts = decodeUintArray(_optionalChain([res, 'access', _15 => _15.constant_result, 'optionalAccess', _16 => _16[0]]));
+  } catch (e3) {
+    return null;
+  }
+  if (!_optionalChain([amounts, 'optionalAccess', _17 => _17.length])) return null;
+  const amountIn = amounts[0];
+  if (amountIn === void 0 || amountIn <= 0n) return null;
+  const amountInMax = _chunkMZXVXC3Ccjs.applySlippage.call(void 0, 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: _chunk6XTNI2OQcjs.formatUnits.call(void 0, 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 (_optionalChain([res, 'optionalAccess', _18 => _18.result, 'optionalAccess', _19 => _19.result]) !== true) return 0n;
+    const raw = _optionalChain([res, 'access', _20 => _20.constant_result, 'optionalAccess', _21 => _21[0]]);
+    return raw ? BigInt("0x" + raw.slice(0, 64)) : 0n;
+  } catch (e4) {
+    return 0n;
+  }
+}
+async function sendAndConfirm(client, contract, selector, params, owner, privateKey, feeLimit) {
+  const built = await client.transactionBuilder.triggerSmartContract(
+    contract,
+    selector,
+    { feeLimit },
+    params,
+    owner
+  );
+  if (_optionalChain([built, 'optionalAccess', _22 => _22.result, 'optionalAccess', _23 => _23.result]) !== true) {
+    throw new Error(_nullishCoalesce(_optionalChain([built, 'optionalAccess', _24 => _24.result, 'optionalAccess', _25 => _25.message]), () => ( `Tron: ${selector} could not be built`)));
+  }
+  const signed = await client.trx.sign(built.transaction, privateKey);
+  const broadcast = await client.trx.sendRawTransaction(signed);
+  if (_optionalChain([broadcast, 'optionalAccess', _26 => _26.result]) === false || _optionalChain([broadcast, 'optionalAccess', _27 => _27.code])) {
+    throw new Error(`${_nullishCoalesce(broadcast.code, () => ( "broadcast failed"))}: ${_nullishCoalesce(broadcast.message, () => ( ""))}`);
+  }
+  const txid = _nullishCoalesce(_nullishCoalesce(_optionalChain([broadcast, 'optionalAccess', _28 => _28.txid]), () => ( _optionalChain([broadcast, 'optionalAccess', _29 => _29.transaction, 'optionalAccess', _30 => _30.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 (e5) {
+      continue;
+    }
+    const result = _optionalChain([info, 'optionalAccess', _31 => _31.receipt, 'optionalAccess', _32 => _32.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 (0, _chunk6XTNI2OQcjs.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 (!_optionalChain([route, 'optionalAccess', _33 => _33.router]) || !_optionalChain([route, 'access', _34 => _34.path, 'optionalAccess', _35 => _35.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 (_optionalChain([built, 'optionalAccess', _36 => _36.result, 'optionalAccess', _37 => _37.result]) !== true) {
+      throw new Error(_nullishCoalesce(_optionalChain([built, 'optionalAccess', _38 => _38.result, 'optionalAccess', _39 => _39.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 (_optionalChain([broadcast, 'optionalAccess', _40 => _40.result]) === false || _optionalChain([broadcast, 'optionalAccess', _41 => _41.code])) {
+      throw new Error(`${_nullishCoalesce(broadcast.code, () => ( "broadcast failed"))}: ${_nullishCoalesce(broadcast.message, () => ( ""))}`);
+    }
+    const txid = _nullishCoalesce(_nullishCoalesce(_optionalChain([broadcast, 'optionalAccess', _42 => _42.txid]), () => ( _optionalChain([broadcast, 'optionalAccess', _43 => _43.transaction, 'optionalAccess', _44 => _44.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(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _45 => _45.message]), () => ( err)));
+    if (/energy|bandwidth|balance|insufficient|OUT_OF_ENERGY/i.test(msg)) {
+      throw new (0, _chunk6XTNI2OQcjs.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) {
@@ -129,15 +384,15 @@ async function verifyTron(params) {
   let info;
   try {
     info = await reader.getTransactionInfo(txid);
-  } catch (e2) {
+  } catch (e6) {
     return txNotFound(txid);
   }
   if (!info || !info.id) return txNotFound(txid);
-  if (_optionalChain([info, 'access', _13 => _13.receipt, 'optionalAccess', _14 => _14.result]) !== "SUCCESS") {
+  if (_optionalChain([info, 'access', _46 => _46.receipt, 'optionalAccess', _47 => _47.result]) !== "SUCCESS") {
     return {
       ok: false,
       error: "tx_reverted",
-      detail: `Tron tx ${txid} did not succeed (receipt.result=${_nullishCoalesce(_optionalChain([info, 'access', _15 => _15.receipt, 'optionalAccess', _16 => _16.result]), () => ( "none"))}).`
+      detail: `Tron tx ${txid} did not succeed (receipt.result=${_nullishCoalesce(_optionalChain([info, 'access', _48 => _48.receipt, 'optionalAccess', _49 => _49.result]), () => ( "none"))}).`
     };
   }
   const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(info.blockTimeStamp / 1e3);
@@ -177,11 +432,11 @@ async function verifyTronNative(params) {
   let info;
   try {
     info = await reader.getTransactionInfo(txid);
-  } catch (e3) {
+  } catch (e7) {
     return txNotFound(txid);
   }
   if (!info || !info.id) return txNotFound(txid);
-  if (_optionalChain([info, 'access', _17 => _17.receipt, 'optionalAccess', _18 => _18.result]) && info.receipt.result !== "SUCCESS") {
+  if (_optionalChain([info, 'access', _50 => _50.receipt, 'optionalAccess', _51 => _51.result]) && info.receipt.result !== "SUCCESS") {
     return { ok: false, error: "tx_reverted", detail: `Tron tx ${txid} did not succeed (receipt.result=${info.receipt.result}).` };
   }
   const ageSeconds = Math.floor(Date.now() / 1e3) - Math.floor(info.blockTimeStamp / 1e3);
@@ -195,15 +450,15 @@ async function verifyTronNative(params) {
   let tx;
   try {
     tx = await reader.getTransaction(txid);
-  } catch (e4) {
+  } catch (e8) {
     return txNotFound(txid);
   }
   if (!tx) return txNotFound(txid);
-  const ret = _optionalChain([tx, 'access', _19 => _19.ret, 'optionalAccess', _20 => _20[0], 'optionalAccess', _21 => _21.contractRet]);
+  const ret = _optionalChain([tx, 'access', _52 => _52.ret, 'optionalAccess', _53 => _53[0], 'optionalAccess', _54 => _54.contractRet]);
   if (ret && ret !== "SUCCESS") {
     return { ok: false, error: "tx_reverted", detail: `Tron tx ${txid} did not succeed (contractRet=${ret}).` };
   }
-  const contract = (_nullishCoalesce(_optionalChain([tx, 'access', _22 => _22.raw_data, 'optionalAccess', _23 => _23.contract]), () => ( [])))[0];
+  const contract = (_nullishCoalesce(_optionalChain([tx, 'access', _55 => _55.raw_data, 'optionalAccess', _56 => _56.contract]), () => ( [])))[0];
   if (!contract || contract.type !== "TransferContract") {
     return {
       ok: false,
@@ -211,7 +466,7 @@ async function verifyTronNative(params) {
       detail: `Tron tx ${txid} is not a native TRX transfer (TransferContract).`
     };
   }
-  const value = _nullishCoalesce(_optionalChain([contract, 'access', _24 => _24.parameter, 'optionalAccess', _25 => _25.value]), () => ( {}));
+  const value = _nullishCoalesce(_optionalChain([contract, 'access', _57 => _57.parameter, 'optionalAccess', _58 => _58.value]), () => ( {}));
   const to = String(_nullishCoalesce(value.to_address, () => ( ""))).toLowerCase().replace(/^0x/, "");
   if (to !== payToHex41) {
     return { ok: false, error: "wrong_recipient", detail: `Native TRX in ${txid} was not sent to ${accept.payTo}.` };
@@ -219,7 +474,7 @@ async function verifyTronNative(params) {
   const amount = (() => {
     try {
       return BigInt(_nullishCoalesce(value.amount, () => ( 0)));
-    } catch (e5) {
+    } catch (e9) {
       return 0n;
     }
   })();
@@ -254,7 +509,7 @@ function sumTransfersTo(logs, tokenHex20, payToHex20) {
     try {
       total += BigInt(`0x${log.data}`);
       from = last20(topics[1]);
-    } catch (e6) {
+    } catch (e10) {
     }
   }
   return { total, from };
@@ -273,13 +528,13 @@ function txNotFound(txid) {
 // src/drivers/tron/wallet.ts
 function assertTronWallet(wallet, network) {
   if (typeof wallet !== "object" || wallet === null) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { key } (32-byte hex).`
     );
   }
-  _chunkQONQSZHJcjs.assertNoLegacyWalletKey.call(void 0, wallet, "Tron");
+  _chunk6XTNI2OQcjs.assertNoLegacyWalletKey.call(void 0, wallet, "Tron");
   if (!("key" in wallet)) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
       `chain ${network} is Tron; wallet must be { key } (32-byte hex).`
     );
   }
@@ -287,14 +542,14 @@ function assertTronWallet(wallet, network) {
 }
 function resolveTronPrivateKey(config) {
   if (!config.key) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet needs { key } (32-byte hex).");
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)("Tron wallet needs { key } (32-byte hex).");
   }
   if (typeof config.key !== "string") {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet { key } must be a 32-byte hex string.");
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)("Tron wallet { key } must be a 32-byte hex string.");
   }
   const hex = config.key.replace(/^0x/i, "").toLowerCase();
   if (!/^[0-9a-f]{64}$/.test(hex)) {
-    throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+    throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
       "Tron wallet { key } must be a 32-byte hex string (64 hex chars)."
     );
   }
@@ -344,21 +599,21 @@ function makeTronNetwork(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 Tron (known: ${known}). Note: native USDC doesn't exist on Tron. Pass { address, decimals } for a custom TRC-20.`
           );
         }
         return { asset: info.address, decimals: info.decimals, symbol: info.symbol };
       }
-      _chunkQONQSZHJcjs.rejectForeignToken.call(void 0, token, "tron", network);
+      _chunk6XTNI2OQcjs.rejectForeignToken.call(void 0, token, "tron", network);
       if (!("address" in token)) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Tron; a custom token must be { address, decimals } (Base58 T\u2026 contract).`
         );
       }
       const t = token;
       if (t.address.startsWith("0x") || !tronWeb.isAddress(t.address)) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Tron, but token address "${t.address}" is not a valid Tron contract (T\u2026).`
         );
       }
@@ -377,12 +632,12 @@ function makeTronNetwork(preset, rpcUrl) {
     },
     assertValidPayTo(payTo) {
       if (payTo.startsWith("0x")) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" looks like an EVM address.`
         );
       }
       if (!tronWeb.isAddress(payTo)) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)(
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)(
           `chain ${network} is Tron, but payTo "${payTo}" is not a valid Tron address (T\u2026).`
         );
       }
@@ -394,7 +649,7 @@ function makeTronNetwork(preset, rpcUrl) {
       const privateKey = resolveTronPrivateKey(wallet._native);
       const from = tronWeb.address.fromPrivateKey(privateKey);
       if (!from) {
-        throw new (0, _chunkQONQSZHJcjs.WrongFamilyError)("Tron wallet { key } could not derive an address.");
+        throw new (0, _chunk6XTNI2OQcjs.WrongFamilyError)("Tron wallet { key } could not derive an address.");
       }
       if (accept.asset === "native") {
         return payTronNative({ client: tronWeb, from, privateKey, accept });
@@ -413,15 +668,15 @@ function makeTronNetwork(preset, rpcUrl) {
         try {
           const info = await reader.getTransactionInfo(txid);
           if (info) return { height: String(_nullishCoalesce(info.blockNumber, () => ( 0))) };
-        } catch (e7) {
+        } catch (e11) {
         }
         await _chunkCQREG5LEcjs.delay.call(void 0, 2500);
       }
-      throw new (0, _chunkQONQSZHJcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
+      throw new (0, _chunk6XTNI2OQcjs.ConfirmationTimeoutError)(`Tron tx ${txid} did not solidify in time.`);
     },
     async estimateCost(accept, opts) {
       if (accept.asset === "native") {
-        return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
+        return _chunk6XTNI2OQcjs.nativeCost.call(void 0, {
           symbol: "TRX",
           decimals: TRX_DECIMALS,
           fee: 1300000n,
@@ -431,7 +686,7 @@ function makeTronNetwork(preset, rpcUrl) {
       }
       const ENERGY_PRICE = 420n;
       const BANDWIDTH_SUN = 345000n;
-      if (_optionalChain([opts, 'optionalAccess', _26 => _26.from])) {
+      if (_optionalChain([opts, 'optionalAccess', _59 => _59.from])) {
         try {
           const r = await tronWeb.transactionBuilder.triggerConstantContract(
             accept.asset,
@@ -445,7 +700,7 @@ function makeTronNetwork(preset, rpcUrl) {
           );
           const energy = BigInt(_nullishCoalesce(r.energy_used, () => ( 0)));
           if (energy > 0n) {
-            return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
+            return _chunk6XTNI2OQcjs.nativeCost.call(void 0, {
               symbol: "TRX",
               decimals: TRX_DECIMALS,
               fee: energy * ENERGY_PRICE + BANDWIDTH_SUN,
@@ -453,10 +708,10 @@ function makeTronNetwork(preset, rpcUrl) {
               detail: `energy ${energy} @ ${ENERGY_PRICE} sun + bandwidth`
             });
           }
-        } catch (e8) {
+        } catch (e12) {
         }
       }
-      return _chunkQONQSZHJcjs.nativeCost.call(void 0, {
+      return _chunk6XTNI2OQcjs.nativeCost.call(void 0, {
         symbol: "TRX",
         decimals: TRX_DECIMALS,
         fee: 30000n * ENERGY_PRICE + BANDWIDTH_SUN,
@@ -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 (0, _chunk6XTNI2OQcjs.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)
@@ -481,14 +743,34 @@ function makeTronNetwork(preset, rpcUrl) {
           [{ type: "address", value: owner }],
           owner
         );
-        const hex = _optionalChain([res, 'optionalAccess', _27 => _27.constant_result, 'optionalAccess', _28 => _28[0]]);
+        const hex = _optionalChain([res, 'optionalAccess', _60 => _60.constant_result, 'optionalAccess', _61 => _61[0]]);
         token = hex == null ? null : BigInt("0x" + hex);
-      } catch (e9) {
+      } catch (e13) {
         token = null;
       }
       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" };
     },