@t2000/sdk 2.13.2 → 2.14.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Transaction } from '@mysten/sui/transactions';
+import { Transaction, coinWithBalance } from '@mysten/sui/transactions';
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
 import BN from 'bn.js';
 import { EventEmitter } from 'eventemitter3';
@@ -695,22 +695,18 @@ async function buildStakeVSuiTx(_client, address, amountMist) {
   return tx;
 }
 async function buildUnstakeVSuiTx(client, address, amountMist) {
-  const coins = await fetchCoinsByType(client, address, VSUI_TYPE);
-  if (coins.length === 0) {
+  const balResp = await client.getBalance({ owner: address, coinType: VSUI_TYPE });
+  const totalBalance = BigInt(balResp.totalBalance);
+  if (totalBalance === 0n) {
     throw new Error("No vSUI found in wallet.");
   }
   const tx = new Transaction();
   tx.setSender(address);
-  const primary = tx.object(coins[0].coinObjectId);
-  if (coins.length > 1) {
-    tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-  }
-  let vSuiCoin;
-  if (amountMist === "all") {
-    vSuiCoin = primary;
-  } else {
-    [vSuiCoin] = tx.splitCoins(primary, [amountMist]);
+  const requested = amountMist === "all" ? totalBalance : amountMist;
+  if (requested > totalBalance) {
+    throw new Error(`Insufficient vSUI: need ${requested} MIST, have ${totalBalance}`);
   }
+  const vSuiCoin = coinWithBalance({ type: VSUI_TYPE, balance: requested })(tx);
   const [suiCoin] = tx.moveCall({
     target: `${VOLO_PKG}::stake_pool::unstake`,
     arguments: [
@@ -731,19 +727,16 @@ async function addStakeVSuiToTx(tx, client, address, input) {
   if (input.inputCoin) {
     suiCoin = input.inputCoin;
   } else {
-    const coins = await fetchCoinsByType(client, address, SUI_TYPE);
-    if (coins.length === 0) {
-      throw new Error("No SUI coins found in wallet");
-    }
-    const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), 0n);
+    const balResp = await client.getBalance({ owner: address, coinType: SUI_TYPE });
+    const totalBalance = BigInt(balResp.totalBalance);
     if (totalBalance < input.amountMist) {
       throw new Error(`Insufficient SUI: need ${input.amountMist} MIST, have ${totalBalance}`);
     }
-    const primary = tx.object(coins[0].coinObjectId);
-    if (coins.length > 1) {
-      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    [suiCoin] = tx.splitCoins(primary, [input.amountMist]);
+    suiCoin = coinWithBalance({
+      type: SUI_TYPE,
+      balance: input.amountMist,
+      useGasCoin: false
+    })(tx);
   }
   const [vSuiCoin] = tx.moveCall({
     target: `${VOLO_PKG}::stake_pool::stake`,
@@ -765,19 +758,16 @@ async function addUnstakeVSuiToTx(tx, client, address, input) {
       [vSuiCoin] = tx.splitCoins(input.inputCoin, [input.amountMist]);
     }
   } else {
-    const coins = await fetchCoinsByType(client, address, VSUI_TYPE);
-    if (coins.length === 0) {
+    const balResp = await client.getBalance({ owner: address, coinType: VSUI_TYPE });
+    const totalBalance = BigInt(balResp.totalBalance);
+    if (totalBalance === 0n) {
       throw new Error("No vSUI found in wallet.");
     }
-    const primary = tx.object(coins[0].coinObjectId);
-    if (coins.length > 1) {
-      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    if (input.amountMist === "all") {
-      vSuiCoin = primary;
-    } else {
-      [vSuiCoin] = tx.splitCoins(primary, [input.amountMist]);
+    const requested = input.amountMist === "all" ? totalBalance : input.amountMist;
+    if (requested > totalBalance) {
+      throw new Error(`Insufficient vSUI: need ${requested} MIST, have ${totalBalance}`);
     }
+    vSuiCoin = coinWithBalance({ type: VSUI_TYPE, balance: requested })(tx);
   }
   const [suiCoin] = tx.moveCall({
     target: `${VOLO_PKG}::stake_pool::unstake`,
@@ -790,22 +780,6 @@ async function addUnstakeVSuiToTx(tx, client, address, input) {
   });
   return { coin: suiCoin, effectiveAmountMist: input.amountMist };
 }
-async function fetchCoinsByType(client, owner, coinType) {
-  const all = [];
-  let cursor;
-  let hasNext = true;
-  while (hasNext) {
-    const page = await client.getCoins({
-      owner,
-      coinType,
-      cursor: cursor ?? void 0
-    });
-    all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
-    cursor = page.nextCursor;
-    hasNext = page.hasNextPage;
-  }
-  return all;
-}
 var VOLO_PKG, VOLO_POOL, VOLO_METADATA, VSUI_TYPE, SUI_SYSTEM_STATE, MIN_STAKE_MIST, VOLO_STATS_URL;
 var init_volo = __esm({
   "src/protocols/volo.ts"() {
@@ -827,52 +801,29 @@ __export(coinSelection_exports, {
   selectAndSplitCoin: () => selectAndSplitCoin,
   selectSuiCoin: () => selectSuiCoin
 });
-function getMergeCache(tx) {
-  let cache = ptbMergeCache.get(tx);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    ptbMergeCache.set(tx, cache);
-  }
-  return cache;
-}
 async function fetchAllCoins(client, owner, coinType) {
-  const ids = [];
-  let totalBalance = 0n;
-  let cursor;
-  let hasNext = true;
-  while (hasNext) {
-    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
-    for (const c of page.data) {
-      ids.push(c.coinObjectId);
-      totalBalance += BigInt(c.balance);
-    }
-    cursor = page.nextCursor;
-    hasNext = page.hasNextPage;
-  }
-  return { ids, totalBalance };
+  const [balance, ids] = await Promise.all([
+    client.getBalance({ owner, coinType }),
+    (async () => {
+      const out = [];
+      let cursor;
+      let hasNext = true;
+      while (hasNext) {
+        const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+        for (const c of page.data) out.push(c.coinObjectId);
+        cursor = page.nextCursor;
+        hasNext = page.hasNextPage;
+      }
+      return out;
+    })()
+  ]);
+  return { ids, totalBalance: BigInt(balance.totalBalance) };
 }
 async function selectAndSplitCoin(tx, client, owner, coinType, amount, options = {}) {
-  const cache = getMergeCache(tx);
-  const cacheKey = `${owner}|${coinType}`;
-  const cached = cache.get(cacheKey);
-  if (cached) {
-    const allowSwapAll2 = options.allowSwapAll ?? true;
-    if (amount !== "all" && amount > cached.remaining && !allowSwapAll2) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance for ${coinType}`, {
-        available: cached.remaining.toString(),
-        required: amount.toString()
-      });
-    }
-    const requested2 = amount === "all" ? cached.remaining : amount;
-    const swapAll2 = amount === "all" || requested2 >= cached.remaining;
-    const effectiveAmount2 = swapAll2 ? cached.remaining : requested2;
-    const coin2 = swapAll2 ? cached.primary : tx.splitCoins(cached.primary, [effectiveAmount2])[0];
-    cached.remaining = swapAll2 ? 0n : cached.remaining - effectiveAmount2;
-    return { coin: coin2, effectiveAmount: effectiveAmount2, swapAll: swapAll2 };
-  }
-  const { ids, totalBalance } = await fetchAllCoins(client, owner, coinType);
-  if (ids.length === 0) {
-    throw new T2000Error("INSUFFICIENT_BALANCE", `No coins found for ${coinType}`);
+  const balanceResp = await client.getBalance({ owner, coinType });
+  const totalBalance = BigInt(balanceResp.totalBalance);
+  if (totalBalance === 0n) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", `No balance found for ${coinType}`);
   }
   const allowSwapAll = options.allowSwapAll ?? true;
   if (amount !== "all" && amount > totalBalance && !allowSwapAll) {
@@ -884,30 +835,29 @@ async function selectAndSplitCoin(tx, client, owner, coinType, amount, options =
   const requested = amount === "all" ? totalBalance : amount;
   const swapAll = amount === "all" || requested >= totalBalance;
   const effectiveAmount = swapAll ? totalBalance : requested;
-  const primary = tx.object(ids[0]);
-  if (ids.length > 1) {
-    tx.mergeCoins(primary, ids.slice(1).map((id) => tx.object(id)));
-  }
-  const coin = swapAll ? primary : tx.splitCoins(primary, [effectiveAmount])[0];
-  cache.set(cacheKey, {
-    primary,
-    remaining: swapAll ? 0n : totalBalance - effectiveAmount
-  });
+  const coin = coinWithBalance({ type: coinType, balance: effectiveAmount })(tx);
   return { coin, effectiveAmount, swapAll };
 }
 async function selectSuiCoin(tx, client, owner, amountMist, sponsoredContext) {
   if (sponsoredContext) {
     const { SUI_TYPE: SUI_TYPE2 } = await Promise.resolve().then(() => (init_token_registry(), token_registry_exports));
-    return selectAndSplitCoin(tx, client, owner, SUI_TYPE2, amountMist);
+    const balanceResp = await client.getBalance({ owner, coinType: SUI_TYPE2 });
+    const totalBalance = BigInt(balanceResp.totalBalance);
+    if (totalBalance < amountMist) {
+      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient SUI balance`, {
+        available: totalBalance.toString(),
+        required: amountMist.toString()
+      });
+    }
+    const coin2 = coinWithBalance({ type: SUI_TYPE2, balance: amountMist, useGasCoin: false })(tx);
+    return { coin: coin2, effectiveAmount: amountMist, swapAll: false };
   }
   const [coin] = tx.splitCoins(tx.gas, [amountMist]);
   return { coin, effectiveAmount: amountMist, swapAll: false };
 }
-var ptbMergeCache;
 var init_coinSelection = __esm({
   "src/wallet/coinSelection.ts"() {
     init_errors();
-    ptbMergeCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -1115,6 +1065,17 @@ async function addSwapToTx(tx, client, address, input) {
   if (input.inputCoin) {
     inputCoin = input.inputCoin;
     effectiveRaw = requestedRaw;
+  } else if (fromType === "0x2::sui::SUI") {
+    const { selectSuiCoin: selectSuiCoin2 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
+    const result = await selectSuiCoin2(
+      tx,
+      client,
+      address,
+      requestedRaw,
+      input.sponsoredContext ?? false
+    );
+    inputCoin = result.coin;
+    effectiveRaw = result.effectiveAmount;
   } else {
     const { selectAndSplitCoin: selectAndSplitCoin2 } = await Promise.resolve().then(() => (init_coinSelection(), coinSelection_exports));
     const result = await selectAndSplitCoin2(tx, client, address, fromType, requestedRaw);
@@ -1521,26 +1482,16 @@ async function buildSendTx({
   const rawAmount = displayToRaw(amount, assetInfo.decimals);
   const tx = new 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: 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,
-        required: amount
-      });
-    }
-    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)));
-    }
-    const [sendCoin] = tx.splitCoins(primaryCoin, [rawAmount]);
-    tx.transferObjects([sendCoin], recipient);
+  const balanceResp = await client.getBalance({ owner: address, coinType: assetInfo.type });
+  const totalBalance = BigInt(balanceResp.totalBalance);
+  if (totalBalance < rawAmount) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
+      available: Number(totalBalance) / 10 ** assetInfo.decimals,
+      required: amount
+    });
   }
+  const sendCoin = asset === "SUI" ? tx.splitCoins(tx.gas, [rawAmount])[0] : coinWithBalance({ type: assetInfo.type, balance: rawAmount })(tx);
+  tx.transferObjects([sendCoin], recipient);
   return tx;
 }
 function addSendToTx(tx, coin, recipient) {
@@ -5487,26 +5438,6 @@ function resolveAssetInfo(asset) {
   }
   throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown asset: ${asset}`);
 }
-async function fetchCoins(client, owner, coinType) {
-  const all = [];
-  let cursor;
-  let hasNext = true;
-  while (hasNext) {
-    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
-    all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
-    cursor = page.nextCursor;
-    hasNext = page.hasNextPage;
-  }
-  return all;
-}
-function mergeCoins(tx, coins) {
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
-  const primary = tx.object(coins[0].coinObjectId);
-  if (coins.length > 1) {
-    tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-  }
-  return primary;
-}
 async function getPositions(client, address) {
   try {
     const naviPositions = await $e(address, {
@@ -5597,13 +5528,15 @@ async function buildSaveTx(client, address, amount, options = {}) {
   }
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-  const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), 0n);
+  const balResp = await client.getBalance({ owner: address, coinType: assetInfo.type });
+  const totalBalance = BigInt(balResp.totalBalance);
+  if (totalBalance === 0n) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} balance found`);
+  }
   const tx = new Transaction();
   tx.setSender(address);
-  const coinObj = mergeCoins(tx, coins);
   const rawAmount = Math.min(Number(stableToRaw(amount, assetInfo.decimals)), Number(totalBalance));
+  const coinObj = coinWithBalance({ type: assetInfo.type, balance: BigInt(rawAmount) })(tx);
   try {
     await Ce(tx, assetInfo.type, coinObj, {
       ...sdkOptions(client),
@@ -5735,18 +5668,19 @@ async function buildRepayTx(client, address, amount, options = {}) {
   }
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with. Withdraw some savings first to get cash.`);
-  const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), 0n);
+  const balResp = await client.getBalance({ owner: address, coinType: assetInfo.type });
+  const totalBalance = BigInt(balResp.totalBalance);
+  if (totalBalance === 0n) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} to repay with. Withdraw some savings first to get cash.`);
+  }
   const rawRequested = Number(stableToRaw(amount, assetInfo.decimals));
   if (Number(totalBalance) < rawRequested && Number(totalBalance) < 1e3) {
     throw new T2000Error("INSUFFICIENT_BALANCE", `Not enough ${assetInfo.displayName} to repay (need $${amount.toFixed(2)}, wallet has ~$${(Number(totalBalance) / 10 ** assetInfo.decimals).toFixed(4)}). Withdraw some savings first.`);
   }
   const tx = new Transaction();
   tx.setSender(address);
-  const coinObj = mergeCoins(tx, coins);
   const rawAmount = Math.min(rawRequested, Number(totalBalance));
-  const [repayCoin] = tx.splitCoins(coinObj, [rawAmount]);
+  const repayCoin = coinWithBalance({ type: assetInfo.type, balance: BigInt(rawAmount) })(tx);
   await refreshOracle(tx, client, address, {
     skipOracle: options.skipOracle,
     skipPythUpdate: options.skipPythUpdate
@@ -6409,10 +6343,10 @@ var ContactManager = class {
   }
 };
 var DEFAULT_CONFIG_DIR = join$1(homedir(), ".t2000");
-async function executeTx(client, signer, buildTx) {
+async function executeTx(client, signer, buildTx, options = {}) {
   const tx = await buildTx();
   tx.setSender(signer.getAddress());
-  const txBytes = await tx.build({ client });
+  const txBytes = await tx.build({ client: options.buildClient ?? client });
   const { signature } = await signer.signTransaction(txBytes);
   const result = await client.executeTransactionBlock({
     transactionBlock: txBytes,
@@ -6514,10 +6448,15 @@ var T2000 = class _T2000 extends EventEmitter {
     this.enforcer.check({ operation: "pay", amount: options.maxPrice ?? 1 });
     const { Mppx } = await import('mppx/client');
     const { sui, USDC } = await import('@suimpp/mpp/client');
+    const { SuiGrpcClient } = await import('@mysten/sui/grpc');
     const client = this.client;
     const signer = this._signer;
     const signerAddress = signer.getAddress();
     let paymentDigest;
+    let gasCostSui = 0;
+    const network = client.network === "testnet" ? "testnet" : "mainnet";
+    const grpcBaseUrl = network === "testnet" ? "https://fullnode.testnet.sui.io" : "https://fullnode.mainnet.sui.io";
+    const grpcClient = new SuiGrpcClient({ baseUrl: grpcBaseUrl, network });
     const mppx = Mppx.create({
       polyfill: false,
       methods: [sui({
@@ -6528,8 +6467,9 @@ var T2000 = class _T2000 extends EventEmitter {
           signPersonalMessage: (bytes) => signer.signPersonalMessage(bytes)
         },
         execute: async (tx) => {
-          const result = await executeTx(client, signer, () => tx);
+          const result = await executeTx(client, signer, () => tx, { buildClient: grpcClient });
           paymentDigest = result.digest;
+          gasCostSui = result.gasCostSui;
           return { digest: result.digest };
         }
       })]
@@ -6557,6 +6497,7 @@ var T2000 = class _T2000 extends EventEmitter {
       body,
       paid,
       cost: paid ? options.maxPrice ?? void 0 : void 0,
+      gasCostSui: paid ? gasCostSui : void 0,
       receipt: paymentDigest ? { reference: paymentDigest, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : void 0
     };
   }
@@ -6586,8 +6527,8 @@ var T2000 = class _T2000 extends EventEmitter {
     let vSuiAmount;
     if (params.amount === "all") {
       amountMist = "all";
-      const coins = await this._fetchCoins(VSUI_TYPE2);
-      vSuiAmount = coins.reduce((sum, c) => sum + Number(c.balance), 0) / 1e9;
+      const bal = await this.client.getBalance({ owner: this._address, coinType: VSUI_TYPE2 });
+      vSuiAmount = Number(bal.totalBalance) / 1e9;
     } else {
       amountMist = BigInt(Math.floor(params.amount * 1e9));
       vSuiAmount = params.amount;
@@ -6643,10 +6584,14 @@ var T2000 = class _T2000 extends EventEmitter {
       if (fromType === "0x2::sui::SUI") {
         [inputCoin] = tx.splitCoins(tx.gas, [rawAmount]);
       } else {
-        const coins = await this._fetchCoins(fromType);
-        if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${params.from} coins found.`);
-        const merged = this._mergeCoinsInTx(tx, coins);
-        [inputCoin] = tx.splitCoins(merged, [rawAmount]);
+        const bal = await this.client.getBalance({ owner: this._address, coinType: fromType });
+        if (BigInt(bal.totalBalance) < rawAmount) {
+          throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${params.from} balance.`, {
+            available: Number(bal.totalBalance) / 10 ** fromDecimals,
+            required: params.amount
+          });
+        }
+        inputCoin = coinWithBalance({ type: fromType, balance: rawAmount })(tx);
       }
       const outputCoin = await buildSwapTx2({
         walletAddress: this._address,
@@ -6903,11 +6848,15 @@ var T2000 = class _T2000 extends EventEmitter {
       if (canPTB) {
         const tx2 = new Transaction();
         tx2.setSender(this._address);
-        const coins = await this._fetchCoins(assetInfo.type);
-        if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-        const merged = this._mergeCoinsInTx(tx2, coins);
         const rawAmount = BigInt(Math.floor(saveAmount * 10 ** assetInfo.decimals));
-        const [inputCoin] = tx2.splitCoins(merged, [rawAmount]);
+        const bal = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
+        if (BigInt(bal.totalBalance) < rawAmount) {
+          throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${assetInfo.displayName} balance`, {
+            available: Number(bal.totalBalance) / 10 ** assetInfo.decimals,
+            required: saveAmount
+          });
+        }
+        const inputCoin = coinWithBalance({ type: assetInfo.type, balance: rawAmount })(tx2);
         await adapter.addSaveToTx(tx2, this._address, inputCoin, asset);
         return tx2;
       }
@@ -7102,52 +7051,6 @@ var T2000 = class _T2000 extends EventEmitter {
       return 0;
     }
   }
-  async _fetchCoins(coinType) {
-    const all = [];
-    let cursor;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getCoins({ owner: this._address, coinType, cursor: cursor ?? void 0 });
-      all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
-      cursor = page.nextCursor;
-      hasNext = page.hasNextPage;
-    }
-    if (all.length > 0) {
-      this._lastFundDigest = void 0;
-      return all;
-    }
-    if (this._lastFundDigest && coinType === SUPPORTED_ASSETS.USDC.type) {
-      const txInfo = await this.client.getTransactionBlock({
-        digest: this._lastFundDigest,
-        options: { showObjectChanges: true }
-      });
-      const coinIds = (txInfo.objectChanges ?? []).filter(
-        (c) => (c.type === "created" || c.type === "mutated") && "objectType" in c && typeof c.objectType === "string" && c.objectType.includes("0x2::coin::Coin") && c.objectType.includes(coinType)
-      ).map((c) => c.objectId);
-      if (coinIds.length > 0) {
-        const objects = await this.client.multiGetObjects({
-          ids: coinIds,
-          options: { showContent: true, showOwner: true }
-        });
-        for (const obj of objects) {
-          if (obj.data?.content?.dataType === "moveObject" && obj.data.owner && typeof obj.data.owner === "object" && "AddressOwner" in obj.data.owner && obj.data.owner.AddressOwner === this._address) {
-            const fields = obj.data.content.fields;
-            all.push({ coinObjectId: obj.data.objectId, balance: String(fields.balance ?? "0") });
-          }
-        }
-      }
-    }
-    return all;
-  }
-  _mergeCoinsInTx(tx, coins) {
-    if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
-    const primary = tx.object(coins[0].coinObjectId);
-    if (coins.length > 1) {
-      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    return primary;
-  }
-  _lastFundDigest;
   async _autoFundFromSavings(shortfall) {
     const positions = await this.positions();
     const savingsTotal = positions.positions.filter((p) => p.type === "save").reduce((sum, p) => sum + p.amount, 0);
@@ -7175,7 +7078,6 @@ var T2000 = class _T2000 extends EventEmitter {
     if (!usdcReceived) {
       throw new T2000Error("WITHDRAW_FAILED", "Withdraw TX did not produce USDC");
     }
-    this._lastFundDigest = result.tx;
   }
   async maxWithdraw() {
     const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
@@ -7244,11 +7146,18 @@ var T2000 = class _T2000 extends EventEmitter {
       if (adapter.addRepayToTx) {
         const tx2 = new Transaction();
         tx2.setSender(this._address);
-        const coins = await this._fetchCoins(targetAssetInfo.type);
-        if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${targetAssetInfo.displayName} coins`);
-        const merged = this._mergeCoinsInTx(tx2, coins);
         const raw = BigInt(Math.floor(repayAmount * 10 ** targetAssetInfo.decimals));
-        const [repayCoin] = tx2.splitCoins(merged, [raw]);
+        const bal = await this.client.getBalance({
+          owner: this._address,
+          coinType: targetAssetInfo.type
+        });
+        if (BigInt(bal.totalBalance) < raw) {
+          throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${targetAssetInfo.displayName} balance for repayment`, {
+            available: Number(bal.totalBalance) / 10 ** targetAssetInfo.decimals,
+            required: repayAmount
+          });
+        }
+        const repayCoin = coinWithBalance({ type: targetAssetInfo.type, balance: raw })(tx2);
         await adapter.addRepayToTx(tx2, this._address, repayCoin, target.asset);
         return tx2;
       }
@@ -7279,20 +7188,23 @@ var T2000 = class _T2000 extends EventEmitter {
       if (canPTB) {
         const tx = new Transaction();
         tx.setSender(this._address);
-        const assetMerged = /* @__PURE__ */ new Map();
         const uniqueAssets = Array.from(new Set(entries.map((e) => e.borrow.asset)));
         for (const asset of uniqueAssets) {
           const info = SUPPORTED_ASSETS[asset];
           if (!info) throw new T2000Error("ASSET_NOT_SUPPORTED", `Cannot repay unknown asset: ${asset}`);
-          const coins = await this._fetchCoins(info.type);
-          if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${info.displayName} coins for repayment`);
-          assetMerged.set(asset, this._mergeCoinsInTx(tx, coins));
+          const required = entries.filter((e) => e.borrow.asset === asset).reduce((sum, e) => sum + BigInt(Math.floor(e.borrow.amount * 10 ** info.decimals)), 0n);
+          const bal = await this.client.getBalance({ owner: this._address, coinType: info.type });
+          if (BigInt(bal.totalBalance) < required) {
+            throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${info.displayName} balance for repayment`, {
+              available: Number(bal.totalBalance) / 10 ** info.decimals,
+              required: Number(required) / 10 ** info.decimals
+            });
+          }
         }
         for (const { borrow, adapter } of entries) {
           const info = SUPPORTED_ASSETS[borrow.asset];
-          const merged = assetMerged.get(borrow.asset);
           const raw = BigInt(Math.floor(borrow.amount * 10 ** info.decimals));
-          const [repayCoin] = tx.splitCoins(merged, [raw]);
+          const repayCoin = coinWithBalance({ type: info.type, balance: raw })(tx);
           await adapter.addRepayToTx(tx, this._address, repayCoin, borrow.asset);
           totalRepaid += borrow.amount;
         }
@@ -7423,8 +7335,8 @@ var T2000 = class _T2000 extends EventEmitter {
         totalGasCost: 0
       };
     }
-    const preUsdcCoins = await this._fetchCoins(USDC_TYPE2);
-    const preUsdcRaw = preUsdcCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+    const preUsdcBal = await this.client.getBalance({ owner: this._address, coinType: USDC_TYPE2 });
+    const preUsdcRaw = BigInt(preUsdcBal.totalBalance);
     const claimResult = await this.claimRewards();
     if (!claimResult.tx) {
       return {
@@ -7447,8 +7359,8 @@ var T2000 = class _T2000 extends EventEmitter {
         const decimals = getDecimalsForCoinType(reward.coinType) ?? 9;
         const rawAmount = BigInt(Math.floor(reward.amount * 10 ** decimals));
         if (rawAmount <= 0n) continue;
-        const coins = await this._fetchCoins(reward.coinType);
-        if (coins.length === 0) continue;
+        const bal = await this.client.getBalance({ owner: this._address, coinType: reward.coinType });
+        if (BigInt(bal.totalBalance) < rawAmount) continue;
         const route = await findSwapRoute2({
           walletAddress: this._address,
           from: reward.coinType,
@@ -7460,10 +7372,9 @@ var T2000 = class _T2000 extends EventEmitter {
         const swapResult = await executeTx(this.client, this._signer, async () => {
           const tx = new Transaction();
           tx.setSender(this._address);
-          const freshCoins = await this._fetchCoins(reward.coinType);
-          if (freshCoins.length === 0) return tx;
-          const merged = this._mergeCoinsInTx(tx, freshCoins);
-          const [inputCoin] = tx.splitCoins(merged, [rawAmount]);
+          const freshBal = await this.client.getBalance({ owner: this._address, coinType: reward.coinType });
+          if (BigInt(freshBal.totalBalance) < rawAmount) return tx;
+          const inputCoin = coinWithBalance({ type: reward.coinType, balance: rawAmount })(tx);
           const outputCoin = await buildSwapTx2({
             walletAddress: this._address,
             route,
@@ -7480,8 +7391,8 @@ var T2000 = class _T2000 extends EventEmitter {
         console.warn(`[compound] Failed to swap ${reward.symbol}:`, err instanceof Error ? err.message : err);
       }
     }
-    const postUsdcCoins = await this._fetchCoins(USDC_TYPE2);
-    const postUsdcRaw = postUsdcCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+    const postUsdcBal = await this.client.getBalance({ owner: this._address, coinType: USDC_TYPE2 });
+    const postUsdcRaw = BigInt(postUsdcBal.totalBalance);
     const gainedRaw = postUsdcRaw > preUsdcRaw ? postUsdcRaw - preUsdcRaw : 0n;
     const depositUsdc = Number(gainedRaw) / 10 ** USDC_DEC;
     let depositTx = "";
@@ -7491,10 +7402,11 @@ var T2000 = class _T2000 extends EventEmitter {
         const depositResult = await executeTx(this.client, this._signer, async () => {
           const tx = new Transaction();
           tx.setSender(this._address);
-          const coins = await this._fetchCoins(USDC_TYPE2);
-          if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins after swap");
-          const merged = this._mergeCoinsInTx(tx, coins);
-          const [inputCoin] = tx.splitCoins(merged, [gainedRaw]);
+          const bal = await this.client.getBalance({ owner: this._address, coinType: USDC_TYPE2 });
+          if (BigInt(bal.totalBalance) < gainedRaw) {
+            throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC available after swap");
+          }
+          const inputCoin = coinWithBalance({ type: USDC_TYPE2, balance: gainedRaw })(tx);
           await adapter.addSaveToTx(tx, this._address, inputCoin, "USDC");
           return tx;
         });
@@ -7990,7 +7902,8 @@ var WRITE_APPENDER_REGISTRY = {
       overlayFee: ctx.overlayFee,
       providers,
       inputCoin: ctx.chainedCoin,
-      precomputedRoute: input.precomputedRoute
+      precomputedRoute: input.precomputedRoute,
+      sponsoredContext: ctx.sponsoredContext
     });
     if (!ctx.isOutputConsumed) {
       tx.transferObjects([result.coin], ctx.sender);