@t2000/sdk 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -238,39 +238,27 @@ function formatSui(amount) {
 }
 
 // src/wallet/send.ts
-async function buildAndExecuteSend({
+async function buildSendTx({
   client,
-  keypair,
+  address,
   to,
   amount,
   asset = "USDC"
 }) {
   const recipient = validateAddress(to);
   const assetInfo = SUPPORTED_ASSETS[asset];
-  if (!assetInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-  }
-  if (amount <= 0) {
-    throw new T2000Error("INVALID_AMOUNT", "Amount must be greater than zero");
-  }
-  const senderAddress = keypair.getPublicKey().toSuiAddress();
+  if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
+  if (amount <= 0) throw new T2000Error("INVALID_AMOUNT", "Amount must be greater than zero");
   const rawAmount = displayToRaw(amount, assetInfo.decimals);
   const tx = new transactions.Transaction();
+  tx.setSender(address);
   if (asset === "SUI") {
     const [coin] = tx.splitCoins(tx.gas, [rawAmount]);
     tx.transferObjects([coin], recipient);
   } else {
-    const coins = await client.getCoins({
-      owner: senderAddress,
-      coinType: assetInfo.type
-    });
-    if (coins.data.length === 0) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", `No ${asset} coins found`);
-    }
-    const totalBalance = coins.data.reduce(
-      (sum, c) => sum + BigInt(c.balance),
-      0n
-    );
+    const coins = await client.getCoins({ owner: address, coinType: assetInfo.type });
+    if (coins.data.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${asset} coins found`);
+    const totalBalance = coins.data.reduce((sum, c) => sum + BigInt(c.balance), 0n);
     if (totalBalance < rawAmount) {
       throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
         available: Number(totalBalance) / 10 ** assetInfo.decimals,
@@ -279,28 +267,12 @@ async function buildAndExecuteSend({
     }
     const primaryCoin = tx.object(coins.data[0].coinObjectId);
     if (coins.data.length > 1) {
-      tx.mergeCoins(
-        primaryCoin,
-        coins.data.slice(1).map((c) => tx.object(c.coinObjectId))
-      );
+      tx.mergeCoins(primaryCoin, coins.data.slice(1).map((c) => tx.object(c.coinObjectId)));
     }
     const [sendCoin] = tx.splitCoins(primaryCoin, [rawAmount]);
     tx.transferObjects([sendCoin], recipient);
   }
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const gasUsed = result.effects?.gasUsed;
-  const gasCost = gasUsed ? Math.abs(
-    (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9
-  ) : 0;
-  return {
-    digest: result.digest,
-    gasCost
-  };
+  return tx;
 }
 
 // src/wallet/balance.ts
@@ -398,12 +370,6 @@ var NAVI_BALANCE_DECIMALS = 9;
 function clientOpt(client, fresh = false) {
   return { client, ...ENV, ...fresh ? { disableCache: true } : {} };
 }
-function extractGasCost(effects) {
-  if (!effects?.gasUsed) return 0;
-  return Math.abs(
-    (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9
-  );
-}
 function rateToApy(rawRate) {
   if (!rawRate || rawRate === "0") return 0;
   return Number(BigInt(rawRate)) / 10 ** RATE_DECIMALS * 100;
@@ -436,8 +402,7 @@ async function updateOracle(tx, client, address) {
   } catch {
   }
 }
-async function save(client, keypair, amount) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function buildSaveTx(client, address, amount) {
   const rawAmount = Number(usdcToRaw(amount));
   const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
   if (!coins || coins.length === 0) {
@@ -447,25 +412,9 @@ async function save(client, keypair, amount) {
   tx.setSender(address);
   const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
   await lending.depositCoinPTB(tx, USDC_TYPE, coinObj, ENV);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const rates = await getRates();
-  return {
-    success: true,
-    tx: result.digest,
-    amount,
-    apy: rates.USDC.saveApy,
-    fee: 0,
-    gasCost: extractGasCost(result.effects),
-    gasMethod: "self-funded"
-  };
+  return tx;
 }
-async function withdraw(client, keypair, amount) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function buildWithdrawTx(client, address, amount) {
   const state = await lending.getLendingState(address, clientOpt(client, true));
   const usdcPos = findUsdcPosition(state);
   const deposited = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
@@ -477,47 +426,18 @@ async function withdraw(client, keypair, amount) {
   await updateOracle(tx, client, address);
   const withdrawnCoin = await lending.withdrawCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
   tx.transferObjects([withdrawnCoin], address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  return {
-    success: true,
-    tx: result.digest,
-    amount: effectiveAmount,
-    gasCost: extractGasCost(result.effects),
-    gasMethod: "self-funded"
-  };
+  return { tx, effectiveAmount };
 }
-async function borrow(client, keypair, amount) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function buildBorrowTx(client, address, amount) {
   const rawAmount = Number(usdcToRaw(amount));
   const tx = new transactions.Transaction();
   tx.setSender(address);
   await updateOracle(tx, client, address);
   const borrowedCoin = await lending.borrowCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
   tx.transferObjects([borrowedCoin], address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const hf = await lending.getHealthFactor(address, clientOpt(client, true));
-  return {
-    success: true,
-    tx: result.digest,
-    amount,
-    fee: 0,
-    healthFactor: hf,
-    gasCost: extractGasCost(result.effects),
-    gasMethod: "self-funded"
-  };
+  return tx;
 }
-async function repay(client, keypair, amount) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function buildRepayTx(client, address, amount) {
   const rawAmount = Number(usdcToRaw(amount));
   const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
   if (!coins || coins.length === 0) {
@@ -527,23 +447,7 @@ async function repay(client, keypair, amount) {
   tx.setSender(address);
   const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
   await lending.repayCoinPTB(tx, USDC_TYPE, coinObj, { ...ENV, amount: rawAmount });
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const state = await lending.getLendingState(address, clientOpt(client, true));
-  const usdcPos = findUsdcPosition(state);
-  const remainingDebt = usdcPos ? Number(usdcPos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
-  return {
-    success: true,
-    tx: result.digest,
-    amount,
-    remainingDebt,
-    gasCost: extractGasCost(result.effects),
-    gasMethod: "self-funded"
-  };
+  return tx;
 }
 async function getHealthFactor(client, keypair) {
   const address = keypair.getPublicKey().toSuiAddress();
@@ -635,10 +539,6 @@ async function maxBorrowAmount(client, keypair) {
   };
 }
 var DEFAULT_SLIPPAGE_BPS = 300;
-function extractGasCost2(effects) {
-  if (!effects?.gasUsed) return 0;
-  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
-}
 function isA2B(from) {
   return from === "USDC";
 }
@@ -649,9 +549,8 @@ function getCetusSDK() {
   }
   return _cetusSDK;
 }
-async function executeSwap(params) {
-  const { client, keypair, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
-  const address = keypair.getPublicKey().toSuiAddress();
+async function buildSwapTx(params) {
+  const { address, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
   const a2b = isA2B(fromAsset);
   const fromInfo = SUPPORTED_ASSETS[fromAsset];
   const toInfo = SUPPORTED_ASSETS[toAsset];
@@ -682,32 +581,10 @@ async function executeSwap(params) {
     amount: preSwapResult.amount.toString(),
     amount_limit: amountLimit.toString()
   });
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: swapPayload,
-    options: { showEffects: true, showBalanceChanges: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  let actualReceived = 0;
-  if (result.balanceChanges) {
-    for (const change of result.balanceChanges) {
-      if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === address) {
-        const amt = Number(change.amount) / 10 ** toInfo.decimals;
-        if (amt > 0) actualReceived += amt;
-      }
-    }
-  }
-  const expectedOutput = estimatedOut / 10 ** toInfo.decimals;
-  if (actualReceived === 0) actualReceived = expectedOutput;
-  const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
   return {
-    digest: result.digest,
-    fromAmount: amount,
-    fromAsset,
-    toAmount: actualReceived,
-    toAsset,
-    priceImpact,
-    gasCost: extractGasCost2(result.effects)
+    tx: swapPayload,
+    estimatedOut,
+    toDecimals: toInfo.decimals
   };
 }
 async function getPoolPrice(client) {
@@ -984,12 +861,127 @@ async function executeAutoTopUp(client, keypair) {
   };
 }
 
+// src/gas/manager.ts
+function extractGasCost(effects) {
+  if (!effects?.gasUsed) return 0;
+  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
+}
+async function getSuiBalance(client, address) {
+  const bal = await client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type });
+  return BigInt(bal.totalBalance);
+}
+async function trySelfFunded(client, keypair, tx) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const suiBalance = await getSuiBalance(client, address);
+  if (suiBalance < AUTO_TOPUP_THRESHOLD) return null;
+  tx.setSender(address);
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    gasMethod: "self-funded",
+    gasCostSui: extractGasCost(result.effects)
+  };
+}
+async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const canTopUp = await shouldAutoTopUp(client, address);
+  if (!canTopUp) return null;
+  try {
+    await executeAutoTopUp(client, keypair);
+  } catch {
+    return null;
+  }
+  tx.setSender(address);
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    gasMethod: "auto-topup",
+    gasCostSui: extractGasCost(result.effects)
+  };
+}
+async function trySponsored(client, keypair, tx) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  tx.setSender(address);
+  let txBytes;
+  try {
+    txBytes = await tx.build({ client, onlyTransactionKind: true });
+  } catch {
+    return null;
+  }
+  const txBytesBase64 = Buffer.from(txBytes).toString("base64");
+  let sponsoredResult;
+  try {
+    sponsoredResult = await requestGasSponsorship(txBytesBase64, address);
+  } catch {
+    return null;
+  }
+  const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
+  const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
+  const result = await client.executeTransactionBlock({
+    transactionBlock: sponsoredResult.txBytes,
+    signature: [agentSig, sponsoredResult.sponsorSignature],
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const gasCost = extractGasCost(result.effects);
+  reportGasUsage(address, result.digest, gasCost, 0, sponsoredResult.type);
+  return {
+    digest: result.digest,
+    effects: result.effects,
+    gasMethod: "sponsored",
+    gasCostSui: gasCost
+  };
+}
+async function executeWithGas(client, keypair, buildTx) {
+  const errors = [];
+  try {
+    const tx = await buildTx();
+    const result = await trySelfFunded(client, keypair, tx);
+    if (result) return result;
+    errors.push("self-funded: SUI below threshold");
+  } catch (err) {
+    errors.push(`self-funded: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const tx = await buildTx();
+    const result = await tryAutoTopUpThenSelfFund(client, keypair, tx);
+    if (result) return result;
+    errors.push("auto-topup: not eligible (low USDC or sufficient SUI)");
+  } catch (err) {
+    errors.push(`auto-topup: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const tx = await buildTx();
+    const result = await trySponsored(client, keypair, tx);
+    if (result) return result;
+    errors.push("sponsored: returned null");
+  } catch (err) {
+    errors.push(`sponsored: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  throw new T2000Error(
+    "INSUFFICIENT_GAS",
+    `No SUI for gas and Gas Station unavailable. Fund your wallet with SUI or USDC. [${errors.join(" | ")}]`,
+    { reason: "all_gas_methods_exhausted", errors }
+  );
+}
+
 // src/t2000.ts
 var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   keypair;
   client;
   _address;
-  _lastGasMethod = "self-funded";
   constructor(keypair, client) {
     super();
     this.keypair = keypair;
@@ -1043,29 +1035,6 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return { agent, address, sponsored };
   }
   // -- Gas --
-  /**
-   * Ensure the agent has enough SUI for gas.
-   * If SUI is low and USDC is available, auto-swaps $1 USDC → SUI.
-   */
-  async ensureGas() {
-    this._lastGasMethod = "self-funded";
-    const needsTopUp = await shouldAutoTopUp(this.client, this._address);
-    if (!needsTopUp) return;
-    try {
-      const result = await executeAutoTopUp(this.client, this.keypair);
-      this._lastGasMethod = "auto-topup";
-      this.emit("gasAutoTopUp", {
-        usdcSpent: result.usdcSpent,
-        suiReceived: result.suiReceived
-      });
-    } catch {
-      this.emit("gasStationFallback", {
-        reason: "auto-topup failed",
-        method: "self-funded",
-        suiUsed: 0
-      });
-    }
-  }
   /** SuiClient used by this agent — exposed for x402 and other integrations. */
   get suiClient() {
     return this.client;
@@ -1083,24 +1052,23 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (!(asset in SUPPORTED_ASSETS)) {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
     }
-    await this.ensureGas();
-    const result = await buildAndExecuteSend({
-      client: this.client,
-      keypair: this.keypair,
-      to: params.to,
-      amount: params.amount,
-      asset
-    });
+    const sendAmount = params.amount;
+    const sendTo = params.to;
+    const gasResult = await executeWithGas(
+      this.client,
+      this.keypair,
+      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset })
+    );
     const balance = await this.balance();
-    this.emitBalanceChange(asset, params.amount, "send", result.digest);
+    this.emitBalanceChange(asset, sendAmount, "send", gasResult.digest);
     return {
       success: true,
-      tx: result.digest,
-      amount: params.amount,
+      tx: gasResult.digest,
+      amount: sendAmount,
       to: params.to,
-      gasCost: result.gasCost,
+      gasCost: gasResult.gasCostSui,
       gasCostUnit: "SUI",
-      gasMethod: this._lastGasMethod,
+      gasMethod: gasResult.gasMethod,
       balance
     };
   }
@@ -1156,11 +1124,24 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       amount = params.amount;
     }
     const fee = calculateFee("save", amount);
-    await this.ensureGas();
-    const result = await save(this.client, this.keypair, amount);
-    reportFee(this._address, "save", fee.amount, fee.rate, result.tx);
-    this.emitBalanceChange("USDC", amount, "save", result.tx);
-    return { ...result, fee: fee.amount, gasMethod: this._lastGasMethod };
+    const saveAmount = amount;
+    const gasResult = await executeWithGas(
+      this.client,
+      this.keypair,
+      () => buildSaveTx(this.client, this._address, saveAmount)
+    );
+    const rates = await getRates(this.client);
+    reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
+    this.emitBalanceChange("USDC", saveAmount, "save", gasResult.digest);
+    return {
+      success: true,
+      tx: gasResult.digest,
+      amount: saveAmount,
+      apy: rates.USDC.saveApy,
+      fee: fee.amount,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async withdraw(params) {
     let amount;
@@ -1188,10 +1169,21 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
         }
       }
     }
-    await this.ensureGas();
-    const result = await withdraw(this.client, this.keypair, amount);
-    this.emitBalanceChange("USDC", amount, "withdraw", result.tx);
-    return { ...result, gasMethod: this._lastGasMethod };
+    const withdrawAmount = amount;
+    let effectiveAmount = withdrawAmount;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await buildWithdrawTx(this.client, this._address, withdrawAmount);
+      effectiveAmount = built.effectiveAmount;
+      return built.tx;
+    });
+    this.emitBalanceChange("USDC", effectiveAmount, "withdraw", gasResult.digest);
+    return {
+      success: true,
+      tx: gasResult.digest,
+      amount: effectiveAmount,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async maxWithdraw() {
     return maxWithdrawAmount(this.client, this.keypair);
@@ -1206,27 +1198,52 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       });
     }
     const fee = calculateFee("borrow", params.amount);
-    await this.ensureGas();
-    const result = await borrow(this.client, this.keypair, params.amount);
-    reportFee(this._address, "borrow", fee.amount, fee.rate, result.tx);
-    this.emitBalanceChange("USDC", params.amount, "borrow", result.tx);
-    return { ...result, fee: fee.amount, gasMethod: this._lastGasMethod };
+    const borrowAmount = params.amount;
+    const gasResult = await executeWithGas(
+      this.client,
+      this.keypair,
+      () => buildBorrowTx(this.client, this._address, borrowAmount)
+    );
+    const hf = await getHealthFactor(this.client, this.keypair);
+    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
+    this.emitBalanceChange("USDC", borrowAmount, "borrow", gasResult.digest);
+    return {
+      success: true,
+      tx: gasResult.digest,
+      amount: borrowAmount,
+      fee: fee.amount,
+      healthFactor: hf.healthFactor,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async repay(params) {
     let amount;
     if (params.amount === "all") {
-      const hf = await this.healthFactor();
-      amount = hf.borrowed;
+      const hf2 = await this.healthFactor();
+      amount = hf2.borrowed;
       if (amount <= 0) {
         throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
       }
     } else {
       amount = params.amount;
     }
-    await this.ensureGas();
-    const result = await repay(this.client, this.keypair, amount);
-    this.emitBalanceChange("USDC", amount, "repay", result.tx);
-    return { ...result, gasMethod: this._lastGasMethod };
+    const repayAmount = amount;
+    const gasResult = await executeWithGas(
+      this.client,
+      this.keypair,
+      () => buildRepayTx(this.client, this._address, repayAmount)
+    );
+    const hf = await getHealthFactor(this.client, this.keypair);
+    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
+    return {
+      success: true,
+      tx: gasResult.digest,
+      amount: repayAmount,
+      remainingDebt: hf.borrowed,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async maxBorrow() {
     return maxBorrowAmount(this.client, this.keypair);
@@ -1251,28 +1268,51 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
     }
     const fee = calculateFee("swap", params.amount);
-    await this.ensureGas();
-    const result = await executeSwap({
-      client: this.client,
-      keypair: this.keypair,
-      fromAsset,
-      toAsset,
-      amount: params.amount,
-      maxSlippageBps: params.maxSlippage ? params.maxSlippage * 100 : void 0
+    const swapAmount = params.amount;
+    const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
+    let swapMeta = { estimatedOut: 0, toDecimals: 0 };
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await buildSwapTx({
+        client: this.client,
+        address: this._address,
+        fromAsset,
+        toAsset,
+        amount: swapAmount,
+        maxSlippageBps: slippageBps
+      });
+      swapMeta = { estimatedOut: built.estimatedOut, toDecimals: built.toDecimals };
+      return built.tx;
     });
-    reportFee(this._address, "swap", fee.amount, fee.rate, result.digest);
-    this.emitBalanceChange(result.fromAsset, result.fromAmount, "swap", result.digest);
+    const toInfo = SUPPORTED_ASSETS[toAsset];
+    const txDetail = await this.client.getTransactionBlock({
+      digest: gasResult.digest,
+      options: { showBalanceChanges: true }
+    });
+    let actualReceived = 0;
+    if (txDetail.balanceChanges) {
+      for (const change of txDetail.balanceChanges) {
+        if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === this._address) {
+          const amt = Number(change.amount) / 10 ** toInfo.decimals;
+          if (amt > 0) actualReceived += amt;
+        }
+      }
+    }
+    const expectedOutput = swapMeta.estimatedOut / 10 ** swapMeta.toDecimals;
+    if (actualReceived === 0) actualReceived = expectedOutput;
+    const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
+    reportFee(this._address, "swap", fee.amount, fee.rate, gasResult.digest);
+    this.emitBalanceChange(fromAsset, swapAmount, "swap", gasResult.digest);
     return {
       success: true,
-      tx: result.digest,
-      fromAmount: result.fromAmount,
-      fromAsset: result.fromAsset,
-      toAmount: result.toAmount,
-      toAsset: result.toAsset,
-      priceImpact: result.priceImpact,
+      tx: gasResult.digest,
+      fromAmount: swapAmount,
+      fromAsset,
+      toAmount: actualReceived,
+      toAsset,
+      priceImpact,
       fee: fee.amount,
-      gasCost: result.gasCost,
-      gasMethod: this._lastGasMethod
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
     };
   }
   async swapQuote(params) {
@@ -1403,115 +1443,6 @@ function parseMoveAbort(errorStr) {
   return { reason: errorStr };
 }
 
-// src/gas/manager.ts
-function extractGasCost3(effects) {
-  if (!effects?.gasUsed) return 0;
-  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
-}
-async function getSuiBalance(client, address) {
-  const bal = await client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type });
-  return BigInt(bal.totalBalance);
-}
-async function trySelfFunded(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const suiBalance = await getSuiBalance(client, address);
-  if (suiBalance < AUTO_TOPUP_THRESHOLD) return null;
-  tx.setSender(address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "self-funded",
-    gasCostSui: extractGasCost3(result.effects)
-  };
-}
-async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const canTopUp = await shouldAutoTopUp(client, address);
-  if (!canTopUp) return null;
-  try {
-    await executeAutoTopUp(client, keypair);
-  } catch {
-    return null;
-  }
-  tx.setSender(address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "auto-topup",
-    gasCostSui: extractGasCost3(result.effects)
-  };
-}
-async function trySponsored(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  tx.setSender(address);
-  let txBytes;
-  try {
-    txBytes = await tx.build({ client, onlyTransactionKind: true });
-  } catch {
-    return null;
-  }
-  const txBytesBase64 = Buffer.from(txBytes).toString("base64");
-  let sponsoredResult;
-  try {
-    sponsoredResult = await requestGasSponsorship(txBytesBase64, address);
-  } catch {
-    return null;
-  }
-  const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
-  const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
-  const result = await client.executeTransactionBlock({
-    transactionBlock: sponsoredResult.txBytes,
-    signature: [agentSig, sponsoredResult.sponsorSignature],
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const gasCost = extractGasCost3(result.effects);
-  reportGasUsage(address, result.digest, gasCost, 0, sponsoredResult.type);
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "sponsored",
-    gasCostSui: gasCost
-  };
-}
-async function executeWithGas(client, keypair, buildTx) {
-  try {
-    const tx = await buildTx();
-    const result = await trySelfFunded(client, keypair, tx);
-    if (result) return result;
-  } catch {
-  }
-  try {
-    const tx = await buildTx();
-    const result = await tryAutoTopUpThenSelfFund(client, keypair, tx);
-    if (result) return result;
-  } catch {
-  }
-  try {
-    const tx = await buildTx();
-    const result = await trySponsored(client, keypair, tx);
-    if (result) return result;
-  } catch {
-  }
-  throw new T2000Error(
-    "INSUFFICIENT_GAS",
-    "No SUI for gas and Gas Station unavailable. Fund your wallet with SUI or USDC.",
-    { reason: "all_gas_methods_exhausted" }
-  );
-}
-
 exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;