@t2000/sdk 0.17.14 → 0.17.16

package/dist/adapters/index.cjs

@@ -867,6 +867,172 @@ 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) {
+    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.bcs.vector(bcs.bcs.string()).serialize(assets)),
+        tx.pure(bcs.bcs.vector(bcs.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 = {
@@ -954,6 +1120,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) {
@@ -1278,15 +1450,17 @@ function parseReserve(raw, index) {
   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.filter((rw) => rw !== null).map((rw) => {
+  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)
+      endTimeMs: num(rwf.end_time_ms),
+      rewardIndex: idx
     };
-  }).filter((rw) => rw.endTimeMs > now && rw.totalRewards > 0);
+  }).filter((rw) => rw !== null && rw.endTimeMs > now && rw.totalRewards > 0);
   return {
     coinType: str(coinTypeField?.name),
     mintDecimals: num(r.mint_decimals),
@@ -1837,6 +2011,108 @@ 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 utils.normalizeStructTag(r.coinType) === utils.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) {
+      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",