@t2000/sdk 0.9.1 → 0.9.4

package/dist/adapters/index.cjs

@@ -503,6 +503,94 @@ async function buildWithdrawTx(client, address, amount, options = {}) {
   tx.transferObjects([coin], address);
   return { tx, effectiveAmount };
 }
+async function addWithdrawToTx(tx, client, address, amount, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
+  const [config, pool, pools, states] = await Promise.all([
+    getConfig(),
+    getPool(asset),
+    getPools(),
+    getUserState(client, address)
+  ]);
+  const assetState = states.find((s) => s.assetId === pool.id);
+  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex) : 0;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
+  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
+  const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
+  addOracleUpdatesForPositions(tx, config, pools, states, pool);
+  const [balance] = tx.moveCall({
+    target: `${config.package}::incentive_v3::withdraw_v2`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.oracle.priceOracle),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      tx.pure.u64(rawAmount),
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3),
+      tx.object(SUI_SYSTEM_STATE)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+  const [coin] = tx.moveCall({
+    target: "0x2::coin::from_balance",
+    arguments: [balance],
+    typeArguments: [pool.suiCoinType]
+  });
+  return { coin, effectiveAmount };
+}
+async function addSaveToTx(tx, _client, _address, coin, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, coin, "save");
+  }
+  const [coinValue] = tx.moveCall({
+    target: "0x2::coin::value",
+    typeArguments: [pool.suiCoinType],
+    arguments: [coin]
+  });
+  tx.moveCall({
+    target: `${config.package}::incentive_v3::entry_deposit`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      coin,
+      coinValue,
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+}
+async function addRepayToTx(tx, client, _address, coin, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  addOracleUpdate(tx, config, pool);
+  const [coinValue] = tx.moveCall({
+    target: "0x2::coin::value",
+    typeArguments: [pool.suiCoinType],
+    arguments: [coin]
+  });
+  tx.moveCall({
+    target: `${config.package}::incentive_v3::entry_repay`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.oracle.priceOracle),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      coin,
+      coinValue,
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+}
 async function buildBorrowTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
     throw new T2000Error("INVALID_AMOUNT", "Borrow amount must be a positive number");
@@ -794,6 +882,18 @@ var NaviAdapter = class {
   async maxBorrow(address, _asset) {
     return maxBorrowAmount(this.client, address);
   }
+  async addWithdrawToTx(tx, address, amount, asset) {
+    const stableAsset = normalizeAsset(asset);
+    return addWithdrawToTx(tx, this.client, address, amount, { asset: stableAsset });
+  }
+  async addSaveToTx(tx, address, coin, asset, options) {
+    const stableAsset = normalizeAsset(asset);
+    return addSaveToTx(tx, this.client, address, coin, { ...options, asset: stableAsset });
+  }
+  async addRepayToTx(tx, address, coin, asset) {
+    const stableAsset = normalizeAsset(asset);
+    return addRepayToTx(tx, this.client, address, coin, { asset: stableAsset });
+  }
 };
 var DEFAULT_SLIPPAGE_BPS = 300;
 function createAggregatorClient(client, signer) {
@@ -838,6 +938,41 @@ async function buildSwapTx(params) {
     toDecimals: toInfo.decimals
   };
 }
+async function addSwapToTx(params) {
+  const { tx, client, address, inputCoin, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  if (!fromInfo || !toInfo) {
+    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+  }
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const aggClient = createAggregatorClient(client, address);
+  const result = await aggClient.findRouters({
+    from: fromInfo.type,
+    target: toInfo.type,
+    amount: rawAmount,
+    byAmountIn: true
+  });
+  if (!result || result.insufficientLiquidity) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
+    );
+  }
+  const slippage = maxSlippageBps / 1e4;
+  const outputCoin = await aggClient.routerSwap({
+    router: result,
+    txb: tx,
+    inputCoin,
+    slippage
+  });
+  const estimatedOut = Number(result.amountOut.toString());
+  return {
+    outputCoin,
+    estimatedOut,
+    toDecimals: toInfo.decimals
+  };
+}
 async function getPoolPrice(client) {
   try {
     const pool = await client.getObject({
@@ -948,6 +1083,18 @@ var CetusAdapter = class {
   async getPoolPrice() {
     return getPoolPrice(this.client);
   }
+  async addSwapToTx(tx, address, inputCoin, from, to, amount, maxSlippageBps) {
+    return addSwapToTx({
+      tx,
+      client: this.client,
+      address,
+      inputCoin,
+      fromAsset: from,
+      toAsset: to,
+      amount,
+      maxSlippageBps
+    });
+  }
 };
 var WAD = 1e18;
 var MIN_HEALTH_FACTOR2 = 1.5;
@@ -1343,6 +1490,95 @@ var SuilendAdapter = class {
     tx.transferObjects([coin], address);
     return { tx, effectiveAmount };
   }
+  async addWithdrawToTx(tx, address, amount, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves(true)]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
+    const positions = await this.getPositions(address);
+    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
+    const effectiveAmount = Math.min(amount, deposited);
+    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
+    const ratio = cTokenRatio(reserve);
+    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::withdraw_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        tx.pure.u64(ctokenAmount)
+      ]
+    });
+    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
+    const [none] = tx.moveCall({
+      target: "0x1::option::none",
+      typeArguments: [exemptionType]
+    });
+    const [coin] = tx.moveCall({
+      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(CLOCK2),
+        ctokens,
+        none
+      ]
+    });
+    return { coin, effectiveAmount };
+  }
+  async addSaveToTx(tx, address, coin, asset, options) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    let capRef;
+    if (caps.length === 0) {
+      const [newCap] = tx.moveCall({
+        target: `${pkg}::lending_market::create_obligation`,
+        typeArguments: [LENDING_MARKET_TYPE],
+        arguments: [tx.object(LENDING_MARKET_ID)]
+      });
+      capRef = newCap;
+    } else {
+      capRef = caps[0].id;
+    }
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, coin, "save");
+    }
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(CLOCK2),
+        coin
+      ]
+    });
+    tx.moveCall({
+      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        typeof capRef === "string" ? tx.object(capRef) : capRef,
+        tx.object(CLOCK2),
+        ctokens
+      ]
+    });
+    if (typeof capRef !== "string") {
+      tx.transferObjects([capRef], address);
+    }
+  }
   async buildBorrowTx(address, amount, asset, options) {
     const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
     const assetInfo = SUPPORTED_ASSETS[assetKey];
@@ -1402,6 +1638,26 @@ var SuilendAdapter = class {
     });
     return { tx };
   }
+  async addRepayToTx(tx, address, coin, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
+    tx.moveCall({
+      target: `${pkg}::lending_market::repay`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        coin
+      ]
+    });
+  }
   async maxWithdraw(address, _asset) {
     const health = await this.getHealth(address);
     let maxAmount;