@t2000/sdk 0.17.13 → 0.17.15

package/dist/adapters/index.d.cts

@@ -1,4 +1,4 @@
-export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-D4cFY__D.cjs';
+export { x as AdapterCapability, y as AdapterPositions, z as AdapterTxResult, K as CetusAdapter, O as HealthInfo, L as LendingAdapter, t as LendingRates, Q as NaviAdapter, U as PerpsAdapter, Z as ProtocolDescriptor, _ as ProtocolRegistry, a1 as SuilendAdapter, d as SwapAdapter, a2 as SwapQuote, a5 as allDescriptors, a6 as cetusDescriptor, a9 as naviDescriptor, ac as sentinelDescriptor, af as suilendDescriptor } from '../index-xQEri-Eu.cjs';
 import '@mysten/sui/transactions';
 import '@mysten/sui/jsonRpc';
 import '@mysten/sui/keypairs/ed25519';

package/dist/adapters/index.d.ts

@@ -1,4 +1,4 @@
-export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-D4cFY__D.js';
+export { x as AdapterCapability, y as AdapterPositions, z as AdapterTxResult, K as CetusAdapter, O as HealthInfo, L as LendingAdapter, t as LendingRates, Q as NaviAdapter, U as PerpsAdapter, Z as ProtocolDescriptor, _ as ProtocolRegistry, a1 as SuilendAdapter, d as SwapAdapter, a2 as SwapQuote, a5 as allDescriptors, a6 as cetusDescriptor, a9 as naviDescriptor, ac as sentinelDescriptor, af as suilendDescriptor } from '../index-xQEri-Eu.js';
 import '@mysten/sui/transactions';
 import '@mysten/sui/jsonRpc';
 import '@mysten/sui/keypairs/ed25519';

package/dist/adapters/index.js

@@ -865,6 +865,173 @@ async function maxBorrowAmount(client, addressOrKeypair) {
   const maxAmount = Math.max(0, hf.supplied * ltv / MIN_HEALTH_FACTOR - hf.borrowed);
   return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR, currentHF: hf.healthFactor };
 }
+var CERT_TYPE = "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT";
+var DEEP_TYPE = "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP";
+var REWARD_FUNDS = {
+  [CERT_TYPE]: "0x7093cf7549d5e5b35bfde2177223d1050f71655c7f676a5e610ee70eb4d93b5c",
+  [DEEP_TYPE]: "0xc889d78b634f954979e80e622a2ae0fece824c0f6d9590044378a2563035f32f"
+};
+var REWARD_SYMBOLS = {
+  [CERT_TYPE]: "vSUI",
+  [DEEP_TYPE]: "DEEP"
+};
+var incentiveRulesCache = null;
+async function getIncentiveRules(client) {
+  if (incentiveRulesCache && Date.now() - incentiveRulesCache.ts < CACHE_TTL) {
+    return incentiveRulesCache.data;
+  }
+  const [pools, obj] = await Promise.all([
+    getPools(),
+    client.getObject({
+      id: "0x62982dad27fb10bb314b3384d5de8d2ac2d72ab2dbeae5d801dbdb9efa816c80",
+      options: { showContent: true }
+    })
+  ]);
+  const rewardCoinMap = /* @__PURE__ */ new Map();
+  for (const pool of pools) {
+    const ct = (pool.suiCoinType || pool.coinType || "").toLowerCase();
+    const suffix = ct.split("::").slice(1).join("::");
+    const coins = pool.supplyIncentiveApyInfo?.rewardCoin;
+    if (Array.isArray(coins) && coins.length > 0) {
+      rewardCoinMap.set(suffix, coins[0]);
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  if (obj.data?.content?.dataType !== "moveObject") {
+    incentiveRulesCache = { data: result, ts: Date.now() };
+    return result;
+  }
+  const fields = obj.data.content.fields;
+  const poolsObj = fields.pools;
+  const entries = poolsObj?.fields?.contents;
+  if (!Array.isArray(entries)) {
+    incentiveRulesCache = { data: result, ts: Date.now() };
+    return result;
+  }
+  for (const entry of entries) {
+    const ef = entry?.fields;
+    if (!ef) continue;
+    const key = String(ef.key ?? "");
+    const value = ef.value;
+    const rules = value?.fields?.rules;
+    const ruleEntries = rules?.fields?.contents;
+    if (!Array.isArray(ruleEntries)) continue;
+    const ruleIds = ruleEntries.map((re) => {
+      const rf = re?.fields;
+      return String(rf?.key ?? "");
+    }).filter(Boolean);
+    const suffix = key.split("::").slice(1).join("::").toLowerCase();
+    const full = key.toLowerCase();
+    const rewardCoin = rewardCoinMap.get(suffix) ?? rewardCoinMap.get(full) ?? null;
+    result.set(key, { ruleIds, rewardCoinType: rewardCoin });
+  }
+  incentiveRulesCache = { data: result, ts: Date.now() };
+  return result;
+}
+function stripPrefix(coinType) {
+  return coinType.replace(/^0x0*/, "");
+}
+async function getPendingRewards(client, address) {
+  const [pools, states, rules] = await Promise.all([
+    getPools(),
+    getUserState(client, address),
+    getIncentiveRules(client)
+  ]);
+  const rewards = [];
+  const deposited = states.filter((s) => s.supplyBalance > 0n);
+  if (deposited.length === 0) return rewards;
+  const rewardTotals = /* @__PURE__ */ new Map();
+  for (const state of deposited) {
+    const pool = pools.find((p) => p.id === state.assetId);
+    if (!pool) continue;
+    const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? "0");
+    if (boostedApr <= 0) continue;
+    const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
+    if (!Array.isArray(rewardCoins) || rewardCoins.length === 0) continue;
+    const rewardType = rewardCoins[0];
+    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex, pool);
+    const price = pool.token?.price ?? 0;
+    const depositUsd = supplyBal * price;
+    const annualRewardUsd = depositUsd * (boostedApr / 100);
+    const estimatedUsd = annualRewardUsd / 365;
+    rewardTotals.set(rewardType, (rewardTotals.get(rewardType) ?? 0) + estimatedUsd);
+  }
+  for (const [coinType, dailyUsd] of rewardTotals) {
+    if (dailyUsd < 1e-3) continue;
+    rewards.push({
+      protocol: "navi",
+      coinType,
+      symbol: REWARD_SYMBOLS[coinType] ?? coinType.split("::").pop() ?? "UNKNOWN",
+      amount: 0,
+      estimatedValueUsd: dailyUsd
+    });
+  }
+  return rewards;
+}
+async function addClaimRewardsToTx(tx, client, address) {
+  const [config, pools, states, rules] = await Promise.all([
+    getConfig(),
+    getPools(),
+    getUserState(client, address),
+    getIncentiveRules(client)
+  ]);
+  const deposited = states.filter((s) => s.supplyBalance > 0n);
+  if (deposited.length === 0) return [];
+  const claimGroups = /* @__PURE__ */ new Map();
+  for (const state of deposited) {
+    const pool = pools.find((p) => p.id === state.assetId);
+    if (!pool) continue;
+    const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? "0");
+    if (boostedApr <= 0) continue;
+    const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
+    if (!Array.isArray(rewardCoins) || rewardCoins.length === 0) continue;
+    const rewardType = rewardCoins[0];
+    const fundId = REWARD_FUNDS[rewardType];
+    if (!fundId) continue;
+    const coinType = pool.suiCoinType || pool.coinType || "";
+    const strippedType = stripPrefix(coinType);
+    const ruleData = Array.from(rules.entries()).find(
+      ([key]) => stripPrefix(key) === strippedType || key.split("::").slice(1).join("::").toLowerCase() === coinType.split("::").slice(1).join("::").toLowerCase()
+    );
+    if (!ruleData || ruleData[1].ruleIds.length === 0) continue;
+    const group = claimGroups.get(rewardType) ?? { assets: [], ruleIds: [] };
+    for (const ruleId of ruleData[1].ruleIds) {
+      group.assets.push(strippedType);
+      group.ruleIds.push(ruleId);
+    }
+    claimGroups.set(rewardType, group);
+  }
+  const claimed = [];
+  for (const [rewardType, { assets, ruleIds }] of claimGroups) {
+    const fundId = REWARD_FUNDS[rewardType];
+    const [balance] = tx.moveCall({
+      target: `${config.package}::incentive_v3::claim_reward`,
+      typeArguments: [rewardType],
+      arguments: [
+        tx.object(CLOCK),
+        tx.object(config.incentiveV3),
+        tx.object(config.storage),
+        tx.object(fundId),
+        tx.pure(bcs.vector(bcs.string()).serialize(assets)),
+        tx.pure(bcs.vector(bcs.Address).serialize(ruleIds))
+      ]
+    });
+    const [coin] = tx.moveCall({
+      target: "0x2::coin::from_balance",
+      typeArguments: [rewardType],
+      arguments: [balance]
+    });
+    tx.transferObjects([coin], address);
+    claimed.push({
+      protocol: "navi",
+      coinType: rewardType,
+      symbol: REWARD_SYMBOLS[rewardType] ?? "UNKNOWN",
+      amount: 0,
+      estimatedValueUsd: 0
+    });
+  }
+  return claimed;
+}
 
 // src/adapters/navi.ts
 var descriptor = {
@@ -952,6 +1119,12 @@ var NaviAdapter = class {
     const normalized = normalizeAsset(asset);
     return addRepayToTx(tx, this.client, address, coin, { asset: normalized });
   }
+  async getPendingRewards(address) {
+    return getPendingRewards(this.client, address);
+  }
+  async addClaimRewardsToTx(tx, address) {
+    return addClaimRewardsToTx(tx, this.client, address);
+  }
 };
 var DEFAULT_SLIPPAGE_BPS = 300;
 function createAggregatorClient(client, signer) {
@@ -1234,6 +1407,26 @@ function computeRates(reserve) {
   const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - reserve.spreadFeeBps / 1e4) * 100;
   return { borrowAprPct, depositAprPct };
 }
+var MS_PER_YEAR = 365.25 * 24 * 3600 * 1e3;
+function computeDepositRewardApr(reserve, allReserves) {
+  if (reserve.depositTotalShares <= 0 || reserve.price <= 0) return 0;
+  const totalDepositValue = reserve.depositTotalShares / 10 ** reserve.mintDecimals * reserve.price;
+  if (totalDepositValue <= 0) return 0;
+  const priceMap = /* @__PURE__ */ new Map();
+  for (const r of allReserves) {
+    if (r.price > 0) priceMap.set(r.coinType, { price: r.price, decimals: r.mintDecimals });
+  }
+  let rewardApr = 0;
+  for (const rw of reserve.depositPoolRewards) {
+    const info = priceMap.get(rw.coinType);
+    if (!info || info.price <= 0) continue;
+    const durationMs = rw.endTimeMs - rw.startTimeMs;
+    if (durationMs <= 0) continue;
+    const annualTokens = rw.totalRewards / 10 ** info.decimals * (MS_PER_YEAR / durationMs);
+    rewardApr += annualTokens * info.price / totalDepositValue * 100;
+  }
+  return rewardApr;
+}
 function cTokenRatio(reserve) {
   if (reserve.ctokenSupply === 0) return 1;
   const totalSupply = reserve.availableAmount + reserve.borrowedAmountWad / WAD - reserve.unclaimedSpreadFeesWad / WAD;
@@ -1253,6 +1446,20 @@ function parseReserve(raw, index) {
   const r = f(raw);
   const coinTypeField = f(r.coin_type);
   const config = f(f(r.config)?.element);
+  const dMgr = f(r.deposits_pool_reward_manager);
+  const rawRewards = Array.isArray(dMgr?.pool_rewards) ? dMgr.pool_rewards : [];
+  const now = Date.now();
+  const depositPoolRewards = rawRewards.map((rw, idx) => {
+    if (rw === null) return null;
+    const rwf = f(rw);
+    return {
+      coinType: str(f(rwf.coin_type)?.name),
+      totalRewards: num(rwf.total_rewards),
+      startTimeMs: num(rwf.start_time_ms),
+      endTimeMs: num(rwf.end_time_ms),
+      rewardIndex: idx
+    };
+  }).filter((rw) => rw !== null && rw.endTimeMs > now && rw.totalRewards > 0);
   return {
     coinType: str(coinTypeField?.name),
     mintDecimals: num(r.mint_decimals),
@@ -1266,7 +1473,10 @@ function parseReserve(raw, index) {
     spreadFeeBps: num(config?.spread_fee_bps),
     interestRateUtils: Array.isArray(config?.interest_rate_utils) ? config.interest_rate_utils.map(num) : [],
     interestRateAprs: Array.isArray(config?.interest_rate_aprs) ? config.interest_rate_aprs.map(num) : [],
-    arrayIndex: index
+    arrayIndex: index,
+    price: num(f(r.price)?.value) / WAD,
+    depositTotalShares: num(dMgr?.total_shares),
+    depositPoolRewards
   };
 }
 function parseObligation(raw) {
@@ -1411,7 +1621,8 @@ var SuilendAdapter = class {
     const reserve = this.findReserve(reserves, asset);
     if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
     const { borrowAprPct, depositAprPct } = computeRates(reserve);
-    return { asset, saveApy: depositAprPct, borrowApy: borrowAprPct };
+    const rewardApr = computeDepositRewardApr(reserve, reserves);
+    return { asset, saveApy: depositAprPct + rewardApr, borrowApy: borrowAprPct };
   }
   async getPositions(address) {
     const supplies = [];
@@ -1428,7 +1639,8 @@ var SuilendAdapter = class {
       const ratio = cTokenRatio(reserve);
       const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
       const { depositAprPct } = computeRates(reserve);
-      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct });
+      const rewardApr = computeDepositRewardApr(reserve, reserves);
+      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct + rewardApr });
     }
     for (const bor of obligation.borrows) {
       const reserve = reserves[bor.reserveIdx];
@@ -1798,6 +2010,109 @@ var SuilendAdapter = class {
     }
     return all;
   }
+  // -- Claim Rewards --------------------------------------------------------
+  isClaimableReward(coinType) {
+    const ct = coinType.toLowerCase();
+    return ct.includes("spring_sui") || ct.includes("deep::deep") || ct.includes("cert::cert");
+  }
+  async getPendingRewards(address) {
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) return [];
+    const [reserves, obligation] = await Promise.all([
+      this.loadReserves(true),
+      this.fetchObligation(caps[0].obligationId)
+    ]);
+    const rewards = [];
+    const rewardEstimates = /* @__PURE__ */ new Map();
+    for (const dep of obligation.deposits) {
+      const reserve = reserves[dep.reserveIdx];
+      if (!reserve) continue;
+      const ratio = cTokenRatio(reserve);
+      const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
+      const price = reserve.price;
+      const depositUsd = amount * price;
+      for (const rw of reserve.depositPoolRewards) {
+        if (!this.isClaimableReward(rw.coinType)) continue;
+        const rewardReserve = reserves.find((r) => {
+          try {
+            return normalizeStructTag(r.coinType) === normalizeStructTag(rw.coinType);
+          } catch {
+            return false;
+          }
+        });
+        const rewardPrice = rewardReserve?.price ?? 0;
+        const rewardDecimals = rewardReserve?.mintDecimals ?? 9;
+        const durationMs = rw.endTimeMs - rw.startTimeMs;
+        if (durationMs <= 0) continue;
+        const annualTokens = rw.totalRewards / 10 ** rewardDecimals * (MS_PER_YEAR / durationMs);
+        const totalDepositValue = reserve.depositTotalShares / 10 ** reserve.mintDecimals * price;
+        if (totalDepositValue <= 0) continue;
+        const userShare = depositUsd / totalDepositValue;
+        const dailyRewardUsd = annualTokens * rewardPrice / 365 * userShare;
+        rewardEstimates.set(rw.coinType, (rewardEstimates.get(rw.coinType) ?? 0) + dailyRewardUsd);
+      }
+    }
+    for (const [coinType, dailyUsd] of rewardEstimates) {
+      if (dailyUsd < 1e-3) continue;
+      const symbol = coinType.includes("spring_sui") ? "SPRING_SUI" : coinType.includes("deep::") ? "DEEP" : coinType.split("::").pop() ?? "UNKNOWN";
+      rewards.push({
+        protocol: "suilend",
+        coinType,
+        symbol,
+        amount: 0,
+        estimatedValueUsd: dailyUsd
+      });
+    }
+    return rewards;
+  }
+  async addClaimRewardsToTx(tx, address) {
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) return [];
+    const [pkg, reserves, obligation] = await Promise.all([
+      this.resolvePackage(),
+      this.loadReserves(true),
+      this.fetchObligation(caps[0].obligationId)
+    ]);
+    const claimsByToken = /* @__PURE__ */ new Map();
+    const claimed = [];
+    for (const dep of obligation.deposits) {
+      const reserve = reserves[dep.reserveIdx];
+      if (!reserve) continue;
+      for (const rw of reserve.depositPoolRewards) {
+        if (!this.isClaimableReward(rw.coinType)) continue;
+        const [coin] = tx.moveCall({
+          target: `${pkg}::lending_market::claim_rewards`,
+          typeArguments: [LENDING_MARKET_TYPE, rw.coinType],
+          arguments: [
+            tx.object(LENDING_MARKET_ID),
+            tx.object(caps[0].id),
+            tx.object(CLOCK2),
+            tx.pure.u64(reserve.arrayIndex),
+            tx.pure.u64(rw.rewardIndex),
+            tx.pure.bool(true)
+          ]
+        });
+        const existing = claimsByToken.get(rw.coinType) ?? [];
+        existing.push(coin);
+        claimsByToken.set(rw.coinType, existing);
+      }
+    }
+    for (const [coinType, coins] of claimsByToken) {
+      if (coins.length > 1) {
+        tx.mergeCoins(coins[0], coins.slice(1));
+      }
+      tx.transferObjects([coins[0]], address);
+      const symbol = coinType.includes("spring_sui") ? "SPRING_SUI" : coinType.includes("deep::") ? "DEEP" : coinType.split("::").pop() ?? "UNKNOWN";
+      claimed.push({
+        protocol: "suilend",
+        coinType,
+        symbol,
+        amount: 0,
+        estimatedValueUsd: 0
+      });
+    }
+    return claimed;
+  }
 };
 var descriptor4 = {
   id: "sentinel",